数据结构之链表

合集 - 数据结构与算法(24)

1.算法衡量优劣之时间复杂度2023-09-052.数据结构与算法之概念2023-09-013.算法衡量优劣之空间复杂度2023-09-064.数据结构之数组2023-09-06

5.数据结构之链表2023-09-11

6.数据结构之栈2023-09-147.N-皇后问题2023-09-198.算术表达式的表示法（即求值法）2023-09-249.算术表达式求值法（表达式求值）之前序表示法求值2023-09-2510.算术表达式求值法（表达式求值）之后序表示法求值2023-09-2711.数据结构之队列（一般队列）2023-10-0812.数据结构之队列（循环队列）2023-10-1113.数据结构之队列（双向队列）2023-10-1414.数据结构之树（基本概念）2023-10-2415.数据结构之树（二叉树）2023-10-2916.数据结构之树（Huffman tree(赫夫曼树 / 霍夫曼树 / 哈夫曼树 / 最优二叉树)）2023-10-3117.数据结构之树（二叉树的存储方式之数组）2023-11-0218.数据结构之树（二叉树的存储方式之链表）2023-11-0519.数据结构之树（遍历）2023-11-0520.数据结构之树（二叉运算树）2023-11-0721.数据结构之树（二叉搜索树）2023-11-0822.数据结构之树（线索树）2023-11-1123.数据结构之树（树转化为二叉树也叫二叉化）2023-11-1224.确定唯一二叉树2023-11-12

收起

说明

链表是数据结构中的线性结构，用于存储一系列元素（节点），其中每个元素都包含一个指向下一个元素的引用。

链表由一组节点组成，每个节点包含两个部分：数据和指向下一个节点的指针（或引用）。

线性结构中对比数组/列表的优势：插入和删除性能较好

涉及的概念：

1. 节点：节点包括2个域,元素域、链接域

2. 元素域也叫数据域：就是链表在该节点上存储的数据（元素）

3. 链接域也叫指针域：建立当前节点与前后节点的关系。比如：单链表就是当前节点存储其下个节点地址的指针。

分类

链表有多种类型，包括单链表、双链表和循环链表等。

单链表（Singly Linked List）

单链表（Singly Linked List）是一种常见的链表数据结构，它由一组节点组成，每个节点包含两部分信息：

1. 数据域：存储实际的元素值。
2. 指针域（或引用域）：指向下一个节点的引用或指针。

单链表的特点是每个节点只有一个指针，它指向链表中的下一个节点，而最后一个节点的指针通常为空，表示链表的结束。

单链表的第一个节点被称为头节点（Head），而最后一个节点的指针为空。链表的头节点用于表示链表的起始位置，通过头节点可以访问整个链表。

下面是一个简单的单链表示例：

[Head] -> [Node2] -> [Node3] -> [Node4] -> null

 

在上面的示例中，链表的头节点指向第2个节点Node2，Node2的指针指向Node3，依此类推，最后一个节点Node4的指针为空，表示链表结束。

单链表常用于需要频繁插入和删除元素的场景，因为插入和删除节点的操作相对高效。然而，它的随机访问效率较低，因为要访问特定位置的元素，必须从头节点开始遍历链表，直到达到目标节点。

 

特点：

单链表（Singly Linked List）是一种常见的链表数据结构，其主要特点包括以下几点：

1. 节点结构：单链表由一组节点组成，每个节点包含两个部分信息：

   • 数据域：用于存储实际的元素值。
   • 指针域（或引用域）：指向下一个节点的引用或指针。

2. 单向连接：单链表的节点之间通过指针（引用）实现单向连接。每个节点指向链表中的下一个节点，而最后一个节点的指针通常为空（null或None），表示链表的结束。

3. 头节点：单链表通常有一个头节点（Head），它是链表的第一个节点。

4. 随机访问效率低：要访问单链表中的特定位置的元素，通常需要从头节点开始遍历链表，直到达到目标位置。因此，单链表的随机访问效率相对较低，时间复杂度为 O(n)，其中 n 表示链表的长度。

5. 插入和删除效率高：单链表对于插入和删除节点的操作相对高效。插入节点时，只需修改相邻节点的指针，不需要移动整个链表。同样，删除节点时也只需修改相邻节点的指针。

6. 动态大小：单链表的大小可以动态增长或缩小，因为节点的插入和删除操作是高效的。

7. 占用内存相对较少（考虑到数组创建时就已经占用内存空间，链表是加入元素/节点才占用）：与数组相比，单链表通常占用较少的内存，因为它不需要预分配连续的内存空间。

8. 适用场景：单链表通常在需要频繁插入和删除元素，而不需要频繁随机访问元素的情况下使用。

总之，单链表是一种简单但常见的数据结构，用于存储和操作一系列元素。它的主要优势在于插入和删除操作的高效性，以及动态大小的能力。然而，随机访问效率较低，因此在需要随机访问元素的情况下，数组可能更为合适。选择链表类型应根据特定需求和应用场景来决定。

 

 双链表（Doubly Linked List）

是一种链表数据结构，与单链表相比，它的节点包含两个指针，分别指向前一个节点和后一个节点。这使得双链表在某些操作上比单链表更加灵活，但也更占用内存。

双链表节点的结构如下：

• 数据域：存储实际的元素值。
• 前驱指针（或前向指针）：指向前一个节点的引用或指针。
• 后继指针（或后向指针）：指向后一个节点的引用或指针。

下面是一个简单的双链表示例：

?

1	null <- [Head] <-> [Node1] <-> [Node2] <-> [Node3] <-> ... <-> [LastNode] <-> null

　　

• [Head] 表示头节点。
• <- 表示前驱指针。
• <-> 表示后继指针。
• [Node1]、[Node2]、[Node3] 表示实际的数据节点。
• [LastNode] 表示链表的最后一个节点。
• null 表示空指针，表示链表的结束。

在上面的示例中，双链表的头节点前驱指针为空，尾节点的后继指针都为空。Node1的前驱指针为空，后继指针指向Node2，Node2的前驱指针指向Node1，后继指针指向Node3，以此类推。

双链表相对于单链表具有以下优势：

1. 前向和后向遍历：双链表允许从头到尾或从尾到头轻松遍历链表，而不需要重新遍历。

2. 插入和删除效率高：插入和删除节点的操作在双链表中通常比在单链表中更高效，因为不需要查找前一个节点，可以直接通过前驱和后继指针执行操作。

3. 反向操作：在某些情况下，需要反向操作，双链表可以轻松满足这种需求。

然而，双链表相对于单链表也有一些缺点，其中之一是占用更多的内存，因为每个节点需要存储两个指针。此外，实现和维护双链表可能比单链表更复杂。

总之，双链表是一种灵活的数据结构，适用于需要前向和后向遍历以及高效插入和删除操作的场景。在选择链表类型时，您应该考虑您的需求以及链表的优缺点。

 

特点：

双链表（Doubly Linked List）是一种链表数据结构，相对于单链表具有以下主要特点：

1. 双向连接：每个节点包含两个指针，一个指向前一个节点（前驱节点），一个指向后一个节点（后继节点）。这使得在双链表中可以轻松从前向后或从后向前遍历链表，而不需要重新遍历。

2. 头节点和尾节点：通常，双链表有一个头节点和一个尾节点，它们分别用于表示链表的起始和结束。头节点的前驱指针为空，尾节点的后继指针为空，这样可以方便地在链表的两端插入和删除元素。

3. 插入和删除效率高：双链表对于插入和删除节点的操作相对高效。插入和删除节点时，只需修改相邻节点的指针，不需要重新遍历链表。

4. 随机访问效率较低：虽然双链表允许从前向后和从后向前遍历链表，但对于随机访问特定位置的元素，仍然需要从头节点或尾节点开始遍历，因此随机访问的效率相对较低，时间复杂度为 O(n)，其中 n 表示链表的长度。

5. 占用内存相对较多：相对于单链表，双链表通常占用更多的内存，因为每个节点需要存储两个指针（前驱和后继指针）。

6. 适用场景：双链表通常在需要频繁从前向后和从后向前遍历链表的场景中使用，以及需要在链表两端进行插入和删除操作的情况下使用。

总之，双链表是一种灵活的数据结构，它允许在链表中轻松进行前向和后向遍历，以及高效地进行插入和删除操作。但它相对于单链表占用更多的内存空间，因此在选择链表类型时，应根据特定需求和应用场景来决定。

 

双链表的最佳实践：

1. 初始化：始终在创建双链表时初始化头节点和尾节点，并确保它们的前驱和后继指针都为空。

2. 插入节点：插入节点时，更新前一个节点和后一个节点的指针（与当前节点的关系），以确保链表的正确连接。

3. 删除节点：删除节点时，更新前一个节点和后一个节点的指针，以跳过要删除的节点。

4. 前向和后向遍历：利用前驱和后继指针进行前向和后向遍历链表。注意在进行遍历之前检查指针是否为空，以防止访问不存在的节点。

5. 注意边界情况：在操作头节点和尾节点时要格外小心，因为它们的前驱和后继指针可能为空。

循环链表（特殊的单链表）

循环链表（Circular Linked List）是一种链表数据结构，它与常规链表（单链表或双链表）不同之处在于，循环链表的最后一个节点指向链表的第一个节点，形成一个循环。这个特点使得在循环链表中可以轻松地从任何节点开始遍历整个链表。

以下是循环链表的主要特点和详细解释：

1. 循环连接：循环链表的最后一个节点不是指向空（null或nil），而是指向链表的第一个节点，从而形成一个环。这种循环结构使得可以无限循环地遍历链表。

2. 头节点：循环链表通常有一个头节点（Head），它是链表的第一个节点。头节点不包含实际数据，只是用于表示链表的起始位置。头节点的后继指针指向链表的第一个实际节点，而尾节点的后继指针指向头节点。

3. 插入和删除效率高：与常规链表一样，循环链表对于插入和删除节点的操作相对高效。插入和删除节点时，只需修改相邻节点的指针，不需要重新遍历链表。

4. 随机访问效率较低：与常规链表一样，循环链表的随机访问效率较低，因为要访问特定位置的元素，通常需要从头节点开始遍历链表。

5. 应用场景：循环链表在某些特定场景中非常有用，例如循环队列（Circular Queue）和循环缓冲区（Circular Buffer）的实现。在这些场景中，需要循环使用有限的存储空间，而循环链表可以很好地满足这种需求。

特点：

1. 循环连接：循环链表的最后一个节点不是指向空，而是指向链表的第一个节点，形成一个环。这使得可以轻松地在循环链表中进行循环遍历，而不需要重新遍历整个链表。

2. 头节点：循环链表通常有一个头节点（Head），它是链表的第一个节点。头节点的后继指针指向链表的第二节点，而尾节点的后继指针也指向头节点，形成了循环。

3. 插入和删除效率高：与常规链表一样，循环链表对于插入和删除节点的操作相对高效。插入和删除节点时，只需修改相邻节点的指针，不需要重新遍历链表。

4. 随机访问效率较低：与常规链表一样，循环链表的随机访问效率相对较低，因为要访问特定位置的元素，通常需要从头节点开始遍历链表。

5. 应用场景：循环链表在某些特定场景中非常有用，例如实现循环队列（Circular Queue）和循环缓冲区（Circular Buffer）。在这些场景中，需要循环使用有限的存储空间，而循环链表可以很好地满足这种需求。

6. 无限循环：由于循环链表的特性，它可以被无限循环遍历，从而适用于需要连续循环访问数据的情况。

总之，循环链表是一种具有循环连接的链表数据结构，使得在链表中可以轻松进行循环遍历。它通常用于需要循环使用数据集的场景，同时具有与常规链表相似的插入和删除操作效率。选择循环链表还是常规链表应根据特定需求和应用场景来决定。

 

链表的优势

链表相对于数组具有一些优势：

1. 动态大小：链表可以根据需要动态增长或缩小，而数组的大小是固定的。

2. 插入和删除：在链表中插入或删除元素的操作通常比在数组中更高效，因为不需要移动其他元素。

3. 没有预分配内存：链表不需要预分配连续内存空间，这在处理大型数据集时非常有用。

 

链表的最佳实践

1. 选择正确的类型：选择链表类型（单链表、双链表、循环链表等）根据您的需求。不同类型的链表适用于不同的场景。

2. 维护头和尾：通常，保持对链表头和尾的引用可以加速插入和删除操作。

3. 避免过度使用链表：链表不适用于所有情况。在需要随机访问元素的情况下，数组通常更适合。

 

 

 

Javascript中的链表

 

单链表示例：

// 定义一个节点类：一个节点2个域，数据域、指针域
class Node {
    constructor(data) {
        this.data = data;  // 为数据域赋值
        this.next = null;  // 指针域默认是null，等入链时根据其位置设值：1. 作为head节点，其指针域值为之前的head值。 2. 作为tail节点，其指针域值就是null。 
    }
}

class LinkedList {
    constructor() {
        this.head = null;
    }

    append(data) {
        const newNode = new Node(data);
        if (!this.head) {
            this.head = newNode;
        } else {
            let current = this.head;
            while (current.next) {
                current = current.next;
            }
            current.next = newNode;
        }
    }

    display() {
        let current = this.head;
        while (current) {
            console.log(current.data);
            current = current.next;
        }
    }
}

const myList = new LinkedList();
myList.append(1);
myList.append(2);
myList.append(3);

myList.display(); // 输出 1, 2, 3

输出：

?

1 2 3

1 2 3

　　

双链表示例：

class Node {
    constructor(data) {
        this.data = data;
        this.prev = null; // 前驱指针
        this.next = null; // 后继指针
    }
}

class DoublyLinkedList {
    constructor() {
        this.head = null;
        this.tail = null;
    }

    // 在链表尾部添加节点
    append(data) {
        const newNode = new Node(data);
        if (!this.head) {  // 如果是空链，待插入的节点即是头节点，也是尾节点
            this.head = newNode;
            this.tail = newNode;
        } else {
            newNode.prev = this.tail;  // 设置待插入的节点前驱指针指向尾节点
            this.tail.next = newNode;  // 当前尾节点的后继指针直线待插入节点
            this.tail = newNode;       // 将待插入节点设置为尾节点即tail变量的值为待插入节点
        }
    }

    // 在链表头部添加节点
    prepend(data) {
        const newNode = new Node(data);
        if (!this.head) {         // 空链，待插入节点既是头节点也是尾节点
            this.head = newNode;
            this.tail = newNode;
        } else {
            newNode.next = this.head;  // 1. 待插入节点的后继指针，指向当前头节点
            this.head.prev = newNode;  // 2. 当前头节点的前驱指针指向待插入节点
            this.head = newNode;       // 3. 更新head变量的值为待插入节点
        }
    }

    // 删除指定节点
    delete(data) {
        let current = this.head;
        while (current) {
            if (current.data === data) {          // 1. 遍历，找到待删除的节点即current节点
                if (current === this.head) {      // 2. 如果是头节点，头节点下一个节点为head变量的值
                    this.head = current.next;
                    if (this.head) {               // 2.1 如果头节点不为空，则其前驱节点为null
                        this.head.prev = null;
                    }
                } else if (current === this.tail) { // 3. 如果待删除的是尾节点
                    this.tail = current.prev;       // 3.1 其前驱节点为尾节点
                    this.tail.next = null;          // 3.2 要满足尾节点的特点，后继指针为null
                } else {
                    current.prev.next = current.next;  // 4. 非头非尾节点，当前节点的下一个节点作为当前节点上一个节点的后继节点
                    current.next.prev = current.prev;  // 4.1 当前节点前驱节点作为当前节点下一个节点的前驱节点
                }
                return;
            }
            current = current.next;
        }
    }

    // 打印链表元素
    display() {
        let current = this.head;
        while (current) {
            console.log(current.data);
            current = current.next;
        }
    }
}

// 创建双链表实例
const myList = new DoublyLinkedList();

// 添加元素
myList.append(1);
myList.append(2);
myList.append(3);
myList.prepend(0);

// 打印链表
myList.display(); // 输出: 0 1 2 3

// 删除元素
myList.delete(2);

// 打印链表
myList.display(); // 输出: 0 1 3

输出：

?

1 2 3 4 5 6 7

0 1 2 3 0 1 3

 

循环链表示例

//  节点类，就是单向链表，把尾节点的后继指针指向了头节点
class Node {
    constructor(data) {
        this.data = data;
        this.next = null;  // 单向循环链表，有一个后继节点就ok了
    }
}

class CircularLinkedList {
    constructor() {
        this.head = null;  // 循环链表，要记录头，方便后面遍历、添加、删除等操作
    }

    // 在链表尾部添加节点
    append(data) {
        const newNode = new Node(data);
        if (!this.head) {              // 1. 如果是空链，那么当前节点就是头节点，也是尾节点，因此其后继指针指向head
            this.head = newNode;
            newNode.next = this.head; // 将新节点的下一个指向自身，形成循环
        } else {                      // 2. 如果不是空链，从头遍历遍历找到尾节点
            let current = this.head;
            while (current.next !== this.head) {  // 2.1 尾节点的特点就是其后继指针指向了头节点head
                current = current.next;
            }
            current.next = newNode;      // 3. current代表尾节点，其后继节点变成了新节点
            newNode.next = this.head;    // 4. 新节点的下一个指向头节点，形成循环
        }
    }

    // 删除指定节点
    delete(data) {
        if (!this.head) {  // 1. 空节点直接返回
            return;
        }
        let current = this.head;  // 2. 从头开始遍历，找目标节点
        let prev = null;          // 目标节点前一个节点

        // 寻找要删除的节点并找到其前驱节点
        do {
            if (current.data === data) {  // 找到目标节点
                if (prev) {  // 目标节点前一个节点，如果不为空，其后继指针指向目标节点后继指针指向的节点
                    prev.next = current.next;
                } else {
                    // 如果要删除的是头节点，需要更新头节点
                    let temp = current;
                    while (temp.next !== this.head) {  //如果当前节点不是尾节点，就遍历，让temp变成尾节点
                        temp = temp.next;
                    }
                    this.head = current.next;
                    temp.next = this.head;
                }
                return;
            }
            prev = current;
            current = current.next;
        } while (current !== this.head); // 遍历链表
    }

    // 打印链表元素
    display() {
        if (!this.head) {
            return;
        }
        let current = this.head;
        do {
            console.log(current.data);
            current = current.next;
        } while (current !== this.head);
    }
}

// 创建循环链表实例
const myList = new CircularLinkedList();

// 添加元素
myList.append(1);
myList.append(2);
myList.append(3);

// 打印链表
myList.display(); // 输出: 1 2 3 1 2 3 ...

// 删除元素
myList.delete(2);

// 打印链表
myList.display(); // 输出: 1 3 1 3 ...

输出：

?

1 2 3 4 5

1 2 3 1 3

　　

　　

 

 

Java语言中的链表

 

单链表示例

class Node {
    int data;
    Node next;

    Node(int data) {
        this.data = data;
        this.next = null;
    }
}

public class LinkedList {

    private Node head;

    LinkedList() {
        this.head = null;
    }

    // 在链表头部插入元素
    public void prepend(int data) {
        Node newNode = new Node(data);
        newNode.next = head;
        head = newNode;
    }

    // 在链表尾部追加元素
    public void append(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
            return;
        }
        Node current = head;
        while (current.next != null) {
            current = current.next;
        }
        current.next = newNode;
    }

    // 删除指定元素
    public void delete(int data) {
        if (head == null) {
            return;
        }
        if (head.data == data) {
            head = head.next;
            return;
        }
        Node current = head;
        while (current.next != null && current.next.data != data) {
            current = current.next;
        }
        if (current.next != null) {
            current.next = current.next.next;
        }
    }

    // 打印链表元素
    public void display() {
        Node current = head;
        while (current != null) {
            System.out.print(current.data + " ");
            current = current.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        LinkedList myList = new LinkedList();
        myList.append(1);
        myList.append(2);
        myList.append(3);

        myList.display(); // 输出: 1 2 3

        myList.prepend(0);

        myList.display(); // 输出: 0 1 2 3

        myList.delete(2);

        myList.display(); // 输出: 0 1 3
    }

}

输出：

?

1 2 3

1 2 3 0 1 2 3 0 1 3

　　

 

双向链表示例

//1. 节点类
class Node {
    int data;
    Node prev;
    Node next;

    Node(int data) {
        this.data = data;
        this.prev = null;
        this.next = null;
    }
}

public class DoublyLinkedList {

    Node head;
    Node tail;

    // 在链表尾部添加节点
    public void append(int data) {
        Node newNode = new Node(data);  // 创建节点
        if (head == null) {  // 是空链，新节点即为头节点也是尾节点
            head = newNode;
            tail = newNode;
        } else {
            newNode.prev = tail;  // 当前尾节点作为新节点的前驱节点
            tail.next = newNode;  // 新节点为当前尾节点的后继节点
            tail = newNode;       // 新节点为尾节点
        }
    }

    // 在链表头部添加节点
    public void prepend(int data) {
        Node newNode = new Node(data);     // 1. 创建新节点
        if (head == null) {                // 2. 如果链表为空，新节点既是头也是尾节点
            head = newNode;
            tail = newNode;
        } else {
            newNode.next = head;           // 3. 新节点的后继指针指向头节点
            head.prev = newNode;           // 4. 新节点作为当前头节点的后继节点
            head = newNode;                // 5. 把新节点赋值给头节点变量
        }
    }

    // 删除指定节点
    public void delete(int data) {
        Node current = head;           // 从头开始遍历，找到待删除节点 current
        while (current != null) {
            if (current.data == data) {
                if (current == head) {   // 1. 如果待删除节点是头节点
                    head = current.next; // 其下一个节点为头节点
                    if (head != null) {  // 如果不为空，则其前驱节点为null
                        head.prev = null;
                    }
                } else if (current == tail) {  // 1. 如果待删除节点是尾节点
                    tail = current.prev;       // 当前节点的前驱节点指向tail遍历
                    tail.next = null;          // tail的后继指针指向null
                } else {
                    current.prev.next = current.next;  // 非头非尾
                    current.next.prev = current.prev;
                }
                return;
            }
            current = current.next;
        }
    }

    // 打印链表元素
    public void display() {
        Node current = head;
        while (current != null) {
            System.out.print(current.data + " ");
            current = current.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        DoublyLinkedList myList = new DoublyLinkedList();
        myList.append(1);
        myList.append(2);
        myList.append(3);

        myList.display(); // 输出: 1 2 3

        myList.prepend(0);

        myList.display(); // 输出: 0 1 2 3

        myList.delete(2);

        myList.display(); // 输出: 0 1 3
    }

}

输出：

?

1 2 3

1 2 3 0 1 2 3 0 1 3

　　

 

循环链表示例

package org.allen.data.structure.linkedlist;

/**
 * 节点类
 */
class Node {
    int data;  // 数据域，用于存放数据
    Node next;  // 指针域，用于指向后继节点

    public Node(int data) { // 生成器快捷键Alt + insert
        this.data = data;
        this.next = null;
    }
}

/**
 * 循环链表(单链表的特例)
 */
public class CircularLinkedList {
    private Node head; // 头节点，必须要有，后面操作必须用到
//    private Node tail; // 尾节点，有在尾部经常添加删除操作的需要

    public CircularLinkedList() {
        this.head = null;
    }

    /**
     * 在链表尾巴添加元素
     *
     * @param data 节点的数据域的值
     */
    public void append(int data) {
        // 1. 根据数据域的值构建一个节点对象
        Node newNode = new Node(data);
        // 2. 判断是否空链
        if (head == null) {
            head = newNode; // 2.1 空链，就把待插入节点作为head
            head.next = head; // 2.1 循环链特殊场景：只有head，head的后继节点执行自己
        } else {
            // 2.2 不是空链（没有保留尾节点），需要从头遍历，找到尾节点，然后建立尾节点与待插入元素的关系
            Node current = head;
            while (current.next != head) { // 尾节点的特点就是后继节点是head
                current = current.next;  // 切换当前节点，直到当前节点current是尾节点

            }
            // 2.2 建立尾节点与待插入节点的关系:当前尾节点下一个节点是待插入节点
            current.next = newNode;
            // 建立循环
            newNode.next = head;
        }

    }

    /**
     * 打印链表元素
     */
    public void display() {
        // 1. 如果链表是空链，直接结束
        if (head == null) {
            return;
        } else {  // 打印
            Node current = head;
            do {
                System.out.println(current.data + "\t");
                current = current.next;
            } while (current.next != head);
            System.out.println(current.data);  // 打印尾节点的值
        }
    }

    public static void main(String[] args) {
        CircularLinkedList myList = new CircularLinkedList();
        myList.append(1);
        myList.append(2);
        myList.append(3);

        myList.display();
    }
}

输出：

?

1 2 3

1   2   3

　

Python中的链表

单链表示例

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None


class LinkedList:
    def __init__(self):
        self.head = None  # 要时刻想着维护头节点

    # 在链表头部插入元素
    def prepend(self, data):  # 1. 新节点的指针指向头节点 && 把新节点作为头节点
        new_node = Node(data)
        new_node.next = self.head  # 新节点的指针指向头节点
        self.head = new_node  # 把新节点作为头节点

    # 在链表尾部追加元素
    def append(self, data):
        new_node = Node(data)
        if not self.head:  # 1. 如果是空链，新节点作为头节点
            self.head = new_node
            return
        current = self.head  # 2. 找到尾节点，指定其指针指向新节点
        while current.next:
            current = current.next
        current.next = new_node  # 此时current为尾节点

    # 删除指定元素
    def delete(self, data):
        if not self.head:
            return
        if self.head.data == data:  # 如果删除的数据是头节点，直接把头节点的下一个节点作为头节点即可
            self.head = self.head.next
            return
        current = self.head  # 从头遍历（头节点为删除节点已考虑），从current.next排查、比较
        while current.next and current.next.data != data:  # 找到current.next即为要删除的节点，current表示要删除节点前一节点
            current = current.next
        if current.next:  # 如果删除的节点不是None
            current.next = current.next.next  # 当前节点的指针（ current.next）要指向被删除节点（ current.next）的下一个节点（current.next.next）

    # 打印链表元素
    def display(self):
        current = self.head
        while current:
            print(current.data, end=" ")
            current = current.next
        print()


# 创建单链表实例
my_list = LinkedList()

# 添加元素
my_list.append(1)
my_list.append(2)
my_list.append(3)

# 打印链表
my_list.display()  # 输出: 1 2 3

# 在头部插入元素
my_list.prepend(0)

# 打印链表
my_list.display()  # 输出: 0 1 2 3

# 删除元素
my_list.delete(2)

# 打印链表
my_list.display()  # 输出: 0 1 3

输出：

?

1 2 3

1 2 3 0 1 2 3 0 1 3

　　

双链表示例

　

'''
双链表时的最佳实践：
    1. 初始化：始终在创建双链表时初始化头节点和尾节点，并确保它们的前驱和后继引用都为空。
    2. 插入节点：插入节点时，更新前一个节点和后一个节点的引用，以确保链表的正确连接。
    3. 删除节点：删除节点时，更新前一个节点和后一个节点的引用，以跳过要删除的节点。
    4. 前向和后向遍历：利用前驱和后继引用进行前向和后向遍历链表。在遍历之前检查引用是否为空，以防止访问不存在的节点。
    5. 注意边界情况：在操作头节点和尾节点时要格外小心，因为它们的前驱和后继引用可能为空。
'''


# 1. 定义节点:要维护当前节点的前驱、后继指针
class Node:
    def __init__(self, data):
        self.data = data
        self.prev = None
        self.next = None


# 2. 链表: 要维护头尾2个节点的引用
class DoublyLinkedList:
    def __init__(self):
        self.head = None
        self.tail = None

    # 在链表尾部添加节点
    def append(self, data):
        new_node = Node(data)
        if not self.head:  # 如果为空链，新节点既是头节点也是尾节点
            self.head = new_node
            self.tail = new_node
        else:  # 如果不是空链，直接在尾节点上操作: 1. 尾节点的后继指针指向新节点，新节点的前驱指针指向尾节点。2. 更新新节点为尾节点
            new_node.prev = self.tail  # 1. 尾节点的后继指针指向新节点，新节点的前驱指针指向尾节点
            self.tail.next = new_node

            self.tail = new_node  # 2. 更新新节点为尾节点

    # 在链表头部添加节点
    def prepend(self, data):
        new_node = Node(data)
        if not self.head:  # 如果为空链，新节点既是头节点也是尾节点
            self.head = new_node
            self.tail = new_node
        else:
            new_node.next = self.head  # 新节点后继指针指向头节点
            self.head.prev = new_node  # 新节点作为头节点的前驱指针的引用值
            self.head = new_node  # 新节点作为头节点

    # 删除指定节点
    def delete(self, data):
        current = self.head
        while current:  # 从头遍历，找到待删除的节点，有3种情况：删除的是头节点、是尾节点、非头尾节点
            if current.data == data:
                if current == self.head:  # 1. 删除头节点
                    self.head = current.next  # 下一个节点作为头节点
                    if self.head:
                        self.head.prev = None  # 双向链表，维护其前驱和后继指针，头节点的前驱指针为None
                if current == self.tail:  # 2. 删除尾节点
                    self.tail = current.prev  # 维护尾节点: 尾节点前一个节点作为尾节点
                    if self.tail:  # 尾节点的特点: 其后继指针为None
                        self.tail.next = None
                if current.prev:  # 删除非头尾节点，为删除节点的前1个节点不为None（不是头节点），则其后继指针指向，删除节点的后继指向的节点
                    current.prev.next = current.next
                if current.next:  # 如果删除节点后继指针不为None（不是尾节点），则要删除的节点的前驱指针指向的节点赋值给其下一个节点的前驱指针
                    current.next.prev = current.prev
                return
            current = current.next

    # 打印链表元素
    def display(self):
        current = self.head
        while current:
            print(current.data, end=" ")
            current = current.next
        print()


# 创建双链表实例
my_list = DoublyLinkedList()

# 添加元素
my_list.append(1)
my_list.append(2)
my_list.append(3)

# 打印链表
my_list.display()  # 输出: 1 2 3

# 在头部插入元素
my_list.prepend(0)

# 打印链表
my_list.display()  # 输出: 0 1 2 3

# 删除元素
my_list.delete(2)

# 打印链表
my_list.display()  # 输出: 0 1 3

输出：

?

1 2 3

1 2 3 0 1 2 3 0 1 3

　　

循环链表

'''
循环链表时的最佳实践：
    1. 初始化：创建循环链表时，初始化一个头节点，并确保尾节点的 next 引用指向头节点，形成循环。
    2. 插入节点：插入节点时，更新前一个节点和后一个节点的引用，以确保链表的正确连接。
    3. 删除节点：删除节点时，更新前一个节点和后一个节点的引用，以跳过要删除的节点。
    4. 循环遍历：由于循环链表的特性，可以使用一个循环来遍历整个链表，循环条件可以是检查当前节点是否等于头节点。
    5. 注意边界情况：在操作头节点和尾节点时要格外小心，因为它们的 next 引用可能涉及到循环。
'''


# 1. 节点:需要维护数据域、指针域（指向下一个节点）
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None


# 2. 循环链表: 记录头节点。特点尾节点指针指向头节点
class CircularLinkedList:
    def __init__(self):
        self.head = None

    # 在链表尾部添加节点
    def append(self, data):
        new_node = Node(data)
        if not self.head:  # 空链，新节点既是头节点也是尾节点。
            self.head = new_node
            new_node.next = self.head  # 将新节点的下一个指向自身，形成循环
        else:
            current = self.head
            while current.next != self.head:  # 找到尾节点，尾节点的特点就是指针指向头节点
                current = current.next
            current.next = new_node  # 新节点作为尾节点的指针所指向的节点
            new_node.next = self.head  # 新节点的下一个指向头节点，形成循环

    # 删除指定节点
    def delete(self, data):
        if not self.head:
            return
        current = self.head
        prev = None  # 当前节点前1个节点

        # 寻找要删除的节点并找到其前驱节点
        while current.data != data:
            prev = current
            current = current.next
            if current == self.head:  # 说明已经遍历了一遍了，没有找到就结束
                return  # 节点不存在

        if prev:  # 目标节点前一个节点，不为None
            prev.next = current.next
        else:
            # 如果要删除的是头节点，需要更新头节点
            temp = current
            while temp.next != self.head:
                temp = temp.next
            self.head = current.next
            temp.next = self.head

    # 打印链表元素
    def display(self):
        if not self.head:
            return
        current = self.head
        while True:
            print(current.data, end=" ")
            current = current.next
            if current == self.head:
                break
        print()


# 创建循环链表实例
my_list = CircularLinkedList()

# 添加元素
my_list.append(1)
my_list.append(2)
my_list.append(3)

# 打印链表
my_list.display()  # 输出: 1 2 3 

# 删除元素
my_list.delete(2)

# 打印链表
my_list.display()  # 输出: 1 3 

输出：

?

1 2

1 2 3 1 3

　　

 应用

1. 多项式

class Node:
    def __init__(self, coefficient, exponent):
        self.coefficient = coefficient  # 系数
        self.exponent = exponent  # 指数
        self.next = None  # 下一个节点的引用


class Polynomial:
    def __init__(self):
        self.head = None  # 多项式链表的头节点

    def add_term(self, coefficient, exponent):
        new_term = Node(coefficient, exponent)
        if not self.head:
            self.head = new_term
        else:
            current = self.head
            prev = None
            while current and current.exponent > exponent:
                prev = current
                current = current.next
            if current and current.exponent == exponent:
                current.coefficient += coefficient
            else:
                new_term.next = current
                if prev:
                    prev.next = new_term
                else:
                    self.head = new_term

    def evaluate(self, x):
        result = 0
        current = self.head
        while current:
            result += current.coefficient * (x ** current.exponent)
            current = current.next
        return result

    def display(self):
        current = self.head
        while current:
            print(f"{current.coefficient}x^{current.exponent}", end=" ")
            current = current.next
        print()


# 创建多项式 P(x) = 3x^4 + 2x^2 + 5
p = Polynomial()
p.add_term(3, 4)
p.add_term(2, 2)
p.add_term(5, 0)

# 显示多项式
p.display()

# 计算多项式在 x=2 处的值
x_value = 2
result = p.evaluate(x_value)
print(f"P({x_value}) = {result}")

输出：

?

1 2	3x^4 2x^2 5x^0 P(2) = 61

　　

 

'''
节点类:
    1. 链表的基本组成部分
    2. 每个节点都存储了多项式的系数、指数、后继节点的引用
'''
class Node:
    def __init__(self, coefficient, exponent):
        self.coefficient = coefficient    # 多项式某个指数的系数
        self.exponent = exponent          # 多项式某个指数的指数
        self.next = None                  # 后继节点的引用，初始None，入链根据情况设值


class Polynomial:
    def __init__(self):
        self.head = Node(None, None)  # 此处设置头节点不存储数据

    def insert_term(self, coefficient, exponent):
        new_node = Node(coefficient, exponent)
        current = self.head
        while current.next and current.next.exponent > exponent:   # 1. 找到插入的位置
            current = current.next
        if current.next and current.next.exponent == exponent:     # 2. 判断指数是否相同，相同系数相加
            current.next.coefficient += coefficient
        else:                                                      # 3. 不存在的指数，加入即可
            new_node.next = current.next
            current.next = new_node

    def display(self):
        current = self.head.next
        while current:
            print(f"{current.coefficient}x^{current.exponent}", end="")
            current = current.next
            if current:
                print(" + ", end="")
        print()

    def evaluate(self, x):
        result = 0
        current = self.head.next
        while current:
            result += current.coefficient * (x ** current.exponent)
            current = current.next
        return result


# 创建多项式1: 2x^3 + 3x^2 + 4x^1 + 5x^0
poly1 = Polynomial()
poly1.insert_term(2, 3)
poly1.insert_term(3, 2)
poly1.insert_term(4, 1)
poly1.insert_term(5, 0)
poly1.display()  # 输出结果为 2x^3 + 3x^2 + 4x^1 + 5x^0

# 创建多项式2: 1x^2 + 2x^1 + 3x^0
poly2 = Polynomial()
poly2.insert_term(1, 2)
poly2.insert_term(2, 1)
poly2.insert_term(3, 0)
poly2.display()  # 输出结果为 1x^2 + 2x^1 + 3x^0

# 计算多项式相加
poly_sum = Polynomial()
current1 = poly1.head.next
current2 = poly2.head.next

# 方法1:
while current1 and current2:
    if current1.exponent > current2.exponent:
        poly_sum.insert_term(current1.coefficient, current1.exponent)
        current1 = current1.next
    elif current1.exponent < current2.exponent:
        poly_sum.insert_term(current2.coefficient, current2.exponent)
        current2 = current2.next
    else:
        poly_sum.insert_term(current1.coefficient + current2.coefficient, current1.exponent)
        current1 = current1.next
        current2 = current2.next

# 方法2:
# while current1:
#     poly_sum.insert_term(current1.coefficient, current1.exponent)
#     current1 = current1.next
# while current2:
#     poly_sum.insert_term(current2.coefficient, current2.exponent)
#     current2 = current2.next
poly_sum.display()  # 输出结果为 2x^3 + 4x^2 + 6x^1 + 8x^0

print(poly_sum.evaluate(1))  # 20 
print(poly_sum.evaluate(6))  # 620

输出：

?

1 2 3 4

1x^2 + 2x^1 + 3x^0 2x^3 + 4x^2 + 6x^1 + 8x^0 20 620

　　

常见问题

1. 在java、python、javascript语言中模拟链表中的节点，该如何声明?

无论你选择使用哪种编程语言，都可以使用这些节点类来创建链表，每个节点都包含一个值和一个指向下一个节点的引用，以构建链表数据结构中的节点。

Java

在Java中，通常使用类来表示链表节点。

public class ListNode {
    int val;
    ListNode next;
    
    public ListNode(int val) {
        this.val = val;
        this.next = null;
    }
}

这个类具有一个整数值（可以根据需要更改为其他类型）和一个指向下一个节点的引用。

Python

在Python中，你可以使用类来定义链表节点。

class ListNode:
    def __init__(self, val):
        self.val = val
        self.next = None

这个类也有一个值和一个指向下一个节点的引用。

 

Javascript

在JavaScript中，你可以使用类来表示链表节点。

class ListNode {
    constructor(val) {
        this.val = val;
        this.next = null;
    }
}

这个类具有一个值和一个指向下一个节点的引用。

2. 链表在稀疏矩阵上的应用

稀疏矩阵是指矩阵中大部分元素为零的矩阵。为了有效地存储和处理稀疏矩阵，可以使用链表表示。链表表示的基本思想是只存储非零元素的值以及它们的位置信息（行号和列号），而将零元素省略，从而节省存储空间。

链表表示稀疏矩阵的一种常见方式是使用三元组表示法（Triplet Representation），它使用一个链表来存储所有非零元素的值以及它们的行列坐标。以下是链表表示法的示例：

?

1 2 3 4 5 6 7 8 9 10

稀疏矩阵： 0 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0   链表表示： (2, 3, 7) (3, 2, 2)

　　

上述示例中，链表中的每个元素都是一个三元组，包含了非零元素的值以及它们的行列坐标。比如(2,3,7)其中2，3是其坐标，7代表其值

典型的应用场景和示例：

1. 图像处理：图像通常由大量像素组成，其中大多数像素为白色或透明，因此图像可以表示为稀疏矩阵。例如，OCR（光学字符识别）系统中的图像文本识别。

2. 自然语言处理：自然语言处理中的词汇统计或文本表示也可以使用稀疏矩阵来表示，其中每个文档可以看作是一个稀疏向量，表示词汇表中每个词的出现频率或TF-IDF权重。

3. 网络分析：在社交网络分析或Web链接分析中，可以使用稀疏邻接矩阵来表示不同实体（如用户或网页）之间的连接关系。

4. 有限元分析：工程领域中的有限元分析通常涉及大型稀疏矩阵，用于模拟结构、流体或电磁场的行为。

5. 推荐系统：推荐系统中的用户-物品评分矩阵通常是稀疏的，因为用户通常只与少数物品有交互，可以使用稀疏矩阵来表示并进行协同过滤等推荐算法。

在这些应用场景中，链表表示法可以有效地减少存储空间的占用，同时也可以提高算法的效率，因为可以只处理非零元素，而忽略零元素。这对于处理大规模稀疏数据非常重要。

图像处理

python语言

'''
在图像处理中，稀疏矩阵通常用于表示图像数据，因为图像中大部分像素都是相同的颜色或值，而只有少数像素具有不同的颜色或值。
这种情况下，使用稀疏矩阵可以节省内存空间和提高处理效率。Python中的典型示例是使用链表来表示稀疏矩阵。
'''


class Node:   # 节点，存储非0元素以及其坐标
    def __init__(self, row, col, value):
        self.row = row
        self.col = col
        self.value = value
        self.next = None


class SparseMatrix:
    def __init__(self, rows, cols):
        self.rows = rows
        self.cols = cols
        self.head = None

    def add_element(self, row, col, value):
        if row < 0 or row >= self.rows or col < 0 or col >= self.cols:
            raise ValueError("Invalid row or column index")

        if value != 0:
            new_node = Node(row, col, value)
            if self.head is None:
                self.head = new_node
            else:
                current = self.head
                while current.next:
                    current = current.next
                current.next = new_node

    def get_element(self, row, col):
        current = self.head
        while current:
            if current.row == row and current.col == col:
                return current.value
            current = current.next
        return 0

    def to_list(self):
        result = []
        for i in range(self.rows):
            row = []
            for j in range(self.cols):
                row.append(self.get_element(i, j))
            result.append(row)
        return result


# 创建一个3x3的稀疏矩阵
matrix = SparseMatrix(3, 3)
matrix.add_element(0, 0, 1)
matrix.add_element(1, 1, 2)
matrix.add_element(2, 2, 3)

# 打印稀疏矩阵的列表表示
print(matrix.to_list())

# 获取特定位置的元素值
print(matrix.get_element(1, 1))

输出：

?

1 2	[[1, 0, 0], [0, 2, 0], [0, 0, 3]] 2

　　

Java 语言

package org.allen.data.structure.linkedlist;

/**
 * 链表类：用链表表示稀疏矩阵
 */
class SparseMatrixNode {  //  一个节点，可以看出2个节点，行列节点，每次都要维护其下一个行、下一个列节点
    int row, col, value;
    SparseMatrixNode nextRow, nextCol;

    public SparseMatrixNode(int row, int col, int value) {
        this.row = row;
        this.col = col;
        this.value = value;
        this.nextRow = null;
        this.nextCol = null;
    }
}

class SparseMatrix {
    int numRows;
    int numCols;
    SparseMatrixNode[] rowHeads;
    SparseMatrixNode[] colHeads;

    public SparseMatrix(int numRows, int numCols) {
        this.numRows = numRows;  // 行数对应矩阵n
        this.numCols = numCols;  // 列数对应矩阵m
        rowHeads = new SparseMatrixNode[numRows];
        colHeads = new SparseMatrixNode[numCols];
        for (int i = 0; i < numRows; i++) {
            rowHeads[i] = new SparseMatrixNode(i, -1, 0);
        }
        for (int j = 0; j < numCols; j++) {
            colHeads[j] = new SparseMatrixNode(-1, j, 0);
        }
    }

    public void insert(int row, int col, int value) {
        if (row < 0 || row >= numRows || col < 0 || col >= numCols) {
            throw new IllegalArgumentException("Invalid row or column index");
        }
        SparseMatrixNode newNode = new SparseMatrixNode(row, col, value);
        SparseMatrixNode currentRowNode = rowHeads[row];
        SparseMatrixNode currentColNode = colHeads[col];

        // Insert into the row list: 维护列链表
        while (currentRowNode.nextRow != null && currentRowNode.nextRow.col < col) {
            currentRowNode = currentRowNode.nextRow;
        }
        newNode.nextRow = currentRowNode.nextRow;
        currentRowNode.nextRow = newNode;

        // Insert into the column list 维护行列表
        while (currentColNode.nextCol != null && currentColNode.nextCol.row < row) {
            currentColNode = currentColNode.nextCol;
        }
        newNode.nextCol = currentColNode.nextCol;
        currentColNode.nextCol = newNode;
    }

    public void print() {
        for (int i = 0; i < numRows; i++) {
            SparseMatrixNode current = rowHeads[i].nextRow;
            for (int j = 0; j < numCols; j++) {
                if (current != null && current.col == j) {
                    System.out.print(current.value + " ");
                    current = current.nextRow;
                } else {
                    System.out.print("0 ");
                }
            }
            System.out.println();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        SparseMatrix matrix = new SparseMatrix(4, 5);
        matrix.insert(0, 0, 1);
        matrix.insert(1, 1, 2);
        matrix.insert(2, 2, 3);
        matrix.print();
    }
}

输出：

?

1 2 3 4

1 0 0 0 0 0 2 0 0 0 0 0 3 0 0 0 0 0 0 0

　　

javascript语言：

class Node {
    constructor(row, col, value) {
        this.row = row;
        this.col = col;
        this.value = value;
        this.next = null;
    }
}

class SparseMatrix {
    constructor(rows, cols) {
        this.rows = rows;
        this.cols = cols;
        this.head = new Node(-1, -1, null); // 头节点，为空节点
    }

    insert(row, col, value) {
        // 创建一个新节点
        const newNode = new Node(row, col, value);

        // 在链表中插入节点
        let current = this.head;
        while (current.next) {
            current = current.next;
        }
        current.next = newNode;
    }

    getValue(row, col) {
        let current = this.head.next;
        while (current) {
            if (current.row === row && current.col === col) {
                return current.value;
            }
            current = current.next;
        }
        return 0; // 默认值为零
    }
}

// 创建一个 5x5 的稀疏矩阵
const matrix = new SparseMatrix(5, 5);

// 插入一些非零元素
matrix.insert(1, 1, 5);
matrix.insert(2, 2, 8);
matrix.insert(3, 3, 6);

// 执行图像处理操作：将每个像素值减去 2
// for (let i = 0; i < 5; i++) {
//     for (let j = 0; j < 5; j++) {
//         const value = matrix.getValue(i, j);
//         matrix.insert(i, j, value - 2);
//     }
// }

// 打印处理后的稀疏矩阵
for (let i = 0; i < 5; i++) {
    let row = '';
    for (let j = 0; j < 5; j++) {
        row += matrix.getValue(i, j) + ' ';
    }
    console.log(row);
}

输出：

?

1 2 3 4 5

0 0 0 0 0 0 5 0 0 0 0 0 8 0 0 0 0 0 6 0 0 0 0 0 0