LinkedList真的是查詢慢增刪快？

你在我家門口發表於2019-02-26

測試結果

廢話不多說，先上測試結果。作者分別在ArrayList和LinkedList的頭部、尾部和中間三個位置插入與查詢100000個元素所消耗的時間來進行對比測試，下面是測試結果
（感謝@Hosalo的指正，在這裡說明一下測試的環境，尾部插入是在空表的基礎上測試的，頭部和中間位置插入是在已存在100000個元素的表上進行測試的）

插入 查詢
ArrayList尾部 26ms 4ms
ArrayList頭部 2887ms 3ms
ArrayList中間 1936ms 4ms
LinkedList尾部 28ms 9ms
LinkedList頭部 15ms 11ms
LinkedList中間 12310ms 11387ms

測試結論

  • ArrayList的查詢效能絕對是一流的，無論查詢的是哪個位置的元素
  • ArrayList除了尾部插入的效能較好外（位置越靠後效能越好），其他位置效能就不如人意了
  • LinkedList在頭尾查詢、插入效能都是很棒的，但是在中間位置進行操作的話，效能就差很遠了，而且跟ArrayList完全不是一個量級的

原始碼分析

我們把Java中的ArrayList和LinkedList就是分別對順序表和雙向連結串列的一種實現，所以在進行原始碼分析之前，我們先來簡單回顧一下資料結構中的順序表與雙向連結串列中的關鍵概念

  • 順序表：需要申請連續的記憶體空間儲存元素，可以通過記憶體中的物理位置直接找到元素的邏輯位置。在順序表中間插入or刪除元素需要把該元素之後的所有元素向前or向後移動。
  • 雙向連結串列：不需要申請連續的記憶體空間儲存元素，需要通過元素的頭尾指標找到前繼與後繼元素（查詢元素的時候需要從頭or尾開始遍歷整個連結串列，直到找到目標元素）。在雙向連結串列中插入or刪除元素不需要移動元素，只需要改變相關元素的頭尾指標即可。

所以我們潛意識會認為：ArrayList查詢快，增刪慢。LinkedList查詢慢，增刪快。但實際上真的是這樣的嗎？我們一起來看看吧。

測試程式

測試程式程式碼基本沒有什麼營養，這裡就不貼出來了，但是得把程式的執行結果貼出來，方便逐個分析。

執行結果

ArrayList尾部插入100000個元素耗時：26ms
LinkedList尾部插入100000個元素耗時：28ms
ArrayList頭部插入100000個元素耗時：859ms
LinkedList頭部插入100000個元素耗時：15ms
ArrayList中間插入100000個元素耗時：1848ms
LinkedList中間插入100000個元素耗時：15981ms
ArrayList頭部讀取100000個元素耗時：7ms
LinkedList頭部讀取100000個元素耗時：11ms
ArrayList尾部讀取100000個元素耗時：12ms
LinkedList尾部讀取100000個元素耗時：9ms
ArrayList中間讀取100000個元素耗時：13ms
LinkedList中間讀取100000個元素耗時：11387ms

ArrayList尾部插入

原始碼

add(E e)方法

    public boolean add(E e) {
        // 檢查是否需要擴容
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        // 直接在尾部新增元素
        elementData[size++] = e;
        return true;
    }
複製程式碼

可以看出，對ArrayList的尾部插入，直接插入即可，無須額外的操作。

LinkedList尾部插入

原始碼

LinkedList中定義了頭尾節點

    /**
     * Pointer to first node.
     */
    transient Node<E> first;

    /**
     * Pointer to last node.
     */
    transient Node<E> last;
複製程式碼

add(E e)方法，該方法中呼叫了linkLast(E e)方法

    public boolean add(E e) {
        linkLast(e);
        return true;
    }
複製程式碼

linkLast(E e)方法，可以看出，在尾部插入的時候，並不需要從頭開始遍歷整個連結串列，因為已經事先儲存了尾結點，所以可以直接在尾結點後面插入元素

    /**
     * Links e as last element.
     */
    void linkLast(E e) {
        // 先把原來的尾結點儲存下來
        final Node<E> l = last;
        // 建立一個新的結點，其頭結點指向last
        final Node<E> newNode = new Node<>(l, e, null);
        // 尾結點置為newNode
        last = newNode;
        if (l == null)
            first = newNode;
        else
            // 修改原先的尾結點的尾結點，使其指向新的尾結點
            l.next = newNode;
        size++;
        modCount++;
    }
複製程式碼

總結

對於尾部插入而言，ArrayList與LinkedList的效能幾乎是一致的

ArrayList頭部插入

原始碼

add(int index, E element)方法，可以看到通過呼叫系統的陣列複製方法來實現了元素的移動。所以，插入的位置越靠前，需要移動的元素就會越多

public void add(int index, E element) {
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        // 把原來陣列中的index位置開始的元素全部複製到index+1開始的位置（其實就是index後面的元素向後移動一位）
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        // 插入元素
        elementData[index] = element;
        size++;
    }
複製程式碼

LinkedList頭部插入

原始碼

add(int index, E element)方法，該方法先判斷是否是在尾部插入，如果是呼叫linkLast()方法，否則呼叫linkBefore()，那麼是否真的就是需要重頭開始遍歷呢？我們一起來看看

    public void add(int index, E element) {
        checkPositionIndex(index);

        if (index == size)
            linkLast(element);
        else
            linkBefore(element, node(index));
    }
複製程式碼

在頭尾以外的位置插入元素當然得找出這個位置在哪裡，這裡面的node()方法就是關鍵所在，這個函式的作用就是根據索引查詢元素，但是它會先判斷index的位置，如果index比size的一半(size >> 1,右移運算，相當於除以2)要小，就從頭開始遍歷。否則，從尾部開始遍歷。從而可以知道，對於LinkedList來說，操作的元素的位置越往中間靠攏，效率就越低

    Node<E> node(int index) {
        // assert isElementIndex(index);

        if (index < (size >> 1)) {
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }
複製程式碼

這個函式的工作就只是負責把元素插入到相應的位置而已，關鍵的工作在node()方法中已經完成了

    void linkBefore(E e, Node<E> succ) {
        // assert succ != null;
        final Node<E> pred = succ.prev;
        final Node<E> newNode = new Node<>(pred, e, succ);
        succ.prev = newNode;
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode;
        size++;
        modCount++;
    }
複製程式碼

總結

  • 對於LinkedList來說，頭部插入和尾部插入時間複雜度都是O(1)
  • 但是對於ArrayList來說，頭部的每一次插入都需要移動size-1個元素，效率可想而知
  • 但是如果都是在最中間的位置插入的話，ArrayList速度比LinkedList的速度快將近10倍

ArrayList、LinkedList查詢

  • 這就沒啥好說的了，對於ArrayList，無論什麼位置，都是直接通過索引定位到元素，時間複雜度O(1)
  • 而對於LinkedList查詢，其核心方法就是上面所說的node()方法，所以頭尾查詢速度極快，越往中間靠攏效率越低

題外話

第一次在掘金擼部落格，希望以後多給大家分享一些有趣的知識！

相關文章