LinkedList 在什麼情況下用到？它的資料結構是什麼樣的，和我們常常用到的 Arraylist 又有啥不同，接下來我們一起來學習一下在 LinkedList 原始碼中是怎麼樣實現的。（如果對ArrayList的實現還不太清楚的同學可以看一下ArrayList 資料結構分析）
LinkedList
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
複製程式碼-
繼承AbstractSequentialList<E>類，
AbstractSequentialList 繼承自 AbstractList，是 LinkedList 的父類，是 List 介面 的一種簡化版的實現。是一個抽象類 ，子類需要實現實現
public abstract ListIterator<E> listIterator(int index);
複製程式碼該類通過ListIterator 來實現add,remove,addAll等方法。 實現可變的list需要實現iterator的set方法，實現可變list要實現iterator的remove方法。
-
實現了List介面
表明資料結構是 一個元素有序，可重複，可為null的集合，實現List介面的類，元素通過索引進行排序
-
實現了Deque介面
Deque extends Queue 表明是一個佇列，或棧結構。Deque 即雙端佇列。是一種具有佇列和棧的性質的資料結構。雙端佇列中的元素可以從兩端彈出，其限定插入和刪除操作在表的兩端進行。
-
實現了Cloneable介面
表明允許clone
-
實現了Serizlizable介面
序列化
單連結串列
雙連結串列
LinkedList是一個雙向連結串列的實現方式，邏輯上的相連關係。
屬性
大小
transient int size = 0;
/**
* Pointer to first node. 頭結點
* Invariant: (first == null && last == null) ||
* (first.prev == null && first.item != null)
*/
transient Node<E> first;
/**
* Pointer to last node. 下一個結點
* Invariant: (first == null && last == null) ||
* (last.next == null && last.item != null)
*/
transient Node<E> last;
複製程式碼add方法
//add方法其實就是在末尾插入一個新的節點
public boolean add(E e) {
linkLast(e);
return true;
}
複製程式碼我們來看看linkLast的實現
//先看一下結點類的實現
private static class Node<E> {
E item;
Node<E> next;
Node<E> prev;
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
/**
* Links e as last element.
*/
void linkLast(E e) {
<!--首先取出當前的最後一個結點儲存，當做插入結點的前結點-->
final Node<E> l = last;
<!--建立出一個新的結點，newNode.prev為上一個末尾的結點，即l,e為插入的新的元素，newNode.next=null表示該結點是一個尾結點-->
final Node<E> newNode = new Node<>(l, e, null);
<!--將尾指標指向新加的節點（尾結點）-->
last = newNode;
<!--l==null表是插入的是一個頭結點，將頭指標指向新的結點（頭結點）-->
if (l == null){
first = newNode;
}
else{
<!--將前一個結點的next指向新的尾結點-->
l.next = newNode;
}
<!--大小自增-->
size++;
<!--資料結構變動計數自增-->
modCount++;
}
複製程式碼add(int index, E element) 方法
在指定位置插入元素
- s.pre = p.pre;
- p.pre.next = s;
- s.next = p;
- p.pre = s;
/**
*1:檢查index是否越界
*2：如果index==size表示是插入到末尾結點
*3：否則，查詢index結點node(index)，將新的元素插入到index位置
*/
public void add(int index, E element) {
<!--檢查index是否越界-->
checkPositionIndex(index);
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}
//接下來我們來看linkBefore方法：
/**
* Inserts element e before non-null Node succ.
*在指定非空結點的前面插入新的元素e
*/
void linkBefore(E e, Node<E> succ) {
// assert succ != null;
//先取出原先該結點的前結點儲存
final Node<E> pred = succ.prev;
//建立新的結點，新的節點的前結點即為原來succ.prev,後一個節點則為新的節點
final Node<E> newNode = new Node<>(pred, e, succ);
//scc的前結點變為新插入的結點newNode
succ.prev = newNode;
//pred==null 表示插入的為頭結點
if (pred == null){
first = newNode;
}
else{
//將原來的頭結點的next指標指向新的結點
pred.next = newNode;
}
size++;
modCount++;
}
複製程式碼remove方法
雙向連結串列的刪除
- p.prior.next= p.next
- p.next.prior = p.prior
/**
* 1:檢查index越界
* 2：取出index的結點，從鏈上刪除
*/
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
/**
*通過二分法查詢
* Returns the (non-null) Node at the specified element index.
*/
Node<E> node(int index) {
// assert isElementIndex(index);
//如果index小於當前size的一半，從前往後索引
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;
}
}
/**
移除一個非空節點 x
* Unlinks non-null node x.
*/
E unlink(Node<E> x) {
// assert x != null;
final E element = x.item;//節點元素
final Node<E> next = x.next;//下一個結點
final Node<E> prev = x.prev;//上一個結點
if (prev == null) {
//頭結點為空，頭指標指向該結點的下一個結點
first = next;
} else {
//前一個節點的next指向下一個結點
prev.next = next;
//方便GC回收
x.prev = null;
}
//next結點為空，表示刪除的是一個尾結點
if (next == null) {
last = prev;
} else {
next.prev = prev;
x.next = null;
}
//gc
x.item = null;
size--;
modCount++;
//返回刪除的結點元素
return element;
}
複製程式碼removeFirst()刪除頭結點
public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
/**
* Unlinks non-null first node f.
*/
private E unlinkFirst(Node<E> f) {
// assert f == first && f != null;
final E element = f.item;
final Node<E> next = f.next;//下一個結點
f.item = null;
f.next = null; // help GC
first = next; //頭指標指向下一個結點
if (next == null)
last = null;
else
next.prev = null;
size--;
modCount++;
return element;
}
複製程式碼removeLast() 刪除最後一個結點
public E removeLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return unlinkLast(l);
}
/**
* Unlinks non-null last node l.
*/
private E unlinkLast(Node<E> l) {
// assert l == last && l != null;
final E element = l.item;
final Node<E> prev = l.prev;//前一個結點
l.item = null;
l.prev = null; // help GC
last = prev;//尾指標指向prev
if (prev == null)
first = null;
else
prev.next = null;
size--;
modCount++;
return element;
}
複製程式碼get(int index)
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
//看上去比較簡單，但是注意node(index) 是一個for迴圈來遍歷查詢，索引的複雜度尾O(N)
複製程式碼toArray()
public Object[] toArray() {
Object[] result = new Object[size];
int i = 0;
for (Node<E> x = first; x != null; x = x.next)
result[i++] = x.item;
return result;
}
複製程式碼listIterator(int index)迭代器 分析
實現迭代器，在迭代器中實現刪除，或查詢，每次遍歷後，都保留了上一次的結點，所以在實現查詢，刪除操作時，使得效率上得到提升。
public ListIterator<E> listIterator(int index) {
checkPositionIndex(index);
return new ListItr(index);
}
複製程式碼看一下ListItr
private class ListItr implements ListIterator<E> {
private Node<E> lastReturned; //上次返回的結點
private Node<E> next; //下一個結點
private int nextIndex;//下一個結點的索引
private int expectedModCount = modCount;
/** 頭指標的index
* @param index index of the first element to be returned from the
* list-iterator (by a call to {@code next})
*/
ListItr(int index) {
// assert isPositionIndex(index);
next = (index == size) ? null : node(index); //取出下一個結點給next
nextIndex = index;//第一次的索引即傳進來的index
}
public boolean hasNext() {
return nextIndex < size;
}
public E next() {
checkForComodification();
if (!hasNext())
throw new NoSuchElementException();
lastReturned = next;
next = next.next;
nextIndex++;
return lastReturned.item;
}
public boolean hasPrevious() {
return nextIndex > 0;
}
public E previous() {
checkForComodification();
if (!hasPrevious())
throw new NoSuchElementException();
lastReturned = next = (next == null) ? last : next.prev;
nextIndex--;
return lastReturned.item;
}
public int nextIndex() {
return nextIndex;
}
public int previousIndex() {
return nextIndex - 1;
}
public void remove() {
checkForComodification();
if (lastReturned == null)
throw new IllegalStateException();
Node<E> lastNext = lastReturned.next;
unlink(lastReturned);
if (next == lastReturned)
next = lastNext;
else
nextIndex--;
lastReturned = null;
expectedModCount++;
}
public void set(E e) {
if (lastReturned == null)
throw new IllegalStateException();
checkForComodification();
lastReturned.item = e;
}
public void add(E e) {
checkForComodification();
lastReturned = null;
if (next == null)
linkLast(e);
else
linkBefore(e, next);
nextIndex++;
expectedModCount++;
}
public void forEachRemaining(Consumer<? super E> action) {
Objects.requireNonNull(action);
while (modCount == expectedModCount && nextIndex < size) {
action.accept(next.item);
lastReturned = next;
next = next.next;
nextIndex++;
}
checkForComodification();
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
複製程式碼從上面的分析可以看出，LinkedList在實現插入，刪除元素時，時間的複雜度為O(1)，要比ArrayList要快，但是，在查詢元素時，要比ArrayList慢，時間複雜度為O(N),每次查詢要遍歷一遍。因此如果要求插入，刪除比較快時，我們可以考慮用LinkedList,如：我們在實現一個歷史對話列表，經常遇到置頂聊天，排序插入，刪除等。在要求讀取速度比較快時，我們可以考慮用Arraylist.
Other
發現一篇比較好部落格 線性表之順序表與單連結串列的區別及優缺點