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

LinkedList原理及實現學習總結

阿新 • • 發佈：2018-11-24

一、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

相關推薦

LinkedList原理及實現學習總結

一、LinkedList實現原理概述 LinkedList 和 ArrayList 一樣，都實現了 List 介面，但其內部的資料結構有本質的不同。LinkedList 是基於連結串列實現的（通過名字也能區分開來），所以它的插入和刪除操作比 ArrayList 更加高效。但也是由

【資料結構】LinkedList原理及實現學習總結

一、LinkedList實現原理概述 LinkedList 和 ArrayList 一樣，都實現了 List 介面，但其內部的資料結構有本質的不同。LinkedList 是基於連結串列實現的（通過名字也能區分開來），所以它的插入和刪除操作比 ArrayList

四.HashSet原理及實現學習總結

throw map 所有 cti con name 保持 nts equal 在上一篇博文（HashMap原理及實現學習總結）詳細總結了HashMap的實現過程，對於HashSet而言，它是基於HashMap來實現的，底層采用HashMap來保存元素。所以如果對HashMa

五.HashTable原理及實現學習總結

容量 區別 存儲 們的 如果 isn cte ash ref 有兩個類都提供了一個多種用途的hashTable機制，他們都可以將可以key和value結合起來構成鍵值對通過put(key,value)方法保存起來，然後通過get(key)方法獲取相對應的value值。一個是

【數據結構】ArrayList原理及實現學習總結（2）

!= 需要 但是 object count def 原理 arrays 位置 ArrayList是一個基於數組實現的鏈表（List），這一點可以從源碼中看出： transient Object[] elementData; // non-private to si

【數據結構】ArrayList原理及實現學習總結

sset bsp perm arraylist 節點 article cell public arr 關於Java集合的小抄中是這樣描述的： 以數組實現。節約空間，但數組有容量限制。超出限制時會增加50%容量，用System.arraycopy()復制到新的數組，因此最好能

HashSet原理及實現學習總結

一.HsahSet概述 HashSet實現Set介面，由雜湊表（實際上是一個HashMap例項）支援。它不保證set 的迭代順序；特別是它不保證該順序恆久不變。此類允許使用null元素。 public class HashSet<E> extends Abstrac

ArrayList原理及實現學習總結

一、ArrayList介紹 ArrayList是一種線性資料結構，它的底層是用陣列實現的，相當於動態陣列。與Java中的陣列相比，它的容量能動態增長。類似於C語言中的動態申請記憶體，動態增長記憶體。  當建立一個數組的時候，就必須確定它的大小，系統會在記憶體中開

【資料結構】HashTable原理及實現學習總結

有兩個類都提供了一個多種用途的hashTable機制，他們都可以將可以key和value結合起來構成鍵值對通過put(key,value)方法儲存起來，然後通過get(key)方法獲取相對應的value值。一個是前面提到的HashMap，還有一個就是馬上要講解的HashTa

Spring->aop原理及實現學習

部落格轉自 https://www.cnblogs.com/hongwz/p/5764917.html AOP AOP（Aspect Oriented Programming），即面向切面程式設計，可以說是OOP（Object Oriented Programming，面向物件程式設

【轉】Java學習---快速掌握RPC原理及實現

消費者 阿裏 局限 kryo nes 很多 cal 網絡 href 【原文】https://www.toutiao.com/i6592365493435236872/ ?RPC概述 RPC(Remote Procedure Call)即遠程過程調用，也就是說兩臺服務器A，

Java LinkedList工作原理及實現

++ 部分 更多 size mov info 容量限制 element git 1. 概述 以雙向鏈表實現。鏈表無容量限制，但雙向鏈表本身使用了更多空間，也需要額外的鏈表指針操作。 按下標訪問元素—get(i)/set(i,e) 要悲劇的遍歷鏈表將指針移動到位(如果i&g

機器學習系列：k 近鄰法（k-NN）的原理及實現

  本內容將介紹機器學習中的 k k k 近鄰法（

機器學習(4)--層次聚類(hierarchical clustering)基本原理及實現簡單圖片分類

關於層次聚類(hierarchical clustering)的基本步驟： 1、假設每個樣本為一類，計算每個類的距離，也就是相似度 2、把最近的兩個合為一新類，這樣類別數量就少了一個 3、重新新類與各個舊類(去了那兩個合併的類)之間的相似度； 4、迴圈重複2和3直到所有樣本

[機器學習]機器學習筆記整理08- SVM演算法原理及實現

<html> 1 背景 最早是由 Vladimir N. Vapnik 和 Alexey Ya. Chervonenkis 在1963年提出 目前的版本(so

基於歐幾里德聚類的鐳射雷達點雲分割及ROS實現——學習總結

1、特別說明 本部落格是在復現大神部落格的過程中遇到問題的解決方式，具體的部落格地址是： https://blog.csdn.net/AdamShan/article/details/83015570#commentsedit 寫的非常好的博主，在此大力推薦！！！ 2、實現過程

《機器學習實戰》NaiveBayes演算法原理及實現

一、問題描述鳶尾花（IRIS)有很多種，但又因為特徵很是相近，不好區分，通過大量資料歸納的特徵，我們通過花萼長度(Sepal.Length)，花萼寬度(Sepal.Width)，花瓣長度(Petal.Length)，花瓣寬度(Petal.Width)，4個屬性預測鳶尾花卉屬於

（學習筆記二）——基於opencv人臉檢測原理及實現

最近搞了幾天的人臉檢測，終於把大體框架和原理搞清楚了，現在寫出來供大家學習之用，如有不對之處，還請大家指正。也希望大家在學習opencv的過程中能將學習過程及重點記錄下來，以部落格的形式分析，畢竟opencv的教材還不太多，我們自己學習大部分要靠網上的資料。通過部落格分享的

關於base64編碼的原理及實現

一個 replace 編碼範圍 func nco 都是 style bit 如果 我們的圖片大部分都是可以轉換成base64編碼的data：image。 這個在將canvas保存為img的時候尤其有用。雖然除ie外，大部分現代瀏覽器都已經支持原生的基於base64的enco

java設計模式singleton原理及實現

最新 不必要 -- 不同 適合 所有 引用 ati cnblogs 題外話:我要變強，要變強，變強，強。 1、 Singleton的應用場景以及為什麽要使用singleSingleton是一生只能有一個實例的對象。只能由singleton自身創建一個實例。外人是無法創建實例