揭開陣列的真面目

Java旅途發表於2020-08-29
陣列

陣列做為一種基礎的資料儲存結構，應用十分廣泛。陣列是用連續的記憶體空間來儲存固定長度的、相同資料型別的一種資料結構。資料結構是跟語言無關的，這裡，使用java來進行陣列的相關操作。陣列的索引是從0開始的。

一 陣列初始化

建立資料有兩種方式，一種是先宣告一個固定長度的資料，然後再給陣列賦值，另一種是直接賦值。

第一種：

資料型別[] 陣列名稱 = new 資料型別[長度];

這裡的[]標識這宣告瞭一個陣列，這個[]除了可以放在資料型別後面，也可以放在陣列名詞後面，效果一樣。假如我申明一個長度為2的long型別的陣列，並賦值：

long[] arr = new long[2];
arr[0] = 1;
arr[1] = 2;

第二種：

資料型別[] 陣列名稱 = {元素1,元素2, ...};

這樣在陣列初始化的時候直接給陣列賦值，陣列的長度由元素的個數決定。

二 自定義類封裝陣列實現資料操作

public class MyArray {
	
    // 自定義陣列
    private long[] arr;
    // 有效資料長度
    private int element;

    public MyArray(){
        arr = new long[9];
    }

    public MyArray(int maxsize){
        arr = new long[maxsize];
    }
    /**
     * 顯示陣列元素
     */
    public void display(){
        System.out.print("[");
        for (int i = 0; i < element; i++) {
            System.out.print(arr[i]+" ");
        }
        System.out.print("]");
    }
}

2.1 新增元素

陣列是用連續的記憶體空間來儲存資料的，則每次新增的時候會往當前陣列的最後一個元素上新增元素，一次就可以加上元素，所以它的複雜度為O(1)，假如定義一個長度為9陣列，陣列中已經有兩個元素，則新增第三個元素如下：

public void add(long value){
    arr[element] = value;
    element++;
}

2.2 根據值查詢元素位置

這種查詢方式也叫做線性查詢，就是根據傳入的值迴圈去遍歷元素，來獲取對應的位置，理論上平均查詢一個元素需要花費N/2次，所以它的複雜度為O(N)。

public int find(long value){
    int i;
    for (i = 0; i < element; i++) {
        if(value == arr[i]){
            break;
        }
    }
    if(i == element){
        return -1;
    }else {
        return i;
    }
}

2.3 根據索引查詢元素

根據索引來查詢元素，也就是獲取對應位置的元素，其複雜度為O(1)。

public long get(int index){
    if(index >= element || index < 0){
        throw new ArrayIndexOutOfBoundsException();
    }else {
        return arr[index];
    }
}

2.4 根據索引刪除元素

刪除對應索引的元素後，我們需要將所有改索引後面的元素，向前移動一位。假如我要刪除索引為2的元素，如下：

理論上平均刪除一個元素，我們需要移動N/2次，所以它複雜度也為O(N)。

public void delete(int index){
    if(index >= element || index < 0){
        throw new ArrayIndexOutOfBoundsException();
    }else {
        for (int i = index; i < element; i++) {
            arr[index] = arr[index+1];
        }
        element --;
    }
}

2.5 修改元素

修改某個位置的元素，直接根據索引就一次就可以修改對應的元素，所以它的複雜度為O(1)。

public void change(int index,long newValue){
    if(index >= element || index < 0){
        throw new ArrayIndexOutOfBoundsException();
    }else {
        arr[index] = newValue;
    }
}

三 有序陣列

有序陣列是陣列的一種特殊型別，有序陣列中的元素按照某種順序進行排列。

3.1 新增元素

在新增元素的時候，將元素按順序新增到某個位置。如下，在一個陣列中新增一個33的元素。

首先，將索引為3的元素移動到索引為4的位置，然後將索引為2的元素移動到索引為3的位置，最後將33新增到索引為2的位置。理論上插入一個元素需要移動元素的個數為N/2個，所以它的複雜度為O(N)。

public void add(long value){
    int i;
    for (i = 0; i < element; i++) {
        if(arr[i]>value){
            break;
        }
    }

    for (int j = element; j > i; j--){
        arr[j] = arr[j-1];
    }
    arr[i] = value;
    element++;
}

3.2 二分法根據元素查詢索引

在無序陣列中，使用線性法進行查詢相關元素，線性法即按索引按個查詢。有序陣列可以使用二分法來查詢元素，二分發是指將一個陣列從中間分成兩個，判斷元素位於哪個陣列中，然後重複這樣的操作。

假如有8個元素的一個陣列，陣列內容為有序的0-7的序列，要查詢5這個元素，第一次分成0-3和4-7兩個陣列，然後再將4-7分成4-5和6-7連個陣列，最後再將4-5分成4和5就查詢出來具體的元素了，這樣分割3次就可以查詢出長度為8的陣列中具體的元素，其複雜度即為O(logN)（logN在計算機中底數一般指的是2，意思為2的幾次方等於n）。

public int search(long value){
    // 中間值
    int middle = 0;
    // 最小值
    int low = 0;
    // 最大值
    int pow = element;
    while (true){
        middle = (low + pow) / 2;
        if(arr[middle] == value){
            return middle;
        }else if (low > pow){
            return -1;
        }else{
            if(arr[middle] > value){
                pow = middle - 1;
            }else{
                low = middle + 1;
            }
        }
    }
}

四 總結

複雜度越低意味著演算法更加優秀，所以O(1) > O(logN) > O(N) > O(N^2)。

演算法 複雜度
線性查詢 O(N)
二分法查詢 O(logN)
無序陣列插入 O(1)
有序陣列插入 O(N)
無序陣列刪除 O(N)
有序陣列刪除 O(N)
  1. 無序陣列插入快，查詢和刪除慢
  2. 有序陣列查詢快，插入和刪除慢

關注我、不迷路

如果覺得文章不錯，歡迎關注、點贊、收藏，你們的支援是我創作的動力，感謝大家。

如果文章寫的有問題，請不要吝嗇，歡迎留言指出，我會及時核查修改。

如果你還想更加深入的瞭解我，可以微信搜尋「Java旅途」進行關注。回覆「1024」即可獲得學習視訊及精美電子書。每天7:30準時推送技術文章，讓你的上班路不在孤獨，而且每月還有送書活動，助你提升硬實力！

相關文章