C/C++中的链表数据结构实战

晕过前方

于 2024-09-25 15:54:35 发布

阅读量899

点赞数 8

本文链接：https://blog.csdn.net/weixin_35762258/article/details/142536969

版权

本文还有配套的精品资源，点击获取

简介：链表是计算机科学中的基础数据结构，尤其在C/C++编程中。它通过节点和指针链接数据，与数组不同，不依赖于连续内存地址。本教程涵盖链表的基本概念、创建过程、基本操作（插入、删除、遍历、查找），以及双向链表和循环链表的介绍。掌握链表的实现是深入学习数据结构和算法的基础。 LinkedList.rar_数据结构_C/C++_

1. 链表基本概念

链表是一种常见的基础数据结构，它由一系列节点组成，每个节点包含两部分信息：一部分用于存储数据，另一部分指向下一个节点的内存地址。在理解链表之前，我们首先需要明确几个核心概念：数据域、指针域、头指针、尾指针和节点。

数据域 ：存储具体信息的区域，可以是任意数据类型。
指针域 ：存储下一个节点地址的区域，其数据类型通常为指向节点数据类型的指针。
头指针 ：指向链表第一个节点的指针，对于空链表，头指针可以是NULL。
尾指针 ：指向链表最后一个节点的指针，对于空链表，尾指针也是NULL。
节点：链表的基本单位，包含数据域和指针域。

链表之所以被广泛使用，是因为它在插入和删除操作时具有较高的效率。与数组不同，链表不需要在内存中连续分配空间，允许数据的分散存储。这使得链表在动态数据管理方面具有优势，尤其当数据量未知或频繁变动时，链表可以更加灵活地处理数据。

链表根据节点之间的连接方式可以分为单链表、双链表和循环链表。单链表每个节点只有一个指向后继节点的指针；双链表节点包含两个指针，一个指向前驱节点，一个指向后继节点；循环链表的尾节点的指针不指向NULL，而是指向链表的第一个节点，形成一个环状结构。

理解了链表的基本概念之后，我们就能够深入探讨其操作和应用了。下一章将介绍链表节点的定义与创建，为后续操作打下坚实的基础。

2. 链表节点定义与创建

2.1 链表节点的结构设计

2.1.1 节点的数据成员

链表作为一种基本的数据结构，它的核心在于节点(node)的设计。链表节点通常包含两个主要的数据成员：一个是存储数据元素的值，另一个是指向下一个节点的指针（或引用），有时还会有指向前一个节点的指针以支持双向链表的实现。

以C++语言为例，一个简单的单链表节点定义可以这样书写：

template <typename T>
struct ListNode {
    T value;         // 数据成员，存储节点值
    ListNode* next;  // 指针成员，指向下一个节点
};

在Java中，节点的定义可以使用类来实现：

public class ListNode<T> {
    T value;         // 数据成员，存储节点值
    ListNode<T> next; // 指针成员，指向下一个节点
}

2.1.2 节点的构造和析构

为了有效管理链表节点的生命周期，实现构造函数和析构函数是十分必要的。这有助于自动管理内存，避免内存泄漏。

在C++中，节点的构造可以这样实现：

template <typename T>
ListNode<T>::ListNode(T val) : value(val), next(nullptr) {}

而析构函数则可以这样定义：

template <typename T>
ListNode<T>::~ListNode() {
    // 如果存在子节点，则需要递归释放所有子节点的内存
    // 在本简化示例中，我们假设不再有子节点
}

在Java中，由于有垃圾回收机制，通常不需要手动编写析构函数。但是当节点中包含非基本类型且这些类型需要特殊处理时，就需要实现 finalize() 方法。

2.2 链表的初始化与建立

2.2.1 单链表的初始化过程

初始化一个单链表，我们通常需要定义一个头节点（head），它通常不存储有效数据，仅作为链表的起始点和访问的入口。

template <typename T>
class LinkedList {
private:
    ListNode<T>* head; // 头节点，不存储有效数据
public:
    LinkedList() : head(new ListNode<T>()) {
        // 初始化时，头节点的next指针设为nullptr
        head->next = nullptr;
    }
    // 析构函数释放链表内存
    ~LinkedList() {
        ListNode<T>* current = head;
        while (current != nullptr) {
            ListNode<T>* next = current->next;
            delete current;
            current = next;
        }
    }
};

2.2.2 链表头节点的作用和创建

头节点在链表中起到非常重要的作用，它提供了一个不变的起始位置，使得链表的增加、删除等操作变得更加安全和方便。例如，在头节点之后添加新的节点，或者从头节点出发去遍历整个链表，都不会遇到空指针异常。

创建头节点需要为它分配内存，并初始化其 next 指针为 nullptr （或null），确保链表的完整性和可访问性。

template <typename T>
ListNode<T>* createHeadNode() {
    return new ListNode<T>(T()); // 假设T是int类型，则默认值为0
}

头节点的设计让链表的初始化变得简单，同时也为后续的链表操作提供了一个安全的锚点。

3. 链表基本操作详解

链表作为一种基础的数据结构，在各种编程场景中扮演着重要的角色。它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。与数组不同，链表不需要连续的内存空间，这使得链表在插入和删除操作中更加灵活。本章节将详细介绍链表的插入、删除、遍历和查找操作，并解释它们的实现逻辑。

3.1 链表的插入操作

3.1.1 头插法和尾插法的区别与实现

链表的插入操作分为头插法和尾插法。头插法是指每次将新节点插入到链表的头部，而尾插法则是将新节点插入到链表的尾部。

头插法实现

头插法可以保证插入操作的时间复杂度为 O(1)，因为它不依赖于链表的长度。

struct Node {
    int data;
    struct Node* next;
};

void insertAtHead(struct Node** head, int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->next = *head;
    *head = newNode;
}

逻辑分析：该函数创建了一个新的节点，并将其数据成员设置为传入的 data 值。 newNode 的 next 指针指向当前的头节点，然后新的节点成为新的头节点。

尾插法实现

与头插法不同，尾插法需要遍历到链表的末尾，因此其时间复杂度为 O(n)。

void insertAtTail(struct Node** head, int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->next = NULL;
    if (*head == NULL) {
        *head = newNode;
        return;
    }
    struct Node* temp = *head;
    while (temp->next != NULL) {
        temp = temp->next;
    }
    temp->next = newNode;
}

逻辑分析：首先检查链表是否为空，如果是，则新节点直接成为头节点。如果链表不为空，通过遍历找到尾节点，然后将新节点添加到链表的末尾。

3.1.2 指定位置插入节点的算法

在指定位置插入节点涉及到找到该位置的前一个节点，然后进行指针操作。

void insertAtPosition(struct Node** head, int data, int position) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->next = NULL;
    if (position == 0) {
        newNode->next = *head;
        *head = newNode;
        return;
    }
    struct Node* temp = *head;
    for (int i = 0; temp != NULL && i < position - 1; i++) {
        temp = temp->next;
    }
    if (temp == NULL) {
        printf("Position is out of bounds\n");
        return;
    }
    newNode->next = temp->next;
    temp->next = newNode;
}

逻辑分析：此函数首先检查是否在头部插入，如果不在头部，则遍历到指定位置的前一个节点。如果找到前一个节点，则将新节点插入到它的后面。

3.2 链表的删除操作

3.2.1 查找节点及其删除算法

删除链表中的节点需要先定位到该节点，然后更新指针信息。

void deleteNode(struct Node** head, int key) {
    struct Node* temp = *head, *prev = NULL;
    if (temp != NULL && temp->data == key) {
        *head = temp->next;
        free(temp);
        return;
    }
    while (temp != NULL && temp->data != key) {
        prev = temp;
        temp = temp->next;
    }
    if (temp == NULL) return;
    prev->next = temp->next;
    free(temp);
}

逻辑分析：此函数从头节点开始，检查节点的数据成员是否与要删除的 key 相匹配。如果找到，就更新头节点指针，并释放当前节点的内存。如果未找到，则遍历链表直到找到匹配项，然后通过前一个节点指针更新链表的连接关系，并释放当前节点的内存。

3.2.2 删除指定值节点的策略

删除指定值的节点可以通过创建一个虚拟头节点简化操作，这样可以统一插入和删除节点的逻辑。

struct Node* createNode(int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

struct Node* deleteNodeByValue(struct Node* head, int key) {
    struct Node *temp = head, *prev = NULL;
    if (temp != NULL && temp->data == key) {
        head = temp->next;
        free(temp);
        return head;
    }
    while (temp != NULL && temp->data != key) {
        prev = temp;
        temp = temp->next;
    }
    if (temp == NULL) return head;
    prev->next = temp->next;
    free(temp);
    return head;
}

逻辑分析：此函数在删除节点之前检查头节点是否为目标节点。如果是，则直接更新头节点并释放内存。如果目标节点在链表中间或末尾，函数会遍历链表，找到该节点，并通过前一个节点来更新链表的连接关系。

3.3 链表的遍历和查找

3.3.1 单链表遍历的方法

遍历单链表是链表操作中最基本的技巧之一，通常用于读取节点数据或者进行某些操作。

void traverseList(struct Node* head) {
    struct Node* current = head;
    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("\n");
}

逻辑分析：此函数通过一个循环遍历链表中的所有节点。每次迭代中，它都会打印当前节点的数据，并将 current 指针移动到下一个节点。当到达链表的末尾时， current 将为 NULL ，遍历结束。

3.3.2 查找特定节点的技术

查找特定节点是链表中的常见操作，尤其是在链表未排序时。查找操作的时间复杂度为 O(n)。

struct Node* findNode(struct Node* head, int key) {
    struct Node* current = head;
    while (current != NULL) {
        if (current->data == key) {
            return current;
        }
        current = current->next;
    }
    return NULL;
}

逻辑分析：此函数遍历链表，每次迭代检查当前节点的数据是否与要查找的 key 相匹配。如果匹配，函数返回当前节点的指针。如果没有找到匹配项，则返回 NULL 。

在本章节中，我们详细探讨了链表的基本操作，包括插入、删除、遍历和查找。每种操作都提供了对应的实现代码和逻辑分析，确保读者能够深入理解链表操作的原理及其应用。下一章节将聚焦于双向链表和循环链表的扩展应用和实现技巧。

4. 双向链表和循环链表扩展

4.1 双向链表的结构与特性

双向链表（Doubly Linked List）是一种更加复杂的数据结构，它允许在任意方向上遍历节点。与单向链表不同的是，双向链表的每个节点都包含两个指针，一个指向前一个节点，另一个指向后一个节点。这种结构带来了不少优势，同时也增加了一些复杂性。

4.1.1 双向链表节点的设计

在双向链表中，节点通常具有以下结构：

struct DoublyLinkedListNode {
    int data; // 节点存储的数据
    struct DoublyLinkedListNode *prev; // 指向前一个节点的指针
    struct DoublyLinkedListNode *next; // 指向后一个节点的指针
};

这种设计使得双向链表可以从两个方向进行遍历。在进行节点操作时，我们不仅可以访问下一个节点，还可以回溯到上一个节点，这在一些特定的应用场景中非常有用。

4.1.2 双向链表的优缺点分析

双向链表相比于单向链表，具有以下优点：

双向遍历： 可以方便地向前或向后遍历链表。
灵活性： 在删除节点或插入节点时，双向链表不需要像单向链表那样需要访问特定的节点。
数据操作： 在某些情况下，双向链表可以减少搜索次数，提高数据操作的效率。

然而，双向链表也存在一些缺点：

空间开销： 每个节点需要存储两个指针，相比单向链表而言增加了空间的开销。
复杂性： 管理双向指针增加了算法的复杂性，特别是在进行节点的插入和删除时，需要考虑的边界条件更多。

4.2 循环链表的概念与应用

循环链表是一种特殊的链表结构，它的最后一个节点的 next 指针指向头节点，形成一个闭环。这种结构使得循环链表可以在环内无限循环访问，没有明显的起点和终点。

4.2.1 循环链表的数据结构

循环链表的节点与单向链表或双向链表类似，区别在于最后一个节点的 next 指针。在循环链表中， next 指针永远不会是 NULL ，而是指向头节点。

struct CircularLinkedListNode {
    int data;
    struct CircularLinkedListNode *next;
};

4.2.2 循环链表的操作特点

循环链表的操作有其独特性：

遍历： 在循环链表中进行遍历时，需要一个终止条件，否则将会无限循环。
插入和删除： 插入和删除操作需要特别注意，避免形成孤立的节点或破坏循环结构。

循环链表适用于某些特定场景，如约瑟夫环问题（Josephus problem）或者实现一个高效的循环缓冲区。

4.3 特殊链表的实现技巧

在链表的家族中，除了常见的单向链表、双向链表和循环链表外，还有一些特殊的链表实现，它们通过特定的实现技巧，解决了某些特定问题。

4.3.1 静态链表与动态链表

静态链表： 使用数组来模拟链表的动态分配特性，它的空间是预先分配好的，不需要动态分配和释放内存，适合于数据量固定的情况。
动态链表： 在运行时动态地申请和释放节点，可以灵活地处理数据量的变化，是大多数链表实现的选择。

4.3.2 有序链表的操作细节

有序链表是一种在逻辑上有序排列的链表结构，它的每个节点都遵循一定的顺序。在有序链表中插入或删除节点时，需要保证链表依然保持有序状态。

// 有序链表的插入函数示例
void insertInOrder(struct DoublyLinkedListNode **head, int data) {
    struct DoublyLinkedListNode *newNode = createNode(data);
    if (*head == NULL || (*head)->data >= data) {
        newNode->next = *head;
        if (*head != NULL) (*head)->prev = newNode;
        *head = newNode;
    } else {
        struct DoublyLinkedListNode *current = *head;
        while (current->next != NULL && current->next->data < data) {
            current = current->next;
        }
        newNode->next = current->next;
        if (current->next != NULL) current->next->prev = newNode;
        current->next = newNode;
    }
}

有序链表保持排序的特性使得它在某些需要频繁插入或删除操作且需要有序访问的场景中非常有用，例如，优先级队列的实现。

在这一章中，我们深入了解了双向链表和循环链表的结构、特性和应用，以及一些特殊链表的实现技巧。这些内容为理解和运用链表提供了更宽广的视角，为后续章节中链表在高级数据结构中的运用打下了坚实的基础。

5. 链表在高级数据结构中的运用

链表作为一种基础且强大的数据结构，在计算机科学领域中的高级数据结构设计中扮演着关键角色。通过链表的灵活连接特性，它与其他数据结构如栈、队列、哈希表和红黑树等，都能产生有意义的交互和应用。本章节将深入探讨链表在这些高级数据结构中的具体运用，并提供应用案例分析，展示链表在解决实际问题中的价值。

5.1 链表与栈和队列的关系

栈和队列是两种特殊的线性表，它们都有严格的访问规则：栈为后进先出（LIFO），队列为先进先出（FIFO）。在许多情况下，链表可以用来实现这两种数据结构，提供动态的内存分配和灵活的操作方式。

5.1.1 链表实现栈结构

栈的实现通常需要保持后进先出的顺序。通过链表的尾部进行插入和删除操作，可以完美地满足栈的需求。在链表实现的栈中，栈顶始终位于链表的尾部，这样新元素可以直接被添加到链表尾部，删除操作也只需要移除链表尾部的元素即可。

栈的链表实现代码示例

typedef struct StackNode {
    int data;
    struct StackNode *next;
} StackNode, *LinkStackPtr;

typedef struct LinkStack {
    LinkStackPtr top;
    int count;
} LinkStack;

void initStack(LinkStack *s) {
    s->top = NULL;
    s->count = 0;
}

void push(LinkStack *s, int e) {
    LinkStackPtr node = (LinkStackPtr)malloc(sizeof(StackNode));
    node->data = e;
    node->next = s->top;
    s->top = node;
    s->count++;
}

int pop(LinkStack *s) {
    if (s->top == NULL) {
        return -1;
    }
    LinkStackPtr temp = s->top;
    int e = temp->data;
    s->top = s->top->next;
    free(temp);
    s->count--;
    return e;
}

参数说明

initStack 函数初始化一个空栈， top 指向栈顶， count 记录栈中元素的数量。
push 函数将元素 e 入栈，创建一个新节点并将其插入到栈顶。
pop 函数将栈顶元素出栈并返回其值，如果栈为空则返回 -1 。

5.1.2 链表实现队列结构

队列实现需要维护一个先进先出的顺序。在链表中，我们可以在队列头部进行删除操作，而在尾部进行插入操作。队列的头部就是链表的头部，这样新元素总是添加到链表尾部，而删除操作则发生在链表头部。

队列的链表实现代码示例

typedef struct QueueNode {
    int data;
    struct QueueNode *next;
} QueueNode, *LinkQueuePtr;

typedef struct LinkQueue {
    LinkQueuePtr front;
    LinkQueuePtr rear;
    int count;
} LinkQueue;

void initQueue(LinkQueue *q) {
    q->front = q->rear = (LinkQueuePtr)malloc(sizeof(QueueNode));
    if (!q->front) exit(OVERFLOW);
    q->front->next = NULL;
    q->count = 0;
}

void enqueue(LinkQueue *q, int e) {
    LinkQueuePtr node = (LinkQueuePtr)malloc(sizeof(QueueNode));
    node->data = e;
    node->next = NULL;
    q->rear->next = node;
    q->rear = node;
    q->count++;
}

int dequeue(LinkQueue *q) {
    if (q->front == q->rear) {
        return -1;
    }
    LinkQueuePtr temp = q->front->next;
    int e = temp->data;
    q->front->next = temp->next;
    if (q->rear == temp) {
        q->rear = q->front;
    }
    free(temp);
    q->count--;
    return e;
}

参数说明

initQueue 函数初始化一个空队列， front 和 rear 分别指向队列的头尾， count 记录队列中元素的数量。
enqueue 函数将元素 e 入队，创建一个新节点并将其添加到队尾。
dequeue 函数将队头元素出队并返回其值，如果队列为空则返回 -1 。

5.2 链表与其它数据结构的结合

链表不仅能够实现栈和队列这些线性表结构，还能在许多其他复杂的数据结构中发挥作用。以下将介绍链表在哈希表和红黑树中的应用。

5.2.1 哈希表中链表的应用

哈希表是一种通过哈希函数来实现快速查找的数据结构，其核心思想是通过哈希函数将关键字映射到表中的位置。但哈希表中的冲突解决策略往往需要借助链表来实现。当多个元素映射到同一位置时（哈希冲突），链表将这些元素组织起来，形成一个链表结构，存储在哈希表的相同位置上。

哈希表中链表的组织示意图

graph TD
    A[哈希表槽位1] -->|冲突| B[链表节点]
    B --> C[链表节点]
    C --> D[链表节点]
    A -->|单独存储| E[链表节点]

    F[哈希表槽位2] -->|无冲突| G[链表节点]
    F -->|单独存储| H[链表节点]

5.2.2 红黑树中链表的利用

红黑树是一种自平衡的二叉搜索树，它在插入和删除操作时需要进行复杂的调整来保持平衡。在某些特定场景下，如Java中的 TreeMap 或 TreeSet ，红黑树的节点除了存储元素值和颜色属性外，还可能包含指向其他节点的链表指针。这些链表可以用于优化遍历操作，例如，当树的某些部分高度不平衡时，通过链表遍历可以更快速地访问到特定的元素。

5.3 链表在实际问题中的应用案例

链表在实际编程中具有广泛的应用，无论是在操作系统内存分配，还是在算法设计中，链表都能提供独特的解决方案。

5.3.1 链表解决内存分配问题

在内存管理中，操作系统需要一种可以动态分配和回收内存的数据结构。链表由于其动态的内存使用特性，被广泛用作内存分配的管理结构。例如，在分配内存块时，可以根据内存请求动态地创建链表节点来表示一个内存块，并在回收时，将这些内存块通过链表组织起来，便于后续的快速分配。

5.3.2 链表在算法设计中的应用

链表在算法设计中也具有独特的地位，特别是在需要频繁插入和删除元素的场景中。例如，在实现LRU（最近最少使用）缓存淘汰策略时，可以使用链表来记录元素的使用顺序，配合哈希表来快速定位元素，从而高效地淘汰最长时间未被访问的元素。

通过以上分析，我们可以看到链表在高级数据结构中的重要地位和丰富应用。在理解链表与其他数据结构的结合原理后，对于解决实际问题将会有更深层次的见解和更多的创新思路。接下来的章节将探讨链表的性能分析与优化，以及链表编程实践与案例分析，旨在帮助读者进一步掌握链表的高级应用。

6. 链表的性能分析与优化

6.1 链表操作的时间复杂度分析

6.1.1 基本操作的时间复杂度

链表作为一种基础的数据结构，其各种操作的时间复杂度对于理解其性能至关重要。基本操作通常包括插入、删除和查找。

插入操作 ：在链表的头部插入节点具有 O(1) 的时间复杂度，因为不需要遍历链表就可以完成操作。在链表中间或尾部插入节点，需要先遍历找到插入位置，因此时间复杂度是 O(n) ，这里的 n 代表链表的长度。
删除操作 ：删除链表中的节点与插入类似，如果知道要删除节点的前一个节点，删除操作可以在 O(1) 时间完成。否则，需要遍历链表找到该节点，时间复杂度为 O(n) 。
查找操作 ：在链表中查找一个元素的时间复杂度通常是 O(n) ，因为链表不支持随机访问，需要从头节点开始顺序遍历直到找到目标元素。

6.1.2 特殊情况下的性能考量

虽然基本操作的时间复杂度给出了常规情况的性能估计，但在一些特殊情况下，链表的性能表现可能会有所不同。

未排序链表中的查找 ：如果链表是未排序的，那么查找特定值的节点始终是一个 O(n) 的操作。
有序链表中的查找 ：对于有序链表，可以应用二分查找算法来提高查找效率。尽管链表不支持随机访问，但可以通过迭代的方式实现二分查找，从而将查找的时间复杂度降低到 O(log n) 。
尾部插入操作 ：对于单链表而言，尾部插入操作在没有指向尾节点的情况下也是 O(n) 的，因为需要遍历整个链表找到尾部。但可以在尾部维护一个指针，这样尾部插入就变为 O(1) 。

6.2 链表内存管理和空间优化

6.2.1 动态内存分配的效率问题

链表节点的动态内存分配对于性能有着直接的影响。

分配和释放 ：每次插入或删除节点时，都可能涉及到内存的分配和释放。这在C/C++中通常涉及到调用 malloc 和 free 函数，是一个相对开销较大的操作。
内存碎片 ：频繁地分配和释放内存可能导致内存碎片问题，影响程序的内存使用效率。

6.2.2 链表内存回收策略

为了优化链表的内存使用，可以采取以下策略：

预先分配 ：在创建链表时，预先分配一个足够大的内存块来存储预期数量的节点，可以避免多次内存分配带来的性能损失。
内存池 ：使用内存池来管理链表节点的内存分配。通过预先分配一大块内存，并将其切割成固定大小的节点，可以快速分配和回收链表节点，同时减少内存碎片。
引用计数 ：在某些应用中，可以使用引用计数来管理节点的生命周期，当一个节点不再被任何地方引用时，自动回收其内存。

通过以上章节的深入分析，我们可以发现链表虽然在时间复杂度上具有一定的优势，但在内存管理方面却有优化的空间。开发者需要根据实际的应用场景来平衡时间复杂度和内存使用，以达到最优的性能表现。

7. 链表编程实践与案例分析

7.1 C/C++实现链表的编程技巧

7.1.1 指针的正确使用和注意事项

在C/C++中，指针是实现链表不可或缺的数据类型。正确使用指针对于编写高效、安全的链表代码至关重要。下面是几个关于指针使用的要点：

指针初始化 ：在使用指针之前，一定要确保其已被初始化。未初始化的指针指向一个未知的内存位置，这可能导致程序崩溃或不可预测的行为。 cpp node* p = nullptr; // 推荐的初始化方式
内存分配 ：动态分配内存时，使用 new 关键字。在释放内存时使用 delete ，并确保只删除一次已分配的内存。

cpp node* p = new node; // 使用p delete p; // 仅释放一次内存 p = nullptr; // 防止悬挂指针

悬挂指针 ：当释放一个指针所指向的内存后，该指针将变成悬挂指针。悬挂指针的使用是危险的，应该将其设置为 nullptr 。
指针指针（二级指针） ：当需要修改指针本身的值时（例如在函数中修改外部指针的值），需要使用指针的指针（二级指针）。

cpp void changePointer(node** p) { *p = new node; // 修改外部指针p的指向 }

指针与数组 ：虽然指针和数组在很多情况下可以互换使用，但它们在内存处理上有本质的区别。指针更灵活，而数组是静态的，大小在声明时确定。

7.1.2 指针和数组的对比应用

指针和数组在实际编程中各有用途，理解它们之间的关系和区别有助于写出更优化的代码。下面分析几个主要的对比点：

连续内存 ：数组在内存中占用一块连续的存储空间，而指针可以指向任何位置。
下标运算符 ：对数组使用下标运算符 [] 实际上是访问指针所指向内存的一种简便方式。
数组名作为指针 ：数组名在大多数情况下会被解释为指向数组首元素的指针。
指针算术 ：指针支持算术运算，可以进行加减操作以访问连续的内存位置。
大小和容量 ：数组的大小是固定的，而通过指针可以动态地调整数据结构的容量。
动态内存分配 ：指针常用于动态内存分配，允许在运行时确定数据结构的大小。

7.2 链表编程综合实例分析

7.2.1 实现一个简单的链表

我们将通过一个简单的例子演示如何用C++实现一个单向链表：

class ListNode {
public:
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(nullptr) {}
};

class LinkedList {
public:
    ListNode *head;
    LinkedList() : head(nullptr) {}
    void append(int value) {
        if (head == nullptr) {
            head = new ListNode(value);
        } else {
            ListNode *current = head;
            while (current->next != nullptr) {
                current = current->next;
            }
            current->next = new ListNode(value);
        }
    }
};

7.2.2 链表在复杂问题中的应用实例

链表不仅可以用在简单的数据存储中，还可以解决更复杂的编程问题，例如在图的实现中作为邻接表的一部分。

#include <list>
#include <unordered_map>
#include <string>

class Graph {
private:
    std::unordered_map<std::string, std::list<std::string>> adjList;

public:
    void addEdge(const std::string &from, const std::string &to) {
        adjList[from].push_back(to);
        // For undirected graph, add the edge the other way as well.
        // adjList[to].push_back(from);
    }

    void printGraph() {
        for (auto const &pair : adjList) {
            std::cout << pair.first << " -> ";
            for (auto &elem : pair.second) {
                std::cout << elem << ", ";
            }
            std::cout << std::endl;
        }
    }
};

在上述代码中，图是由链表实现的邻接表，使用 std::unordered_map 和 std::list 组合来创建。每个节点都与一个链表相关联，该链表存储所有连接到该节点的其他节点。这种方法允许我们快速访问任何节点的所有邻居。

通过这个章节的介绍，我们已经了解了链表编程的一些核心技巧，并且通过实际的例子展示了如何将链表应用到更加复杂的问题中。链表的编程实践不仅在于对数据结构本身的实现，更在于如何巧妙地运用链表解决各种编程挑战。

本文还有配套的精品资源，点击获取

简介：链表是计算机科学中的基础数据结构，尤其在C/C++编程中。它通过节点和指针链接数据，与数组不同，不依赖于连续内存地址。本教程涵盖链表的基本概念、创建过程、基本操作（插入、删除、遍历、查找），以及双向链表和循环链表的介绍。掌握链表的实现是深入学习数据结构和算法的基础。

本文还有配套的精品资源，点击获取