LinkList(雙向鏈表實現)

LinkedList是用鏈表結構存儲數據的，比較適合數據的動態插入和刪除，隨機訪問和遍歷速度比較慢，還提供了List接口i中沒有定義的方法，專門用於操作表頭和表尾的元素，所以可以當作堆棧、隊列和雙向隊列來使用。LInkedList持有頭節點和尾節點的引用，有兩個構造器，一個是無參構造器，另一個是傳入外部集合構造器，它沒有像ArrayList一樣的初始大小的構造器。

//集合元素個數

transient int size = 0;

 

//頭結點引用

transient Node<E> first;

 

//尾節點引用
transient Node<E> last;

//無參構造器
public LinkedList() {} 

//傳入外部集合的構造器
public LinkedList(Collection<? extends E> c) {
    this();
    addAll(c);
}

//增(添加)
public boolean add(E e) {
  
     //在鏈表尾部添加
    linkLast(e);
    return true;
}

 
//增(插入)
public void add(int index, E element) {

    checkPositionIndex(index);

    if (index == size) {
        //在鏈表尾部添加
        linkLast(element);
    } else {
        //在鏈表中部插入
        linkBefore(element, node(index));
    }
}

 

//刪(給定下標)
public E remove(int index) {

    //檢查下標是否合法
    checkElementIndex(index);
    return unlink(node(index));
}

//刪(給定元素)
public boolean remove(Object o) {
    if (o == null) {
        for (Node<E> x = first; x != null; x = x.next) {
            if (x.item == null) {
                unlink(x);
                return true;
            }
        }
    } else {
        //遍歷鏈表
        for (Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item)) {
                //找到了就刪除
                unlink(x);
                return true;
            }
        }
    }
    return false;
}

 

//改
public E set(int index, E element) {

    //檢查下標是否合法
    checkElementIndex(index);

    //獲取指定下標的結點引用
    Node<E> x = node(index);

    //獲取指定下標結點的值

    E oldVal = x.item;

    //將結點元素設置為新的值

    x.item = element;

    //返回之前的值

    return oldVal;

}


//查
public E get(int index) {

    //檢查下標是否合法
    checkElementIndex(index);

    //返回指定下標的結點的值
    return node(index).item;
}

 

LinkedList的添加元素的方法主要是調用LinkLast和LinkBefore兩個方法，LinkLast方法是在鏈表后面鏈接一個元素，LinkBefore方法是在鏈表中間插入一個元素。LinkedList的刪除方法通過調用unlink方法將某個元素從鏈表中移除。下面是鏈表的插入和刪除操作的核心代碼。

//鏈接到指定結點之前
void linkBefore(E e, Node<E> succ) {

    //獲取給定結點的上一個結點引用
    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++;

}

 

//卸載指定結點
E unlink(Node<E> x) {

    //獲取給定結點的元素
    final E element = x.item;

    //獲取給定結點的下一個結點的引用
    final Node<E> next = x.next;

    //獲取給定結點的上一個結點的引用
    final Node<E> prev = x.prev;

    //如果給定結點的上一個結點為空, 說明給定結點為頭結點
    if (prev == null) {

        //將頭結點引用指向給定結點的下一個結點
        first = next;
    } else {
        //將上一個結點的后繼結點引用指向給定結點的后繼結點
        prev.next = next;
        //將給定結點的上一個結點置空
        x.prev = null;

    }

    //如果給定結點的下一個結點為空, 說明給定結點為尾結點
    if (next == null) {

        //將尾結點引用指向給定結點的上一個結點
        last = prev;
    } else {

        //將下一個結點的前繼結點引用指向給定結點的前繼結點
        next.prev = prev;
        x.next = null;

    }

    //將給定結點的元素置空
    x.item = null;

    //集合元素個數減一
    size--;
    //修改次數加一
    modCount++;
    return element;

}

通過源碼的分析，對鏈表的插入和刪除的時間復雜度都是O(1)，而對鏈表的查找和修改操作都需要遍歷鏈表進行元素的定位，這兩個操作都是調用的node(int index) 方法定位元素，如下代碼演示根據下標來定位元素。

//根據指定位置獲取結點
Node<E> node(int 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;
    }
}

通過下標定位時先判斷是在鏈表的上半部還是下半部

上半部：從頭開始找；

下半部：從尾開始找；

因此通過下標的查找和修改操作的時間復雜度是O(n/2)，通過對雙向鏈表的操作還可以實現單項隊列，雙向隊列和棧的功能。

單向隊列的操作的代碼：

//獲取頭結點
public E peek() {
    final Node<E> f = first;
    return (f == null) ? null : f.item;
}
 
//獲取頭結點
public E element() {
    return getFirst();
}
 
//彈出頭結點
public E poll() {
    final Node<E> f = first;
    return (f == null) ? null : unlinkFirst(f);
}
 
//移除頭結點
public E remove() {
    return removeFirst();
}
 
//在隊列尾部添加結點
public boolean offer(E e) {
    return add(e);
}

雙向隊列的操作：

//在頭部添加
public boolean offerFirst(E e) {
    addFirst(e);
    return true;
}
 
//在尾部添加
public boolean offerLast(E e) {
    addLast(e);
    return true;
}
 
//獲取頭結點
public E peekFirst() {
    final Node<E> f = first;
    return (f == null) ? null : f.item;
 }
 
//獲取尾結點
public E peekLast() {
    final Node<E> l = last;
    return (l == null) ? null : l.item;
}

棧操作：

//入棧
public void push(E e) {
    addFirst(e);
}
 
//出棧
public E pop() {
    return removeFirst();
}

對LindedList，有：

1. LinkedList是基於雙向鏈表實現的，不論是增刪改查方法還是隊列和棧的實現，都可通過操作結點實現

2. LinkedList無需提前指定容量，因為基於鏈表操作，集合的容量隨着元素的加入自動增加

3. LinkedList刪除元素后集合占用的內存自動縮小，無需像ArrayList一樣調用trimToSize()方法

4. LinkedList的所有方法沒有進行同步，因此它也不是線程安全的，應該避免在多線程環境下使用

5. 以上分析基於JDK1.7，其他版本會有些出入，因此不能一概而論

以上內容部分借鑒於：https://blog.csdn.net/iteen/article/details/83109717