2. 程式人生 > >最基礎的動態數據結構：鏈表

最基礎的動態數據結構：鏈表

阿新 • • 發佈：2018-11-09
truct exc shadow equal this stack 讓其 靜態 垃圾

什麽是鏈表

鏈表是一種線性結構，也是最基礎的動態數據結構。我們在實現動態數組、棧以及隊列時，底層都是依托的靜態數組，靠resize來解決固定容量的問題，而鏈表是真正的動態數據結構。學習鏈表這種數據結構，能夠更深入的理解引用（或者指針）以及遞歸。其中鏈表分為單鏈鏈表和雙鏈鏈表，本文中所介紹的是單鏈鏈表。

鏈表中的數據是存儲在一個個的節點中，如下這是一個最基本的節點結構：

class Node {
    E e;
    Node next;  // 節點中持有下一個節點的引用
}

我們可以將鏈表想象成火車，每一節車廂就是一個節點，乘客乘坐在火車的車廂中，就相當於元素存儲在鏈表的節點中。火車的每一節車廂都連接著下一節車廂，就像鏈表中的節點都會持有下一個節點的引用。火車的最後一節車廂沒有連接任何車廂，就像鏈表中末尾的節點指向null一樣：

技術分享圖片

鏈表優缺點：

  • 優點：真正的動態結構，不需要處理固定容量的問題，從中間插入、刪除節點很方便，相較於數組要靈活
  • 缺點：喪失了隨機訪問的能力，不能像數組那種直接通過索引訪問

廢話不多說，我們開始來編寫鏈表這個數據結構吧，首先來實現鏈表中的節點結構以及鏈表的一些簡單方法，代碼如下：

/**
 * @program: Data-Structure
 * @description: 鏈表數據結構實現
 * @author: 01
 * @create: 2018-11-08 15:37
 **/
public class LinkedList<E> {
    /**
     * 鏈表中的節點結構
     */
    private class Node {
        E e;
        Node next;

        public Node() {
            this(null, null);
        }

        public Node(E e) {
            this(e, null);
        }

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

        @Override
        public String toString() {
            return e.toString();
        }
    }

    /**
     * 頭節點
     */
    private Node head;

    /**
     * 鏈表中元素的個數
     */
    private int size;

    public LinkedList() {
        this.head = null;
        this.size = 0;
    }

    /**
     * 獲取鏈表中的元素個數
     *
     * @return 元素個數
     */
    public int getSize() {
        return size;
    }

    /**
     * 鏈表是否為空
     *
     * @return 為空返回true，否則返回false
     */
    public boolean isEmpty() {
        return size == 0;
    }    
}

在鏈表中添加元素

我們在為數組添加元素時，最方便的添加方式就是從數組後面進行添加，因為size總是指向數組最後一個元素+1的位置，所以利用size變量我們可以很輕易的完成元素的添加。

而在鏈表中則相反，我們在鏈表頭添加新的元素最方便，因為鏈表內維護了一個head變量，即鏈表的頭部，我們只需要將新的元素放入一個新的節點中，然後將新節點內的next變量指向head，最後把head指向這個新節點就完成了元素的添加：
技術分享圖片

我們來實現這個在鏈表頭添加新的元素的方法，代碼如下：

/**
 * 在鏈表頭添加新的元素e
 *
 * @param e 新的元素
 */
public void addFirst(E e) {
    Node node = new Node(e);
    node.next = head;
    head = node;

    // 以上三句代碼完全可以直接使用以下一句代碼完成，
    // 但為了讓邏輯更清晰所以這裏特地將代碼分解了
    // head = new Node(e, head);

    size++;
}

然後我們來看看如何在鏈表中指定的位置插入新的節點，雖然這在鏈表中不是一個常用的操作，但是有些鏈表相關的題目會涉及到這種操作，所以我們還是得了解一下。例如我們現在要往“索引”為2的位置插入一個新的節點，該如何實現：
技術分享圖片

雖然鏈表中沒有真正的索引，但是為了實現在指定的位置插入新的節點，我們得引用索引這個概念。如上圖中，把鏈表頭看作是索引0，下一個節點看作索引1，以此類推。然後我們還需要有一個prev變量，通過循環移動這個變量去尋找指定的“索引” - 1 的位置，找到之後將新節點的next指向prev的next，prev的next再指向新的節點，即可完成這個插入節點的邏輯，所以關鍵點就是找到要添加的節點的前一個節點：
技術分享圖片

具體的實現代碼如下：

/**
 * 在鏈表的index(0-based)位置添加新的元素e
 *
 * @param index 元素添加的位置
 * @param e     新的元素
 */
public void add(int index, E e) {
    // 檢查索引是否合法
    if (index < 0 || index > size) {
        throw new IllegalArgumentException("Add failed. Illegal index.");
    }

    // 鏈表頭添加需特殊處理
    if (index == 0) {
        addFirst(e);
    } else {
        Node prev = head;
        // 移動prev到index - 1的位置
        for (int i = 0; i < index - 1; i++) {
            prev = prev.next;
        }

        Node node = new Node(e);
        node.next = prev.next;
        prev.next = node;

        // 同樣，以上三句代碼可以一句代碼完成
        // prev.next = new Node(e, prev.next);

        size++;
    }
}

基於以上這個方法，我們就可以輕易的實現在鏈表末尾添加新的元素：

/**
 * 在鏈表末尾添加新的元素e
 *
 * @param e 新的元素
 */
public void addLast(E e) {
    add(size, e);
}

使用鏈表的虛擬頭節點

在上一小節中，我們實現向指定位置插入元素的代碼裏，需對鏈表頭的位置特殊處理，因為鏈表頭沒有上一個節點。很多時候使用鏈表的都需要進行類似的特殊處理，並不是很優雅，所以本小節就是介紹如何優雅的解決這個問題。

之所以要進行特殊處理，主要原因還是head沒有上一個節點，初始化prev的時候只能指向head，既然這樣我們就給它前面加一個節點好了，這個節點不存儲任何數據，僅作為一個虛擬節點。這也是編寫鏈表結構時經常使用到的技巧，添加這麽一個節點就可以統一鏈表的操作邏輯：
技術分享圖片

修改後的代碼如下：

public class LinkedList<E> {
    ...

    /**
     * 虛擬頭節點
     */
    private Node dummyHead;

    /**
     * 鏈表中元素的個數
     */
    private int size;

    public LinkedList() {
        this.dummyHead = new Node(null, null);
        this.size = 0;
    }

    /**
     * 在鏈表的index(0-based)位置添加新的元素e
     *
     * @param index 元素添加的位置
     * @param e     新的元素
     */
    public void add(int index, E e) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed. Illegal index.");
        }

        Node prev = dummyHead;
        // 移動prev到index前一個節點的位置
        for (int i = 0; i < index; i++) {
            prev = prev.next;
        }

        Node node = new Node(e);
        node.next = prev.next;
        prev.next = node;

        // 同樣，以上三句代碼可以一句代碼完成
        // prev.next = new Node(e, prev.next);

        size++;
    }

    /**
     * 在鏈表頭添加新的元素e
     *
     * @param e 新的元素
     */
    public void addFirst(E e) {
        add(0, e);
    }

    /**
     * 在鏈表末尾添加新的元素e
     *
     * @param e 新的元素
     */
    public void addLast(E e) {
        add(size, e);
    }
}

鏈表的遍歷、查詢和修改

有了以上小節的基礎，接下來我們實現鏈表的遍歷、查詢和修改就很簡單了，代碼如下：

/**
 * 獲取鏈表的第index(0-based)個位置的元素
 *
 * @param index
 * @return
 */
public E get(int index) {
    if (index < 0 || index >= size) {
        throw new IllegalArgumentException("Get failed. Illegal index.");
    }

    Node cur = dummyHead.next;
    for (int i = 0; i < index; i++) {
        cur = cur.next;
    }

    return cur.e;
}

/**
 * 獲取鏈表中的第一個元素
 *
 * @return
 */
public E getFirst() {
    return get(0);
}

/**
 * 獲取鏈表中的最後一個元素
 *
 * @return
 */
public E getLast() {
    return get(size - 1);
}

/**
 * 修改鏈表的第index(0-based)個位置的元素為e
 *
 * @param index
 * @param e
 */
public void set(int index, E e) {
    if (index < 0 || index >= size) {
        throw new IllegalArgumentException("Set failed. Illegal index.");
    }

    Node cur = dummyHead.next;
    for (int i = 0; i < index; i++) {
        cur = cur.next;
    }

    cur.e = e;
}

/**
 * 查找鏈表中是否包含元素e
 *
 * @param e
 * @return
 */
public boolean contain(E e) {
    Node cur = dummyHead.next;
    // 第一種遍歷鏈表的方式
    while (cur != null) {
        if (cur.e.equals(e)) {
            return true;
        }
        cur = cur.next;
    }

    return false;
}

@Override
public String toString() {
    if (isEmpty()) {
        return "[]";
    }

    StringBuilder sb = new StringBuilder();
    sb.append(String.format("LinkedList: size = %d\n", size));
    sb.append("[");
    Node cur = dummyHead.next;
    // 第二種遍歷鏈表的方式
    for (int i = 0; i < size; i++) {
        sb.append(cur.e).append(" -> ");
        cur = cur.next;
    }

    // 第三種遍歷鏈表的方式
    // for (Node cur = dummyHead.next; cur != null; cur = cur.next) {
    //     sb.append(cur.e).append(" -> ");
    // }

    return sb.append("NULL]").toString();
}

從鏈表中刪除元素

最後我們要實現的鏈表操作就是從鏈表中刪除元素，刪除元素就相當於是刪除鏈表中的節點。例如我要刪除”索引“為2的節點，同樣的我們也需要使用一個prev變量循環移動到要刪除的節點的前一個節點上，此時把prev的next拿出來就是待刪除的節點。刪除節點也很簡單，拿出待刪除的節點後，將prev的next指向待刪除節點的next：
技術分享圖片

最後將待刪除的節點指向一個null，讓其脫離鏈表，這樣就能夠快速被垃圾回收，如此一來就完成了節點的刪除：
技術分享圖片

具體的實現代碼如下：

/**
 * 從鏈表中刪除第index(0-based)個位置的元素，並返回刪除的元素
 *
 * @param index
 * @return 被刪除的節點所存儲的元素
 */
public E remove(int index) {
    if (index < 0 || index >= size) {
        throw new IllegalArgumentException("remove failed. Illegal index.");
    }

    Node prev = dummyHead;
    for (int i = 0; i < index; i++) {
        prev = prev.next;
    }

    Node delNode = prev.next;
    // 把引用改變一下就完成了刪除
    prev.next = delNode.next;
    delNode.next = null;
    size--;

    return delNode.e;
}

基於以上這個方法，我們就可以很簡單的實現如下兩個方法：

/**
 * 刪除鏈表中第一個元素
 *
 * @return 被刪除的元素
 */
public E removeFirst() {
    return remove(0);
}

/**
 * 刪除鏈表中最後一個元素
 *
 * @return 被刪除的元素
 */
public E removeLast() {
    return remove(size - 1);
}

最後我們來看一下我們實現的這個鏈表增刪查改操作的時間復雜度：

addLast(e)         // O(n)
addFirst(e)        // O(1)
add(index, e)      // O(n)
removeLast()       // O(n)
removeFirst()      // O(1)
remove(index)      // O(n)
set(index, e)      // O(n)
get(index)         // O(n)
contain(e)         // O(n)

使用鏈表實現棧

從鏈表的addFirst和removeFirst方法的時間復雜度可以看到，如果只對鏈表頭進行增、刪操作的復雜度是O(1)的，只查詢鏈表頭的元素復雜度也是O(1)的。這時我們就可以想到使用鏈表來實現棧，用鏈表實現的棧其入棧出棧等操作時間復雜度也都是O(1)的，具體的實現代碼如下：

/**
 * @program: Data-Structure
 * @description: 基於鏈表實現棧數據結構
 * @author: 01
 * @create: 2018-11-08 23:38
 **/
public class LinkedListStack<E> implements Stack<E> {
    private LinkedList<E> linkedList;

    public LinkedListStack() {
        this.linkedList = new LinkedList<>();
    }

    @Override
    public int getSize() {
        return linkedList.getSize();
    }

    @Override
    public boolean isEmpty() {
        return linkedList.isEmpty();
    }

    @Override
    public void push(E e) {
        linkedList.addFirst(e);
    }

    @Override
    public E pop() {
        return linkedList.removeFirst();
    }

    @Override
    public E peek() {
        return linkedList.getFirst();
    }

    @Override
    public String toString() {
        if (isEmpty()) {
            return "[]";
        }

        StringBuilder sb = new StringBuilder();
        sb.append(String.format("LinkedListStack: size = %d\n", getSize()));
        sb.append("top [");
        for (int i = 0; i < getSize(); i++) {
            sb.append(linkedList.get(i));
            if (i != getSize() - 1) {
                sb.append(", ");
            }
        }
        return sb.append("]").toString();
    }

    // 測試
    public static void main(String[] args) {
        Stack<Integer> stack = new LinkedListStack<>();

        for (int i = 0; i < 5; i++) {
            stack.push(i);
            System.out.println(stack);
        }

        stack.pop();
        System.out.println(stack);
    }
}

帶有尾指針的鏈表：使用鏈表實現隊列

上一小節我們基於鏈表很輕易的就實現了一個棧結構，本小節我們來看看如何使用鏈表實現隊列結構，看看需要對鏈表進行哪些改進。

在編寫代碼之前，我們需要考慮到一個問題，在之前鏈表結構的實現代碼中，只有一個head變量指向頭節點，若我們直接使用這個鏈表實現隊列的話，需要操作鏈尾的元素時，復雜度是O(n)的，因為需要遍歷整個鏈表直到尾節點的位置。那麽該如何避開遍歷，在O(1)的復雜度下快速的找到尾節點呢？答案就是增加一個tail變量，讓這個變量始終指向尾節點即可，這樣我們操作尾節點的復雜度就是O(1)了。

除此之外，使用鏈表實現隊列還有一個問題需要考慮，那就是從哪邊入隊元素，從哪邊出隊元素。我們之前編寫的鏈表代碼中，在鏈首添加元素是O(1)的，也是最簡單方便的，所以我們要將鏈首作為入隊的一端嗎？答案是相反的，應該將鏈首作為出隊的一端，鏈尾作為入隊的一端。

因為我們實現的鏈表是單鏈結構，在這種情況下鏈首無論是作為入隊還是出隊的一端都是可以的，但是鏈尾不可以，鏈尾只能作為入隊的一端。如果將鏈尾作為出隊的一端，那麽出隊的復雜度將是O(n)的，需要遍歷鏈表找到尾節點的上一個節點，然後將該節點的next指向null才能完成出隊的操作。若是雙鏈結構倒是無所謂，只需要通過tail變量就可以獲取到上一個節點，不需要遍歷鏈表去尋找。因此，我們需要將鏈首作為入隊的一端，鏈尾作為出隊的一端，這樣無論是出隊還是入隊的時間復雜度都是O(1)。

具體的實現代碼如下：

/**
 * @program: Data-Structure
 * @description: 基於鏈表實現的隊列數據結構
 * @author: 01
 * @create: 2018-11-09 17:00
 **/
public class LinkedListQueue<E> implements Queue<E> {
    private class Node {
        E e;
        Node next;

        public Node() {
            this(null, null);
        }

        public Node(E e) {
            this(e, null);
        }

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

        @Override
        public String toString() {
            return e.toString();
        }
    }

    /**
     * 頭節點
     */
    private Node head;

    /**
     * 尾節點
     */
    private Node tail;

    /**
     * 表示隊列中的元素個數
     */
    private int size;

    @Override
    public void enqueue(E e) {
        if (tail == null) {
            // 鏈表沒有元素
            tail = new Node(e);
            head = tail;
        } else {
            // 鏈尾入隊元素
            tail.next = new Node(e);
            tail = tail.next;
        }
        size++;
    }

    @Override
    public E dequeue() {
        if (isEmpty()) {
            throw new IllegalArgumentException("Can‘t dequeue from an empty queue.");
        }

        // 鏈首出隊元素
        Node retNode = head;
        head = head.next;
        retNode.next = null;
        if (head == null) {
            // 隊列裏沒元素的話，尾節點需要置空
            tail = null;
        }
        size--;

        return retNode.e;
    }

    @Override
    public E getFront() {
        if (isEmpty()) {
            throw new IllegalArgumentException("Queue is empty.");
        }

        return head.e;
    }

    @Override
    public int getSize() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public String toString() {
        if (isEmpty()) {
            return "[]";
        }

        StringBuilder sb = new StringBuilder();
        sb.append(String.format("LinkedListQueue: size = %d\n", getSize()));
        sb.append("front [");
        Node cur = head;
        while (cur != null) {
            sb.append(cur.e).append(", ");
            cur = cur.next;
        }

        return sb.append("NULL] tail").toString();
    }
}

最基礎的動態數據結構：鏈表

相關推薦

最基礎的動態數據結構：鏈表

truct exc shadow equal this stack 讓其 靜態 垃圾 什麽是鏈表 鏈表是一種線性結構，也是最基礎的動態數據結構。我們在實現動態數組、棧以及隊列時，底層都是依托的靜態數組，靠resize來解決固定容量的問題，而鏈表是真正的動態數據結構。學習鏈表

基本數據結構：鏈表

lis 最大 src 雙向鏈表 頻繁 鏈式表 結構 節點 aid 談到鏈表之前，先說一下線性表。線性表是最基本、最簡單、也是最常用的一種數據結構。線性表中數據元素之間的關系是一對一的關系，即除了第一個和最後一個數據元素之外，其它數據元素都是首尾相接的。線性表有兩種存儲方

數據結構：鏈表（三）

尾插法 .com 鏈表 inf fin 數據 code com python 一、鏈表基礎 1、什麽是鏈表？ 鏈表中每一個元素都是一個對象，每個對象稱為一個節點，包含有數據域key和指向下一個節點的指針next。通過各個節點之間的相互連接，最終串聯成一個鏈表。 2、節點定義

Python基礎【數據結構：列表 | 元組 | 集合 | 字典】

enume 不能 之前 差集 數字 values 顯示 int list 序列 序列是Python中最基本的數據結構。包括字符串，列表，元組，Unicode字符串，buffer對象，xrange對象。序列中的每個元素都分配一個數字，即它的索引第一個索引是0，第二個索引是

數據結構之鏈表

ret 需要 ror std 用戶輸入 用戶 存儲 足夠 存在 數據結構——鏈表 在c++中，數組對應著一個連續存儲的內存塊，將同類型的元素一個一個地排列起來，是組織數據的很好的方法。聲明數組的同時我們需要告訴編譯器數組的大小，以便開辟足夠大小的內存。但是，在解決實際問

數據結構-單向鏈表 C和C++的實現

下標 using print find 十分 for null type 一位 數據結構，一堆數據的存放方式。 今天我們學習數據結構中的 鏈表： 數組，大家相當熟悉的存放數據方式，而鏈表是數組的一種特殊方式，它每個節點包括兩個部分： 數據域：存放數據，此部分與數組相同

redis源碼分析（3）-- 基本數據結構雙鏈表list

direction 函數指針 all eas 源碼 計數 type ima blog 一、雙鏈表結構 redis中實現的雙鏈表結構體如下： 1 typedef struct list { 2 listNode *head; # 鏈表頭 3 listNode

數據結構-雙向鏈表&雙向循環鏈表

class 項目 none png text mes 分享 row 兩個 借圖：http://www.cnblogs.com/skywang12345/p/3561803.html#a33 雙向鏈表 雙向鏈表(雙鏈表)是鏈表的一種。和單鏈表一樣，雙鏈表也是由節點組成，它的每

數據結構：線性表

spa eat solid endif 數據 png tex 只有一個 pre 線性表設計與實現 線性表基本概念 線性表定義 線性表(List)是零個或多個數據元素的集合 線性表中的數據元素之間是有順序的 線性表中的數據元素個數是有限的 線性表中的數據元素的類型必

數據結構之鏈表操作

index stat nbsp ID prev set append his 改進 對鏈表的增刪改查簡單實現 public class LinkedList<E> { private class Node{ public Node

數據結構之鏈表及實現

oid void scan pan 尋找 最大 執行 連續 邏輯 線性表的鏈式表示和實現 線性表的順序存儲結構的特點是邏輯關系上相鄰的兩個元素在物理位置上也相鄰。正由於這種特點，在做插入和刪除操作時，需移動大量元素。 鏈式存儲：不要求邏輯上相鄰的元素在物理位置上也相鄰，特點

c++數據結構之鏈表詳情1(順序鏈表)

length thead cout main.c 元素 protected 序表 3.2 font 長大是人必經的潰爛 ---大衛塞林格 代碼是年輕人的新生！！！！！！ 程序 = 數據結構 + 算法 --Niklaus EmilWirth 這篇博客在參考

Java數據結構——雙向鏈表

.com bubuko http 分享圖片 null wid string 元素 java數據結構 什麽是雙向鏈表？每一個結點不僅配有next引用，同時還有一個prev引用，指向其上一個結點（前驅結點）， 沒有前驅的時候就為NULL。 （以下圖片均來自網絡，侵刪）

Redis數據結構：跳躍表

有序 組成 個數 對象大小 指向 head sco list數據 數量 1. 跳躍表是有序集合（zset）的底層實現之一； 2. 由zskiplist和zskiplistNode組成； 3. 每個跳躍表節點的層數都是1-32之間的隨機數（每創建一個節點的時候，程序會隨機

最基礎的動態數據結構——鏈表

build 刪除鏈表 頭插 程序 val 單元 動態生成 sem 順序結構 定義 鏈表是一種物理存儲單元上非連續、非順序的存儲結構，數據元素的邏輯順序是通過鏈表中的指針鏈接次序實現的。鏈表由一系列結點（鏈表中每一個元素稱為結點）組成，結點可以在運行時動態生成。每個結點包括兩

java數據結構：雙向鏈表

分享圖片 nodevalue next args 新增 data over bre print 雙向鏈表與單鏈表區別在於他多了一個鏈域，用來存放前驅節點。 基本方法實現： 新增節點： 當前節點的next為新增節點，新增節點的next為當前節點的next.next新增節點

第二章、最基本的數據結構——隊列、棧、鏈表

算法基礎還記得大學算法課，老師提過，程序=算法+數據結構，不一定非常正確，但表明了一個事實：算法和數據結構的重要性。 在做題的過程，用經典的算法+合適的數據結構，一道題基本也完成了80%，考慮下取值範圍的限制以及輸入輸出條件，就差不多了。第二章、最基本的數據結構——隊列、棧、鏈表

數據結構：靜態鏈表實現樹的同構

phi truct 判斷 fin 給定 lib 其中 鏈表實現 不同的 寫在最前面 按照課程講解的思路來寫，邏輯關系能夠理解清楚了，但是實際運行起來實在是有問題，雖然在PTA上能夠通過。但是我自己看不出問題來，並且，看了一遍又一遍仍然看不出來！（可能自己太笨。。）這就說明有

內置數據結構 ：列表及常用操作

xtend 也會 count insert 返回 所在 .so 數據 start 列表是一個序列：用於順序的存儲數據， 通常在定義的時候，使用中括號，在轉化可叠代對象為列表時用list 函數 1，訪問列表元素： List[0] 通過下標訪問

Python之數據結構：集合

ict 轉換成 創建 可變 discard 重復 如果 upper amp 一、set集合 1、集合是一個無序不重復元素集,有去重的作用 set集合類需要的參數必須是叠代器類型的，如：序列、字典等，然後轉換成無序不重復的元素集。由於集合是不重復的，所以可以對字符串、列表、元