1. 程式人生 > >LinkedList原理及實現學習總結

LinkedList原理及實現學習總結

一、LinkedList實現原理概述

LinkedList 和 ArrayList 一樣,都實現了 List 介面,但其內部的資料結構有本質的不同。LinkedList 是基於連結串列實現的(通過名字也能區分開來),所以它的插入和刪除操作比 ArrayList 更加高效。但也是由於其為基於連結串列的,所以隨機訪問的效率要比 ArrayList 差。

二、LinkedList類定義

public class LinkedList<E>
     extends AbstractSequentialList<E>
     implements
List<E>, Deque<E>, Cloneable, java.io.Serializable
  • 1
  • 2
  • 3
  • 1
  • 2
  • 3
  1. LinkedList 是一個繼承於AbstractSequentialList的雙向連結串列。它也可以被當作堆疊、佇列或雙端佇列進行操作。
  2. LinkedList 實現 List 介面,能對它進行佇列操作。
  3. LinkedList 實現 Deque 介面,即能將LinkedList當作雙端佇列使用。
  4. LinkedList 實現了Cloneable介面,即覆蓋了函式clone(),能克隆。
  5. LinkedList 實現java.io.Serializable介面,這意味著LinkedList支援序列化,能通過序列化去傳輸。
  6. LinkedList 是非同步的。

為什麼要繼承自AbstractSequentialList ? 
AbstractSequentialList 實現了get(int index)、set(int index, E element)、add(int index, E element) 和 remove(int index)這些骨幹性函式。降低了List介面的複雜度。這些介面都是隨機訪問List的,LinkedList是雙向連結串列;既然它繼承於AbstractSequentialList,就相當於已經實現了“get(int index)這些介面”。 
此外,我們若需要通過AbstractSequentialList自己實現一個列表,只需要擴充套件此類,並提供 listIterator() 和 size() 方法的實現即可。若要實現不可修改的列表,則需要實現列表迭代器的 hasNext、next、hasPrevious、previous 和 index 方法即可。

LinkedList的類圖關係:

這裡寫圖片描述

三、LinkedList資料結構原理

LinkedList底層的資料結構是基於雙向迴圈連結串列的,且頭結點中不存放資料,如下: 
這裡寫圖片描述 
既然是雙向連結串列,那麼必定存在一種資料結構——我們可以稱之為節點,節點例項儲存業務資料,前一個節點的位置資訊和後一個節點位置資訊,如下圖所示: 
這裡寫圖片描述

四、私有屬性

LinkedList中之定義了兩個屬性:

private transient Entry<E> header = new Entry<E>(null, null, null);2 private transient int size = 0;
  • 1
  • 1

header是雙向連結串列的頭節點,它是雙向連結串列節點所對應的類Entry的例項。Entry中包含成員變數: previous, next, element。其中,previous是該節點的上一個節點,next是該節點的下一個節點,element是該節點所包含的值。 
  size是雙向連結串列中節點例項的個數。 
首先來了解節點類Entry類的程式碼。

 private static class Entry<E> {
     E element;
      Entry<E> next;
      Entry<E> previous;

      Entry(E element, Entry<E> next, Entry<E> previous) {
          this.element = element;
          this.next = next;
         this.previous = previous;
             }
          }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

節點類很簡單,element存放業務資料,previous與next分別存放前後節點的資訊(在資料結構中我們通常稱之為前後節點的指標)。

}

五、構造方法

LinkedList提供了兩個構造方法。

public LinkedList() {    
 header.next = header.previous = header;
 }
public LinkedList(Collection<? extends E> c) {
     this();
   addAll(c);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

第一個構造方法不接受引數,將header例項的previous和next全部指向header例項(注意,這個是一個雙向迴圈連結串列,如果不是迴圈連結串列,空連結串列的情況應該是header節點的前一節點和後一節點均為null),這樣整個連結串列其實就只有header一個節點,用於表示一個空的連結串列。 
執行完建構函式後,header例項自身形成一個閉環,如下圖所示: 
這裡寫圖片描述 
第二個構造方法接收一個Collection引數c,呼叫第一個構造方法構造一個空的連結串列,之後通過addAll將c中的元素全部新增到連結串列中。

六、元素新增

下面說明雙向連結串列新增元素add()的原理:

 // 將元素(E)新增到LinkedList中
     public boolean add(E e) {
         // 將節點(節點資料是e)新增到表頭(header)之前。
         // 即,將節點新增到雙向連結串列的末端。         addBefore(e, header);
         return true;
     }

     public void add(int index, E element) {
         addBefore(element, (index==size ? header : entry(index)));
     }

    private Entry<E> addBefore(E e, Entry<E> entry) {
         Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
         newEntry.previous.next = newEntry;
         newEntry.next.previous = newEntry;
         size++;
         modCount++;
         return newEntry;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

addBefore(E e,Entry entry)方法是個私有方法,所以無法在外部程式中呼叫(當然,這是一般情況,你可以通過反射上面的還是能呼叫到的)。 
addBefore(E e,Entry entry)先通過Entry的構造方法建立e的節點newEntry(包含了將其下一個節點設定為entry,上一個節點設定為entry.previous的操作,相當於修改newEntry的“指標”),之後修改插入位置後newEntry的前一節點的next引用和後一節點的previous引用,使連結串列節點間的引用關係保持正確。之後修改和size大小和記錄modCount,然後返回新插入的節點。 
下面分解“新增第一個資料”的步驟: 
第一步:初始化後LinkedList例項的情況: 
這裡寫圖片描述 
第二步:初始化一個預新增的Entry例項(newEntry)。 
Entry newEntry = newEntry(e, entry, entry.previous); 
這裡寫圖片描述

第三步:調整新加入節點和頭結點(header)的前後指標。 
newEntry.previous.next = newEntry; 
newEntry.previous即header,newEntry.previous.next即header的next指向newEntry例項。在上圖中應該是“4號線”指向newEntry。 
newEntry.next.previous = newEntry; 
newEntry.next即header,newEntry.next.previous即header的previous指向newEntry例項。在上圖中應該是“3號線”指向newEntry。 
調整後如下圖所示: 
圖——加入第一個節點後LinkedList示意圖 
這裡寫圖片描述 
下面分解“新增第二個資料”的步驟: 
第一步:新建節點。 
圖——新增第二個節點 
這裡寫圖片描述 
第二步:調整新節點和頭結點的前後指標資訊。 
圖——調整前後指標資訊 
這裡寫圖片描述 
新增後續資料情況和上述一致,LinkedList例項是沒有容量限制的。

總結,addBefore(E e,Entry entry)實現在entry之前插入由e構造的新節點。而add(E e)實現在header節點之前插入由e構造的新節點。為了便於理解,下面給出插入節點的示意圖。 
這裡寫圖片描述

public void addFirst(E e) {
     addBefore(e, header.next);
 }

 public void addLast(E e) {
     addBefore(e, header);
 }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

看上面的示意圖,結合addBefore(E e,Entry entry)方法,很容易理解addFrist(E e)只需實現在header元素的下一個元素之前插入,即示意圖中的一號之前。addLast(E e)只需在實現在header節點前(因為是迴圈連結串列,所以header的前一個節點就是連結串列的最後一個節點)插入節點(插入後在2號節點之後)。

七、刪除資料remove()

public E remove(int index) {
        Entry e = get(index);
        remove(e);
        return e.element;
    }

    private void remove(E e) {
        if (e == header)
            throw new NoSuchElementException();
        // 將前一節點的next引用賦值為e的下一節點
        e.previous.next = e.next;
        // 將e的下一節點的previous賦值為e的上一節點
        e.next.previous = e.previous;
        // 上面兩條語句的執行已經導致了無法在連結串列中訪問到e節點,而下面解除了e節點對前後節點的引用
        e.next = e.previous = null;
        // 將被移除的節點的內容設為null
        e.element = null;
        // 修改size大小
        size--;
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

由於刪除了某一節點因此調整相應節點的前後指標資訊,如下: 
e.previous.next = e.next;//預刪除節點的前一節點的後指標指向預刪除節點的後一個節點。 
e.next.previous = e.previous;//預刪除節點的後一節點的前指標指向預刪除節點的前一個節點。 
清空預刪除節點: 
e.next = e.previous = null; 
e.element = null; 
交給gc完成資源回收,刪除操作結束。 
與ArrayList比較而言,LinkedList的刪除動作不需要“移動”很多資料,從而效率更高。

八、資料獲取get()

Get(int)方法的實現在remove(int)中已經涉及過了。首先判斷位置資訊是否合法(大於等於0,小於當前LinkedList例項的Size),然後遍歷到具體位置,獲得節點的業務資料(element)並返回。 
注意:為了提高效率,需要根據獲取的位置判斷是從頭還是從尾開始遍歷。

// 獲取雙向連結串列中指定位置的節點    
    private Entry<E> entry(int index) {    
        if (index < 0 || index >= size)    
            throw new IndexOutOfBoundsException("Index: "+index+    
                                                ", Size: "+size);    
        Entry<E> e = header;    
        // 獲取index處的節點。    
        // 若index < 雙向連結串列長度的1/2,則從前先後查詢;    
        // 否則,從後向前查詢。    
        if (index < (size >> 1)) {    
            for (int i = 0; i <= index; i++)    
                e = e.next;    
        } else {    
            for (int i = size; i > index; i--)    
                e = e.previous;    
        }    
        return e;    
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

注意細節:位運算與直接做除法的區別。先將index與長度size的一半比較,如果index

九、 清除資料clear()

public void clear() {
      Entry<E> e = header.next;
      // e可以理解為一個移動的“指標”,因為是迴圈連結串列,所以回到header的時候說明已經沒有節點了
      while (e != header) {
         // 保留e的下一個節點的引用
          Entry<E> next = e.next;
          // 解除節點e對前後節點的引用
         e.next = e.previous = null;
          // 將節點e的內容置空
         e.element = null;
         // 將e移動到下一個節點
         e = next;
  }
     // 將header構造成一個迴圈連結串列,同構造方法構造一個空的LinkedList
     header.next = header.previous = header;
     // 修改size
     size = 0;
     modCount++;
 }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

十、資料包含 contains(Object o)

public boolean contains(Object o) {
     return indexOf(o) != -1;
 }
 // 從前向後查詢,返回“值為物件(o)的節點對應的索引”  不存在就返回-1 
 public int indexOf(Object o) {
      int index = 0;
      if (o==null) {
          for (Entry e = header.next; e != header; e = e.next) {
              if (e.element==null)
                  return index;
              index++;
         }
      } else {
         for (Entry e = header.next; e != header; e = e.next) {
             if (o.equals(e.element))
                 return index;
             index++;
        }
    }
     return -1;
 }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

indexOf(Object o)判斷o連結串列中是否存在節點的element和o相等,若相等則返回該節點在連結串列中的索引位置,若不存在則放回-1。 
contains(Object o)方法通過判斷indexOf(Object o)方法返回的值是否是-1來判斷連結串列中是否包含物件o。

十一、資料複製clone()與toArray()

clone()

public Object clone() {
      LinkedList<E> clone = null;
      try {
          clone = (LinkedList<E>) super.clone();
      } catch (CloneNotSupportedException e) {
          throw new InternalError();
    }
      clone.header = new Entry<E>(null, null, null);
      clone.header.next = clone.header.previous = clone.header;
     clone.size = 0;
     clone.modCount = 0;
     for (Entry<E> e = header.next; e != header; e = e.next)
        clone.add(e.element);
     return clone;
 }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

呼叫父類的clone()方法初始化物件連結串列clone,將clone構造成一個空的雙向迴圈連結串列,之後將header的下一個節點開始將逐個節點新增到clone中。最後返回克隆的clone物件。 
toArray()

public Object[] toArray() {
     Object[] result = new Object[size];
     int i = 0;
     for (Entry<E> e = header.next; e != header; e = e.next)
         result[i++] = e.element;
     return result;
 }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

建立大小和LinkedList相等的陣列result,遍歷連結串列,將每個節點的元素element複製到陣列中,返回陣列。 
toArray(T[] a)

public <T> T[] toArray(T[] a) {
      if (a.length < size)
          a = (T[])java.lang.reflect.Array.newInstance(
                                 a.getClass().getComponentType(), size);
      int i = 0;
      Object[] result = a;
      for (Entry<E> e = header.next; e != header; e = e.next)
          result[i++] = e.element;
      if (a.length > size)
         a[size] = null;
     return a;
 }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

先判斷出入的陣列a的大小是否足夠,若大小不夠則拓展。這裡用到了發射的方法,重新例項化了一個大小為size的陣列。之後將陣列a賦值給陣列result,遍歷連結串列向result中新增的元素。最後判斷陣列a的長度是否大於size,若大於則將size位置的內容設定為null。返回a。 
從程式碼中可以看出,陣列a的length小於等於size時,a中所有元素被覆蓋,被拓展來的空間儲存的內容都是null;若陣列a的length的length大於size,則0至size-1位置的內容被覆蓋,size位置的元素被設定為null,size之後的元素不變。 
為什麼不直接對陣列a進行操作,要將a賦值給result陣列之後對result陣列進行操作?

十二、遍歷資料:Iterator()

LinkedList的Iterator 
除了Entry,LinkedList還有一個內部類:ListItr。 
ListItr實現了ListIterator介面,可知它是一個迭代器,通過它可以遍歷修改LinkedList。 
在LinkedList中提供了獲取ListItr物件的方法:listIterator(int index)。

 public ListIterator<E> listIterator(int index) {
     return new ListItr(index);
 }
  • 1
  • 2
  • 3
  • 1
  • 2
  • 3

該方法只是簡單的返回了一個ListItr物件。 
LinkedList中還有通過整合獲得的listIterator()方法,該方法只是呼叫了listIterator(int index)並且傳入0。

轉載自:http://blog.csdn.net/jianyuerensheng/article/details/51204598