2. 程式人生 > 其它 >連結串列之LinkedList

連結串列之LinkedList

阿新 • • 發佈：2021-11-28

寫在前面

在日常開發中，一般在對於List的場景，基本上都是通過ArrayList去封裝資料的，而對於連結串列LinkedList相對來說用的比較少。對我而言，好像ArrayList熟練度高一些，所以基本上也很少用LinkedList，也就是在面試的時候去背過八股文。

連結串列：資料分散的儲存在物理空間中，通過一根線儲存著它們之間的邏輯關係，這種儲存結構稱為鏈式儲存結構，簡稱連結串列。

連結串列的前驅和後繼

資料結構中，一組資料中的每個個體被稱為“資料元素”（簡稱“元素”）。
另外，對於具有“一對一”邏輯關係的資料，我們一直在用“某一元素的左側（前邊）或右側（後邊）”這樣不專業的詞，其實線性表中有更準確的術語：

  • 某一元素的左側相鄰元素稱為“直接前驅”，位於此元素左側的所有元素都統稱為“前驅元素”；
  • 某一元素的右側相鄰元素稱為“直接後繼”，位於此元素右側的所有元素都統稱為“後繼元素”；

單鏈表

概念：單鏈表，用於儲存邏輯關係為 "一對一" 的資料。與順序表不同，連結串列不限制資料的物理儲存狀態，換句話說，使用連結串列儲存的資料元素，其物理儲存位置是隨機的。HashMap在1.7就是通過單鏈表來解決hash衝突的。

節點

在上圖中無法提現出元素之間的邏輯關係，對此，連結串列的解決方案是，每個資料元素在儲存時都配備一個指標，用於指向自己的直接後繼元素。表示一個節點如下：

//節點資訊
class Node {
    E data;
    Node next;

    public Node(E element, Node next) {
        this.data = element;
        this.next = next;
    }

    public Node(E data) {
        this.data = data;
    }
}


因此，在連結串列中，每個資料的儲存有以下2部分組成

  • 資料本身，其所在的區域叫做資料域

  • 指向後繼元素的指標，叫指標域

上圖所示的結構在連結串列中稱為節點。也就是說，連結串列實際儲存的是一個一個的節點，真正的資料元素包含在這些節點中

單鏈表---增

 /**
  * 頭部新增節點
  *
  * @param e
  */
 public void add(E e) {
     //頭結點
     Node cur = new Node(e, list);
     list = cur;
     size++;
 }

 /**
   * 指定位置新增節點
   *
   * @param index
   * @param e     0 1 2 3 4
   */
 public void add(int index, E e) {
 	  //越界檢查
     checkElementIndex(index);
     Node preNode = list;
     for (int i = 0; i < index - 1; i++) {
         //找到插入位置的前一個節點
         preNode = preNode.next;
     }
     Node node = new Node(e);
     node.next = preNode.next;
     preNode.next = node;
     size++;
 }

單鏈表---刪

/**
 * 刪除頭部節點
 */
public void remove() {
    if (list != null) {
        Node node = list;
        list = node.next;
        //GC
        node.next = null;
        size--;
    }
}

/**
 * 刪除指定位置節點
 * 1 2 3 4 5
 * 0 1 2 3 4
 *
 * @param index
 */
public void remove(int index) {
    checkElementIndex(index);
    Node preNode = list;
    for (int i = 0; i < index - 1; i++) {
        //找到指定位置元素的前一個節點
        preNode = preNode.next;
    }
    //指定位置的節點
    Node next = preNode.next;
    preNode.next = next.next;
    //GC
    next = null;
    size--;
}

/**
 * 刪除最後一個節點
 */
public void removeLast() {
    if (list != null) {
        //當前節點
        Node cur = list;
        //最後一個節點的前一個節點
        Node preNode = list;
        while (cur.next != null) {
            preNode = cur;
            cur = cur.next;
        }
        preNode = null;//此時cur已經為null
        size--;
    }
}

單鏈表---改

/**
 * 修改指定索引的元素
 *
 * @param index
 * @param e
 */
public void set(int index, E e) {
    checkElementIndex(index);
    Node cur = list;
    for (int i = 0; i < index; i++) {
        cur = cur.next;
    }
    cur.data = e;
}

單鏈表---查

 /**
  * 獲取頭部節點
  */
 public E get() {
     if (list != null) {
         return list.data;
     } else {
         return null;
     }
 }

  /**
   * 獲取指定位置的元素
   *
   * @param index
   * @return
   */
  public E get(int index) {
      checkElementIndex(index);
      Node cur = list;
      for (int i = 0; i < index; i++) {
          cur = cur.next;
      }
      return cur.data;
  }

完整程式碼

/**
 * 單鏈表
 *
 */
public class SingleLinkedList<E> {

    int size = 0;

    /**
     * 指向第一個節點的指標
     */
    Node list;

    /**
     * 頭部新增節點
     *
     * @param e
     */
    public void add(E e) {
        //頭結點
        Node cur = new Node(e, list);
        list = cur;
        size++;
    }

    /**
     * 指定位置新增節點
     *
     * @param index
     * @param e     0 1 2 3 4
     */
    public void add(int index, E e) {
        checkElementIndex(index);
        Node preNode = list;
        for (int i = 0; i < index - 1; i++) {
            //找到插入位置的前一個節點
            preNode = preNode.next;
        }
        Node node = new Node(e);
        node.next = preNode.next;
        preNode.next = node;
        size++;
    }


    /**
     * 刪除頭部節點
     */
    public void remove() {
        if (list != null) {
            Node node = list;
            list = node.next;
            //GC
            node.next = null;
            size--;
        }
    }

    /**
     * 刪除指定位置節點
     * 1 2 3 4 5
     * 0 1 2 3 4
     *
     * @param index
     */
    public void remove(int index) {
        checkElementIndex(index);
        Node preNode = list;
        for (int i = 0; i < index - 1; i++) {
            //找到指定位置元素的前一個節點
            preNode = preNode.next;
        }
        //指定位置的節點
        Node next = preNode.next;
        preNode.next = next.next;
        //GC
        next = null;
        size--;
    }

    /**
     * 刪除最後一個節點
     */
    public void removeLast() {
        if (list != null) {
            //當前節點
            Node cur = list;
            //最後一個節點的前一個節點
            Node preNode = list;
            while (cur.next != null) {
                preNode = cur;
                cur = cur.next;
            }
            preNode = null;//此時cur已經為null
            size--;
        }
    }

    /**
     * 修改指定索引的元素
     *
     * @param index
     * @param e
     */
    public void set(int index, E e) {
        checkElementIndex(index);
        Node cur = list;
        for (int i = 0; i < index; i++) {
            cur = cur.next;
        }
        cur.data = e;
    }

    /**
     * 獲取頭部節點
     */
    public E get() {
        if (list != null) {
            return list.data;
        } else {
            return null;
        }
    }

    /**
     * 獲取指定位置的元素
     *
     * @param index
     * @return
     */
    public E get(int index) {
        checkElementIndex(index);
        Node cur = list;
        for (int i = 0; i < index; i++) {
            cur = cur.next;
        }
        return cur.data;
    }


    class Node {
        E data;
        Node next;

        public Node(E element, Node next) {
            this.data = element;
            this.next = next;
        }

        public Node(E data) {
            this.data = data;
        }

        public Node() {
        }

        @Override
        public String toString() {
            return "Node{" +
                    "data=" + data +
                    ", next=" + next +
                    '}';
        }
    }

    /**
     * 判斷引數是否為現有元素的索引  即邊界
     *
     * @param index
     */
    private void checkElementIndex(int index) {
        if (!(index >= 0 && index < size))
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
    }

    @Override
    public String toString() {
        Node node = list;
        for (int i = 0; i < size; i++) {
            System.out.print(node.data + " ");
            node = node.next;
        }
        return super.toString();
    }

    public static void main(String[] args) {
        SingleLinkedList<Integer> list = new SingleLinkedList<>();
        list.add(5);
        list.add(4);
        list.add(3);
        list.add(2);
        list.add(1);
        list.toString();
        System.out.println();
        list.add(2, 5);
        list.toString();
        list.removeLast();
        System.out.println();
        list.toString();
        list.set(1, 1);
        System.out.println();
        list.toString();
        System.out.println();
        System.out.println(list.get());
    }
}

雙鏈表LinkedList原始碼分析

雙鏈表，指各節點之間的邏輯關係是雙向的。

節點


因此，在雙向連結串列中各節點包含以下 3 部分資訊

  • 指標域：用於指向當前節點的直接前驅節點；
  • 資料域：用於儲存資料元素。
  • 指標域：用於指向當前節點的直接後繼節點；
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;
    }
}

如果理解了單鏈表，雙項鍊表其實也沒有太多的差別，主要在於限制條件。不僅僅是雙向連結串列，還有很多分類，比如靜態連結串列，動態連結串列，迴圈連結串列等等。這裡可以就增刪給出對應的過程，原始碼可以自己去研究研究。

類的繼承關係

雙鏈表---增

public void add(int index, E element) {
    checkPositionIndex(index);
	//如果索引和size相等直接尾部插入
    if (index == size)
    	linkLast(element);
    else
    	linkBefore(element, node(index));
}


/**
 * first 指向第一個節點的指標
 * @param e 要插入的元素
 * @param succ index位置的節點
 *  a1        a3
 * 在a3索引出插入新的元素  a2
 *  a1    a2    a3
 */
void linkBefore(E e, Node<E> succ) {
    // succ：原a3的前置節點a1
    final Node<E> pred = succ.prev;
    //pred(a1) e(a2) succ(a3)形成新的節點
    //即把e(a2)prev指向pred(a1)節點，把e(a2)next指向succ(a3)節點
    final Node<E> newNode = new Node<>(pred, e, succ);
    //把succ(a3)的prev指向新的節點newNode
    succ.prev = newNode;
    //pred為空代表newNode為首節點
    if (pred == null)
    	first = newNode;
    else
    	//a1的next節點由a3變為a2
    	pred.next = newNode;
    size++;
    modCount++;
}

雙鏈表---刪

public E remove(int index) {    checkElementIndex(index);    return unlink(node(index));    }/** * Unlinks non-null node x. */ E unlink(Node<E> x) {     // assert x != null;     //獲取該節點的值     final E element = x.item;     //獲取該節點的next節點     final Node<E> next = x.next;     //獲取該節點的prev節點     final Node<E> prev = x.prev;     //把該節點的前節點的next指向該節點的next節點，並清除該節點的prev指向     if (prev == null) {     	first = next;     } else {     	prev.next = next;     	x.prev = null;     }     //把該節點的next節點的prev指向該節點的prev節點，並清除該節點的next指向     if (next == null) {     	last = prev;     } else {     	next.prev = prev;     	x.next = null;     }     x.item = null;//gc清除     size--;     modCount++;     return element; }

總結

前面講過ArrayList原始碼分析及擴容機制,如果你看了應該知道不管是用ArrayList還是LinkedList主要是看場景，LinkedList增刪快，因為只用調整指向即可，對於ArrayList而言卻要移動整個陣列，但是如果說是在尾部插入的話，使用兩者都可以。而查詢和修改卻要ArrayList只需要知道下標即可，而對於LinkedList卻要通過迴圈查詢。

對於LinkendList，其中還有很多方法，例如addFirst，addLast，remove等，如果你學會了單鏈表，其實雙鏈表也是一樣的，主要在於思維。

參考

拓展延伸

  • ArrayList和LinkedList有什麼區別？
  • 什麼時候用ArrayList,什麼時候用LinkedList？

相關推薦

連結串列之LinkedList

寫在前面 在日常開發中，一般在對於List的場景，基本上都是通過ArrayList去封裝資料的，而對於連結串列LinkedList相對來說用的比較少。對我而言，好像ArrayList熟練度高一些，所以基本上也很少用LinkedList，也就是

2010_線性表之連結串列之雙向連結串列

2.2.2 雙向連結串列 2.2.2.1 API設計 類名Node 構造器Node(T t, Node pre, Node next) 成員變數 T item;儲存資料Node next;指向下一個結點Node pre;指向上一個結點

2009_線性表之連結串列之單向連結串列

之前我們已經使用順序結構實現了線性表, 我們會發一雖然順序表的查詢很快,時間複雜度為O(1)但是增刪的效率是比較低的, 因為每一次增刪操作都 伴著大量的資料元素移動. 這個問題 有沒有解決方案呢? 有, 我們可以使用另

Python連結串列之單向連結串列

單向連結串列也叫單鏈表，是連結串列中最簡單的一種形式，它的每個節點包含兩個域，一個資訊域（元素域）和一個連結域。這個連結指向連結串列中的下一個節點，而最後一個節點的連結域則指向一個空值。

Python連結串列之單向迴圈連結串列

class Node(object): \"\"\"單鏈表的節點\"\"\" def __init__(self, item): # item存放資料元素 self.item = item

Linux核心連結串列之共享雙鏈表

說明 共享雙鏈表意義在於，可以用一套函式維護不同資料型別的雙鏈表 準備 定義雙鏈表

單向連結串列之兩數相加

單向連結串列是什麼？ 單鏈表是一種鏈式存取的資料結構，用一組地址任意的儲存單元存放線性表中的資料元素。

演算法-連結串列-之查詢連結串列環的入口節點

思路：很自然的想到用map，利用map key-value 鍵值對的唯一性。遍歷連結串列把每個元素儲存到map裡面，如果是重複的就不儲存，同時就返回這個結果，就是想要的值。但是這樣操作下來，空間複雜度是o（n），時間也是

?史上最全的Java容器集合之基礎資料結構（手撕連結串列）

前言 文字已收錄至我的GitHub倉庫，歡迎Star：github.com/bin39232820…種一棵樹最好的時間是十年前，其次是現在

資料結構與演演算法之連結串列的那些事兒

前言 一名優秀的程式設計師，必然要有紮實的資料結構與演演算法基礎。以下是筆者梳理的資料結構與算法系列，歡迎大家閱讀指正，同時也希望對大家有所幫助。

劍指offer之連結串列合集

一、刪除連結串列節點 例：1->2->3->4->5 思路：假如要刪除節點3，常規思路是遍歷連結串列，當遍歷到節點2的時候，發現節點2的 next是節點3，然後將將節點2的next指向節點4。時間複雜度是O(n)。

redis原始碼分析教程之壓縮連結串列ziplist詳解

前言 壓縮列表（ziplist）是由一系列特殊編碼的記憶體塊構成的列表，它對於Redis的資料儲存優化有著非常重要的作用。這篇文章總結一下redis中使用非常多的一個數據結構壓縮連結串列ziplist。該資料結構在redis中說是

Java資料結構預演算法之連結串列

二、連結串列 1、介紹 連結串列是一個有序的列表，上一個資料連線下一個資料，通過連結串列指標連線，順序不可改變。

Redis系列（八）：資料結構List雙向連結串列中阻塞版本之BLPOP、BRPOP和LINDEX、LINSERT、LRANGE命令詳解

1.BRPOP、BLPOP BLPOP： BLPOP是阻塞式列表的彈出原語。 它是命令LPOP的阻塞版本，這是因為當給定列表內沒有任何元素可供彈出的時候，

《資料結構與演算法之美》16——散列表（三）為什麼散列表和連結串列經常會一起使用？

有兩種資料結構（散列表和連結串列）經常會被放在一起使用。前面的章節中有兩個地方講到散列表和連結串列的組合使用，分別是：

java演算法篇之三：連結串列

1. 簡介 前面已經實現了動態陣列、棧、佇列三種線性資料結構，但其底層都是依託靜態陣列，靠resize解決固定容量問題。

資料結構與演算法之美【三】基礎篇-連結串列

連結串列 Linked List 與LRU快取策略 本文內容，單鏈表、雙向連結串列與迴圈連結串列。單鏈表實現LRU的機制。迴文單鏈表的判斷。

資料結構_線性表之連結串列（1）

這是連結串列的第一篇。連結串列方便插入刪除，但是不是隨機存取。實際應用中，用於頻繁的增加刪除操作。

leetcode之19刪除連結串列的倒數第N個結點Golang

首先連結串列是單鏈表： type ListNode struct { Valint Next *ListNode } 　　那麼假如我們又連結串列1->2->3->4->5

leetcode之21合併兩個有序連結串列Golang

這道題很簡單，只需要從頭開始遍歷兩個連結串列，每次將兩個連結串列的當前元素比較，值較小的結點就存入到新的連結串列