上一章我們手寫了ArrayList的核心原始碼，ArrayList底層是用了一個數組來儲存資料，陣列儲存資料的優點就是查詢效率高，但是刪除效率特別低，最壞的情況下需要移動所有的元素。在查詢需求比較重要的情況下可以用ArrayList，如果是刪除操作比較多的情況下，用ArrayList就不太合適了。Java為我們提供了LinkedList，是用連結來實現的，我們今天就來手寫一個QLinkedList，來提示底層是怎麼做的。

如上圖，底層用一個雙鏈表，另外有兩個指示器，一個指向頭，一個指向尾。
連結串列中的每個節點的next指向下一個節點，同理pre指向上一個節點，第一個節點的pre為null，最後一個節點的next為null

雙鏈表的細節實現較多，尤其是邊界的問題，要十分仔細，LinkedList中設計了許多的小函式，本例中就不設計那麼多的小方法了，直接把最核心的程式碼都寫到一個方法中。以方便揭示核心原理。

下面是完整的QLinkedList的原始碼，註釋很清楚。

public class QLinkedList<T> {
    private QNode<T> first; //指向頭節點
    private QNode<T> last;  //指向尾節點

    private int size;    //節點的個數

    //節點類
    public static class QNode<T> {
        T value;        //資料
        QNode<T> pre;   //指向上一個節點
        QNode<T> next;  //指向下一個節點


        public QNode(QNode<T> pre, QNode<T> next, T value) {
            this.pre = pre;     //節點的上一個指向
            this.next = next;   //節點的下一個指向
            this.value = value; //存放的資料
        }
    }

    public QLinkedList() {

        //預設是一個空狼連結串列，first,last都為null, 節點個數為0
        first = null;
        last = null;
        size = 0;
    }

    //預設新增到尾
    public void add(T e) {
        addLast(e);
    }

    //新增到頭部
    public void addFirst(T e) {
        if (first == null && last == null) {
            QNode<T> node = new QNode<>(null, null, e);
            first = node;
            last = node;
        } else {
            QNode<T> node = new QNode<>(null, first, e);
            first.pre = node;
        }

        size++;
    }

    //新增到尾部,我們預設新增的都是不為null的資料
    public void addLast(T e) {
        if (e == null) {
            throw new RuntimeException("e == null");
        }

        //1 連結串列還是空的時候
        if (size == 0) {

            //1.1 新建一個節點，pre,next都為null
            QNode<T> node = new QNode(null, null, e);

            //1.2 只有一個節點，first,last都指向null
            first = node;
            last = node;


        //2 連結串列不為空
        } else {

            //2.1 新建一個節點，pre指向last最後一個節點，next為null(因為是最後一個節點)
            QNode<T> node = new QNode<>(last, null, e);

            //2.2 同時之前的最後一節點的next 指向新建的node節點
            last.next = node;

            //2.3 然後移動last，讓last指向最後一個節點
            last = node;
        }

        //新增一個節點後，別忘了節點的總數加 1
        size++;
    }

    // position 從 0 開始
    // 這裡面有個小技巧，可以先判斷一下 position 是大於 size/2 還是小於 size/2
    // 如果 position > size / 2 , 說明position是在連結串列的後半段，我們可以從last開始往前遍歷
    // 如果 position < size / 2, 說明position是在連結串列的前半段，我們可以從first開始往後遍歷
    // 這樣效率會高許多，這也是雙鏈表的意義所在，我們這裡就不這樣做了。直接從前往後遍歷
    // 讀者可以自己實現，以加深對連結串列的理解
    public T get(int position) {
        // 不合法的position直接拋異常，讓開發者直接定位問題
        if (position < 0 || position > size - 1) {
            throw new RuntimeException("invalid position");
        }

        // 如果連結串列為空，直接返回null
        if (size == 0) {
            return null;
        }

        // 如果連結串列只有一個節點，直接返回
        // 因為position合法性在前面已經驗證過
        // 所以在這裡面不用驗證，一定是0
        if(size == 1){
            return first.value;
        }

        // 注意這個新建的 p 節點，p.next 指向的是 first
        // 這是為了下面的迴圈，保證 i == 0 的時候，p 指向第一個節點
        QNode<T> p = new QNode<>(null, first, null);
        for (int i = 0; i <= position; i++) {
            p = p.next;
        }

        //如果找到了，就返回value
        if (p != null) {
            return p.value;
        }

        //否則返回 null
        return null;
    }

    // 返回連結串列的節點總個數
    // 注意first和last節點只是幫助我們方便操作的
    // size可不包括first,last
    public int size() {
        return size;
    }

    // 刪除一個元素，這裡傳的引數是 T e ，我們也可以傳position進行刪除，這裡就不作演示了
    // 可以先呼叫上面的get()方法，返回對應的值，再呼叫此方法
    // 讀者可以自己實現
    public T remove(T e) {
        //1 不合法，拋異常
        if (e == null) {
            throw new RuntimeException("e == null");
        }

        //2 連結串列為空，返回 null
        if (size == 0) {
            return null;
        }

        //2 如果連結串列只有一個節點
        if (size == 1) {
            QNode<T> node = first;

            //3 如果相等，刪除節點 size-- ,並把first,last賦值為null
            if(e == node.value || e.equals(node.value)){
                first = last = null;
                size--;
                return node.value;
            }else {
                //4 不相等，返回null
                return null;
            }
        }

        // 如果連結串列大於1個節點，我們從前往後找value等於e的節點
        // 1 查詢， 和get()方法一樣，注意p的next指向first
        QNode<T> p = new QNode<>(null, first, null);
        boolean find = false;
        for (int i = 0; i < size; i++) {
            p = p.next;

            if (p != null && (e == p.value || e.equals(p.value))) {
                find = true;
                break;
            }
        }

        // 2 如果找到了
        if (find) {
            // 2.1 如果找到的節點是最後一個節點
            // 刪除的是最後一個
            if (p.next == null) {

                //2.2 改變last的值，指向p的前一個節點
                last = p.pre;

                //2.3 p的前一個節點，變成了最後一個節點，所以，前一個節點的next值賦值為null
                p.pre.next = null;

                //2.4 把p.pre賦值為null,已經沒有用了
                p.pre = null;

                //2.5 別忘了節點個數減1
                size--;

                //2.6 返回刪除的節點的value
                return p.value;

            //3.1 如果刪除的是第一個節點（p.pre == null就表明是第一個節點）
            } else if (p.pre == null) {

                //3.2 改變first的指向，指向p的下一個節點
                first = p.next;

                //3.3 p的下一個節點變成了第一個節點，需要把p的下一個節點的pre指向為null
                p.next.pre = null;

                //3.4 p.next沒有用了
                p.next = null;

                //3.5 別忘了節點個數減1
                size--;

                //3.6 返回刪除的節點的value
                return p.value;


            // 4 如果刪除的不是第一個也不是最後一個，是中間的某一個，這種情況最簡單
            } else {

                //4.1 p的上一個節點的next需要指向p的下一個節點
                p.pre.next = p.next;

                //4.2 p 的下一個節點的pre需要指向p的上一個節點
                p.next.pre = p.pre;

                //4.3 此時p無用了，把p的pre,next賦值為null
                //這時候不需要調整first,last的位置
                p.pre = null;
                p.next = null;

                //4.4 別忘了節點個數減1
                size--;

                //4.5 返回刪除的節點的value
                return p.value;
            }
        }

        //沒有找到與e相等的節點，直接返回null
        return null;
    }

}
 

我們來測試一下QLinkedList，測試程式碼如下：

   public static void main(String[] args) {
        QLinkedList<String> list = new QLinkedList<>();
        list.add("one");
        list.add("two");
        list.add("three");
        list.add("four");

        System.out.println(list.size);
        for (int i = 0; i < list.size; i++) {
            System.out.println(list.get(i));
        }

        System.out.println("===================");

        System.out.println(list.remove("two"));
        System.out.println(list.size);
        for (int i = 0; i < list.size; i++) {
            System.out.println(list.get(i));
        }
    }
 

輸出如下：

4
one
two
three
four
===================
two
3
one
three
four

由此可見我們的QLinkedList可以正常的add,get,size,remove了。
建議可以參考一下JDK中的LinkedList。以加深對LinkedList的理解
明天手寫HashMap的核心原始碼實現