成人国产在线小视频_日韩寡妇人妻调教在线播放_色成人www永久在线观看_2018国产精品久久_亚洲欧美高清在线30p_亚洲少妇综合一区_黄色在线播放国产_亚洲另类技巧小说校园_国产主播xx日韩_a级毛片在线免费

資訊專欄INFORMATION COLUMN

數(shù)據(jù)結(jié)構(gòu)-數(shù)組

894974231 / 1566人閱讀

摘要：數(shù)據(jù)結(jié)構(gòu)數(shù)組數(shù)組數(shù)據(jù)結(jié)構(gòu)中最基本的一個結(jié)構(gòu)就是線性結(jié)構(gòu)，而線性結(jié)構(gòu)又分為連續(xù)存儲結(jié)構(gòu)和離散存儲結(jié)構(gòu)。比如容量，擴容個，沒有意義，很快就滿了容量，擴充個，太多了，容易早證浪費。

數(shù)據(jù)結(jié)構(gòu)-數(shù)組
數(shù)組

數(shù)據(jù)結(jié)構(gòu)中最基本的一個結(jié)構(gòu)就是線性結(jié)構(gòu)，而線性結(jié)構(gòu)又分為連續(xù)存儲結(jié)構(gòu)和離散存儲結(jié)構(gòu)。所謂的連續(xù)存儲結(jié)構(gòu)其實就是數(shù)組。

優(yōu)點：插入塊如果知道坐標可以快速去地存取

缺點：查找慢,刪除慢,大小固定

二次封裝數(shù)組的增刪改查
基類的定義

定義一個工具類名稱-Array

接受的參數(shù)包括基本類型和自定義類型（用泛型來接受，基本類型用包裝類）

自定義屬性兩個：size用來表示數(shù)組的大小，data用來表示一個準確的集合

概念區(qū)分：size表示數(shù)組的大小，capacity表示數(shù)組容量的大小

構(gòu)造函數(shù)：有參構(gòu)造，接受一個int值，用來初始化數(shù)組容量；無參構(gòu)造：給容量一個默認值

toString()方法，輸出數(shù)組的大小和數(shù)組容量的大小，以及數(shù)組中的值

getSize()方法，調(diào)用方通過方法來獲取數(shù)組的大小

getCapacity()方法，調(diào)用方通過方法來獲取數(shù)組容量的大小

isEmpty()方法，調(diào)用方通過方法來判斷數(shù)組是否為空(指的是數(shù)組中是否有值，沒值就為空)

基類的代碼
package com.datastructure.array;

/**
 * @program: test
 * @description: 自定義數(shù)組封裝工具類
 * @author: Mr.Yang
 * @create: 2019-05-01 15:36
 **/
public class Array {

    private Integer size;

    private E[] data;




    /**
     * 有參構(gòu)造函數(shù)
     * @param capacity  封裝data的容量值
     */
    public Array(Integer capacity){
        data= (E[]) new Object[capacity];
        size=0;
    }

    /**
     * 無參構(gòu)造函數(shù)，設(shè)置默認容量為10
     */
    public Array(){
        this(10);
    }

    /**
     * 獲取數(shù)組中的元素個數(shù)
     * @return
     */
    public Integer getSize(){
        return size;
    }

    /**
     * 獲取數(shù)組的容量
     * @return
     */
    public Integer getCapacity(){
        return data.length;
    }

    /**
     * 判斷數(shù)組是否為空
     * @return
     */
    public boolean isEmpty(){
        return size==0;
    }

    @Override
    public String toString(){
        StringBuffer sb = new StringBuffer();
        sb.append(String.format("Array: size = %d , capacity = %d
",size,data.length));
        sb.append("[");
        for(int i =0;i

增


添加的方法




add()方法，兩個參數(shù)，添加元素的索引位置，和元素的值



addFirst()方法，在所有元素的最前面添加



addLast()方法，在所有元素的最后面添加



添加的代碼(增)


/**
     * 在索引為index的位置，插入param
     * 1.假如在索引為2的位置插入元素
     * 2.需要將原來索引為2及其以后的位置向后移動一整位
     * 3.移動完成之后，在索引為2的位置插入指定的值
     * 4.因為數(shù)組中多了一個值，所以size需要+1
     *
     * @param index 元素的索引
     * @param param 值
     */
    public void add(int index, E param) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("添加失敗，索引的值不能小于0，并且索引的值不能大于數(shù)組的大小");
        }
        if (size == data.length) {
            throw new IllegalArgumentException("添加失敗，數(shù)組的大小已經(jīng)等于了數(shù)組容量的大小");
        }
        for (int i = size - 1; i >= index; i--) {
            data[i + 1] = data[i];
        }
        data[index] = param;
        size++;
    }

    /**
     * 在所有元素之前添加值
     *
     * @param param
     */
    public void addFirst(E param) {
        add(0, param);
    }

    /**
     * 在所有元素之后添加值
     *
     * @param param
     */
    public void addLast(E param) {
        add(size, param);
    }


測試代碼


package com.datastructure.array;

/**
 * @program: test
 * @description:
 * @author: Mr.Yang
 * @create: 2019-05-01 16:46
 **/
public class ArrayTest {

    public static void main(String[] args) {
        Array integerArray = new Array(20);
        for(int i = 0; i < 10 ; i ++){
            integerArray.addLast(i);
        }
        System.out.println(integerArray);

        System.out.println("--------------------索引為3的地方添加元素-----------------------");
        integerArray.add(3,666);
        System.out.println(integerArray);

        System.out.println("--------------------所有元素的最后面添加值-----------------------");
        integerArray.addLast(10000);
        System.out.println(integerArray);

        System.out.println("--------------------所有元素的最前面添加值-----------------------");
        integerArray.addFirst(-1);
        System.out.println(integerArray);
    }
}



測試結(jié)果


Array: size = 10 , capacity = 20
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
--------------------索引為3的地方添加元素-----------------------
Array: size = 11 , capacity = 20
[0, 1, 2, 666, 3, 4, 5, 6, 7, 8, 9]
--------------------所有元素的最后面添加值-----------------------
Array: size = 12 , capacity = 20
[0, 1, 2, 666, 3, 4, 5, 6, 7, 8, 9, 10000]
--------------------所有元素的最前面添加值-----------------------
Array: size = 13 , capacity = 20
[-1, 0, 1, 2, 666, 3, 4, 5, 6, 7, 8, 9, 10000]


改


添加的方法



set，兩個參數(shù)，修改的元素的索引位置，和將要修改的值


添加的代碼(改)


/**
     * 修改數(shù)組中元素的值
     * @param index
     * @param param
     */
    public void set(int index,E param){
        if(index<0 || index>= size){
            throw new IllegalArgumentException("獲取失敗，索引值無效");
        }
        data[index]=param;
    }


測試代碼


package com.datastructure.array;

/**
 * @program: test
 * @description:
 * @author: Mr.Yang
 * @create: 2019-05-01 16:46
 **/
public class ArrayTest {

    public static void main(String[] args) {
        Array integerArray = new Array(20);
        for (int i = 0; i < 10; i++) {
            integerArray.addLast(i);
        }
        System.out.println(integerArray);

        System.out.println("--------------------索引為3的地方修改值為1010-----------------------");
        integerArray.set(3, 1010);
        System.out.println(integerArray);

    }
}



測試結(jié)果


Array: size = 10 , capacity = 20
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
--------------------索引為3的地方修改值為1010-----------------------
Array: size = 10 , capacity = 20
[0, 1, 2, 1010, 4, 5, 6, 7, 8, 9]


查


添加的方法




get()方法，一個參數(shù)，索引值，根據(jù)索引返回對應(yīng)的值



contains()方法，一個參數(shù)，判斷數(shù)組中是否包含某個元素



find()方法，一個參數(shù)，查找數(shù)組中是否包含param，如果包含返回索引值，不包含返回-1



findAll()方法，一個參數(shù)，查找數(shù)組中是否包含param，返回包含的索引數(shù)組



添加的代碼(查)


 /**
     * 獲取索引位置的元素
     * @param index
     * @return
     */
    public E get(Integer index){
        if(index<0 || index>=size){
            throw new IllegalArgumentException("獲取失敗，索引的值不能小于0，并且索引的值不能大于等于數(shù)組的大小");
        }
        return data[index];
    }

    /**
     * 查看數(shù)組中是否包含某個元素
     * @param param
     * @return
     */
    public boolean contains(E param){
        for(int i = 0 ; i < size ; i++){
            if(data[i] == param){
                return true;
            }
        }
        return false;
    }


    /**
     * 查找數(shù)組中是否包含param，如果包含返回索引值，不包含返回-1
     * @param param
     * @return
     */
    public Integer find(E param){
        for(int i = 0 ; i < size ; i++){
            if(data[i] == param){
                return i;
            }
        }
        return -1;
    }

    /**
     * 查找數(shù)組中是否包含param
     * 1.創(chuàng)建一個int數(shù)組用來接收返回的索引值
     * 2.索引容量最大為數(shù)組的大小
     * 3.用臨時變量來存儲int數(shù)組的大小
     * 4.如果相等，給 int數(shù)組 為臨時變量的元素賦值(相等的索引)，臨時變量自增
     * @param param
     * @return
     */
    public Integer[] findAll(E param){
        int intTemp=0;
        Integer[] integers = new Integer[size];
        for(int i = 0 ; i < size ; i++){
            if(data[i] == param){
                integers[intTemp]=i;
                intTemp++;
            }
        }
        return integers;
    }


測試代碼


package com.datastructure.array;

import java.util.Arrays;

/**
 * @program: test
 * @description:
 * @author: Mr.Yang
 * @create: 2019-05-01 16:46
 **/
public class ArrayTest {

    public static void main(String[] args) {
        Array integerArray = new Array(20);
        for (int i = 0; i < 10; i++) {
            integerArray.addLast(i);
        }
        integerArray.addLast(3);

        System.out.println(integerArray);

        System.out.println("--------------------得到索引為3的值-----------------------");
        System.out.println(integerArray.get(3));

        System.out.println("--------------------判斷是否包含有包含3的值-----------------------");
        System.out.println(integerArray.contains(3));

        System.out.println("--------------------查找是否包含參數(shù)，并返回索引-----------------------");
        System.out.println(integerArray.find(3));

        System.out.println("--------------------查找是否包含參數(shù)，并返回索引數(shù)組-----------------------");
        System.out.println(Arrays.asList(integerArray.findAll(3)));

    }
}



測試結(jié)果


Array: size = 11 , capacity = 20
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 3]
--------------------得到索引為3的值-----------------------
3
--------------------判斷是否包含有包含3的值-----------------------
true
--------------------查找是否包含參數(shù)，并返回索引-----------------------
3
--------------------查找是否包含參數(shù)，并返回索引數(shù)組-----------------------
[3, 10, null, null, null, null, null, null, null, null, null]


刪


添加的方法




remove()方法，數(shù)組中刪除index位置的元素，并且返回對應(yīng)的值



removeFirst()方法，刪除第一位元素



removeLast()方法，刪除最后一位元素



removeElement()方法，查看某個值是否在數(shù)組中存在，如果存在,刪除并返回true，如果不存在 返回false、



removeLast()方法， 查找所有元素，獲取所有相等的索引，遍歷移除



添加的代碼(刪)


/**
     * 從數(shù)組中刪除index位置的元素，并且返回對應(yīng)的值
     * 1.假如刪除索引為3的元素
     * 2.需要將索引大于3的元素向前移動一位
     * 3.因為數(shù)組中少了一個值，所以元素-1
     * 4.用臨時變量來存儲刪除的值，用來返回
     * @param index
     * @return
     */
    public E remove(int index){
        if(index<0 || index>=size){
            throw new IllegalArgumentException("刪除失敗，索引的值不能小于0，并且索引的值不能大于等于數(shù)組的大小");
        }
        E temp=data[index];
        for(int i = index+1 ; i < size ; i++){
            data[i-1]=data[i];
        }
        size--;
        return temp;
    }

    /**
     * 刪除第一位元素
     * @return
     */
    public E removeFirst(){
        return remove(0);
    }

    /**
     * 刪除最后一位元素
     */
    public E removeLast(){
        return remove(size-1);
    }

    /**
     * 查看某個值是否在數(shù)組中存在，如果存在,刪除并返回true，如果不存在 返回false
     * @param param
     */
    public boolean removeElement(E param){
        Integer index = find(param);
        if(index != -1){
            remove(index);
            return true;
        }
        return false;
    }

   /**
     * 遍歷數(shù)組，移除元素
     * @param param
     */
    public void removeAllElement(E param){
        for(E d:data){
            removeElement(param);
        }
    }


測試代碼


package com.datastructure.array;

import java.util.Arrays;

/**
 * @program: test
 * @description:
 * @author: Mr.Yang
 * @create: 2019-05-01 16:46
 **/
public class ArrayTest {

    public static void main(String[] args) {
        Array integerArray = new Array(20);
        for (int i = 0; i < 10; i++) {
            integerArray.addLast(i);
        }
        integerArray.addLast(3);
        integerArray.addLast(4);

        System.out.println(integerArray);

        System.out.println("--------------------數(shù)組中刪除6位置的元素，并且返回對應(yīng)的值-----------------------");
        System.out.println(integerArray.remove(6));
        System.out.println(integerArray);

        System.out.println("--------------------刪除第一位元素-----------------------");
        System.out.println(integerArray.removeFirst());
        System.out.println(integerArray);

        System.out.println("--------------------刪除最后一位元素-----------------------");
        System.out.println(integerArray.removeLast());
        System.out.println(integerArray);

        System.out.println("--------------------查看8是否在數(shù)組中存在，返回true和fals-----------------------");
        System.out.println(integerArray.removeElement(8));
        System.out.println(integerArray);

        System.out.println("--------------------查找所有元素，獲取所有相等的索引，遍歷移除-----------------------");
        integerArray.removeAllElement(3);
        System.out.println(integerArray);

    }
}



測試結(jié)果


Array: size = 12 , capacity = 20
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 3, 4]
--------------------數(shù)組中刪除6位置的元素，并且返回對應(yīng)的值-----------------------
6
Array: size = 11 , capacity = 20
[0, 1, 2, 3, 4, 5, 7, 8, 9, 3, 4]
--------------------刪除第一位元素-----------------------
0
Array: size = 10 , capacity = 20
[1, 2, 3, 4, 5, 7, 8, 9, 3, 4]
--------------------刪除最后一位元素-----------------------
4
Array: size = 9 , capacity = 20
[1, 2, 3, 4, 5, 7, 8, 9, 3]
--------------------查看8是否在數(shù)組中存在，如果存在,刪除并返回true，如果不存在 返回false、-----------------------
true
Array: size = 8 , capacity = 20
[1, 2, 3, 4, 5, 7, 9, 3]
--------------------查找所有元素，獲取所有相等的索引，遍歷移除-----------------------
Array: size = 6 , capacity = 20
[1, 2, 4, 5, 7, 9]


數(shù)組動態(tài)擴容


添加的方法



resize()方法，定義為私有，調(diào)用方不能通過方法來調(diào)用，去修改，否則容易造成BUG


擴容倍數(shù)，如果用固定值，不好抉擇。比如：100容量，擴容10個，沒有意義，很快就滿了；100容量，擴充1000個，太多了，容易早證浪費。最好選擇倍數(shù)，都在同一個單位級別，這里代碼選擇的是2倍


添加的時候需要判斷擴容，刪除的時候需要刪除容量，減少資源浪費


刪除的時候，當元素減少到容量的1/4的時候開始縮，縮減到容量的1/2


如果選擇1/2的時候開始縮減，然后縮減到1/2會有一定的問題，例如：容量10，現(xiàn)在容量滿了，來了一個元素，需要擴容，按照設(shè)置的擴容機制，會擴容2倍，也就是20容量，如果刪除了一個元素，元素達到了容量的1/2，我們開始進行縮減，縮減1/2，容量又變?yōu)?0。如果一直在這個臨界值，那么元素會一直進行擴容縮減擴容縮減，性能影響太大。


如果選擇1/4的時候開始縮減，然后縮減到1/2，這樣能夠較好的避開以上問題，例如：容量10，容量滿了，來了一個元素，擴容容量到了20，如果刪除一個元素，還不到容量的1/4，所以還不會進行縮減，如果真的到了容量的1/4的時候，我們選擇縮減1/2，容量也需要一定的元素，才會進行擴容，防止了容量一直擴容或者縮減



添加的代碼


    /**
     * 擴容方法
     * 1.需要new一個object，new E[i]  java不支持這樣寫
     * 2.object是所有類的基類，用object然后強轉(zhuǎn)一下就可以
     * 3.擴展之后，需要將原數(shù)組中的值，放入擴展之后的數(shù)組中
     * @param newCapacity
     */
    private void resize(int newCapacity) {
        E[] newData = (E[]) new Object[newCapacity];
        for(int i=0;i

修改的代碼


add() 和 remove()


/**
     * 在索引為index的位置，插入param
     * 1.假如在索引為2的位置插入元素
     * 2.需要將原來索引為2及其以后的位置向后移動一整位
     * 3.移動完成之后，在索引為2的位置插入指定的值
     * 4.因為數(shù)組中多了一個值，所以size需要+1
     *
     * @param index 元素的索引
     * @param param 值
     */
    public void add(int index, E param) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("添加失敗，索引的值不能小于0，并且索引的值不能大于數(shù)組的大小");
        }
        if (size == data.length) {
            resize(2 * data.length);
        }
        for (int i = size - 1; i >= index; i--) {
            data[i + 1] = data[i];
        }
        data[index] = param;
        size++;
    }


/**
     * 從數(shù)組中刪除index位置的元素，并且返回對應(yīng)的值
     * 1.假如刪除索引為3的元素
     * 2.需要將索引大于3的元素向前移動一位
     * 3.因為數(shù)組中少了一個值，所以元素-1
     * 4.用臨時變量來存儲刪除的值，用來返回
     * @param index
     * @return
     */
    public E remove(int index){
        if(index<0 || index>=size){
            throw new IllegalArgumentException("刪除失敗，索引的值不能小于0，并且索引的值不能大于等于數(shù)組的大小");
        }
        E temp=data[index];
        for(int i = index+1 ; i < size ; i++){
            data[i-1]=data[i];
        }
        size--;
        if(size == data.length / 4 ){
            resize(data.length / 2 );
        }
        return temp;
    }


測試代碼


package com.datastructure.array;

import java.util.Arrays;

/**
 * @program: test
 * @description:
 * @author: Mr.Yang
 * @create: 2019-05-01 16:46
 **/
public class ArrayTest {

    public static void main(String[] args) {
        Array integerArray = new Array(10);
        for (int i = 0; i < 10; i++) {
            integerArray.addLast(i);
        }
        System.out.println(integerArray);

        System.out.printf("--------------------將容量設(shè)置為10，添加10個元素，元素的容量 : %d -------------------
",integerArray.getCapacity());

        integerArray.addLast(21);
        System.out.printf("--------------------元素+1，元素的容量 : %d --------------------
",integerArray.getCapacity());


        integerArray.removeLast();
        System.out.printf("--------------------元素-1，元素的容量 : %d --------------------
",integerArray.getCapacity());

        integerArray.removeLast();
        System.out.printf("--------------------元素-1，元素的容量 : %d --------------------
",integerArray.getCapacity());

        for(int x=0;x<=5;x++){
            integerArray.removeLast();
        }
        System.out.printf("--------------------元素-1/4，元素的容量 : %d --------------------
",integerArray.getCapacity());


    }
}



測試結(jié)果


Array: size = 10 , capacity = 10
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
--------------------將容量設(shè)置為10，添加10個元素，元素的容量 : 10 -------------------
--------------------元素+1，元素的容量 : 20 --------------------
--------------------元素-1，元素的容量 : 20 --------------------
--------------------元素-1，元素的容量 : 20 --------------------
--------------------元素-1/4，元素的容量 : 10 --------------------

文章版權(quán)歸作者所有，未經(jīng)允許請勿轉(zhuǎn)載,若此文章存在違規(guī)行為，您可以聯(lián)系管理員刪除。

轉(zhuǎn)載請注明本文地址：http://systransis.cn/yun/74390.html

相關(guān)文章

  • JavaScript 之 核心語法 [ 數(shù)組 ]

    摘要：數(shù)組描述表示可以儲存一個或多個數(shù)據(jù)值的有序集合數(shù)組中儲存的數(shù)據(jù)中可以稱為元素數(shù)組中可以儲存任何類型的數(shù)據(jù)語法字面量方式數(shù)組名稱元素，元素，構(gòu)造函數(shù)方式數(shù)組名稱元素元素函數(shù)方式數(shù)組名稱元素元素長度表示數(shù)組的長度數(shù)組中儲存元素的個數(shù)當使用 數(shù)組 描述 表示可以儲存一個或多個數(shù)據(jù)值的有序集合 數(shù)組中儲存的數(shù)據(jù)中可以稱為元素 數(shù)組中可以儲存任何類型的數(shù)據(jù) 語法 字面量方式 - var 數(shù)...

    mumumu 評論0 收藏0

  • 減小程序規(guī)模！稀疏數(shù)組Sparsearray，數(shù)據(jù)結(jié)構(gòu)二維數(shù)組與稀疏數(shù)組轉(zhuǎn)換，Java實現(xiàn)

    摘要：文章目錄基本介紹應(yīng)用實例基本介紹當一個數(shù)組中大部分元素為，或者為同一個值的數(shù)組時，可以使用稀疏數(shù)組來保存該數(shù)組。把具有不同值的元素的行列及值記錄在一個小規(guī)模的數(shù)組中，從而縮小程序的規(guī)模。 ...

    jonh_felix 評論0 收藏0

  • JavaScript數(shù)據(jù)結(jié)構(gòu)與算法——數(shù)組

    摘要：數(shù)據(jù)結(jié)構(gòu)的分類數(shù)據(jù)結(jié)構(gòu)是指相互之間存在著一種或多種關(guān)系的數(shù)據(jù)元素的集合和該集合中數(shù)據(jù)元素之間的關(guān)系組成。數(shù)據(jù)一般存儲著一系列數(shù)據(jù)類型相同的值，但在中，可以在數(shù)組中保存不同類型的值，但一般不需要這么用。 數(shù)據(jù)結(jié)構(gòu)的分類 數(shù)據(jù)結(jié)構(gòu)是指相互之間存在著一種或多種關(guān)系的數(shù)據(jù)元素的集合和該集合中數(shù)據(jù)元素之間的關(guān)系組成 。 常用的數(shù)據(jù)結(jié)構(gòu)有：數(shù)組，棧，鏈表，隊列，樹，圖，堆，散列表等，如圖所示： ...

    codeKK 評論0 收藏0

  • 重讀《學習JavaScript數(shù)據(jù)結(jié)構(gòu)與算法-第三版》- 第3章 數(shù)組（一）

    摘要：此處應(yīng)該有掌聲前言讀學習數(shù)據(jù)結(jié)構(gòu)與算法第章數(shù)組，本節(jié)將為各位小伙伴分享數(shù)組的相關(guān)知識概念創(chuàng)建方式常見方法以及數(shù)組的新功能。數(shù)組數(shù)組是最簡單的內(nèi)存數(shù)據(jù)結(jié)構(gòu)，用于存儲一系列同一種數(shù)據(jù)類型的值。 定場詩 大將生來膽氣豪，腰橫秋水雁翎刀。 風吹鼉鼓山河動，電閃旌旗日月高。 天上麒麟原有種，穴中螻蟻豈能逃。 太平待詔歸來日，朕與先生解戰(zhàn)袍。 此處應(yīng)該有掌聲... 前言 讀《學習JavaScrip...

    iKcamp 評論0 收藏0

  • 【數(shù)據(jù)科學系統(tǒng)學習】Python # 數(shù)據(jù)分析基本操作[一] numpy

    摘要：提供了使我們能夠快速便捷地處理結(jié)構(gòu)化數(shù)據(jù)的大量數(shù)據(jù)結(jié)構(gòu)和函數(shù)。結(jié)構(gòu)化數(shù)據(jù)，例如多維數(shù)據(jù)矩陣表格行數(shù)據(jù)，其中各列可能是不同的類型字符串數(shù)值日期等?；A(chǔ)數(shù)組和矢量計算高性能科學計算和數(shù)據(jù)分析的基礎(chǔ)包。 本篇內(nèi)容為整理《利用Python進行數(shù)據(jù)分析》，博主使用代碼為 Python3，部分內(nèi)容和書本有出入。 利用 Python 進行科學計算的實用指南。本書重點介紹了用于高效解決各種數(shù)據(jù)分析問...

    wushuiyong 評論0 收藏0

  • 《JavaScript數(shù)據(jù)結(jié)構(gòu)與算法》筆記——第2章 數(shù)組

    數(shù)組操作方法 方法 描述 備注 push() 將元素添加到數(shù)組末尾 修改原數(shù)組 unShift() 將元素插入到數(shù)組首位（將每項向后移動一位，在第一位插入元素） 修改原數(shù)組 pop() 刪除數(shù)組最后一個元素 修改原數(shù)組 shift() 刪除數(shù)組第一個元素（將每項向前移動一位并刪除最后一項） ...

    Martin91 評論0 收藏0

發(fā)表評論

0條評論

最新活動
閱讀需要支付1元查看
<