链表详解（附有C语言详细代码）

07-17 774阅读

一、链表的概念

链表（Linked List）是一种常见的数据结构，它通过一系列节点（Node）来存储数据元素。与数组不同，链表中的元素在内存中不是连续存储的，而是通过指针或引用链接在一起。链表的基本结构包括节点和指针，节点通常包含两部分：数据域和指针域（或称为链接域）。数据域用于存储数据元素，而指针域则用于指向链表中的下一个节点。

（图片来源网络，侵删）

链表具有多种类型，包括单向链表、双向链表、循环链表等。其中，单向链表是最简单的链表形式，每个节点只有一个指针，指向下一个节点；双向链表则包含两个指针，一个指向前一个节点，一个指向后一个节点；循环链表则是将链表的最后一个节点指向第一个节点，形成一个环形结构。

二、链表的特点

链表作为一种动态数据结构，具有以下特点：

动态分配：链表中的节点可以在运行时动态分配和释放，因此链表的大小可以根据需要动态调整。
插入和删除操作方便：在链表中插入或删除一个节点时，只需要修改相关节点的指针即可，不需要移动其他节点，因此操作效率较高。
空间利用率高：链表不需要像数组那样预先分配连续的内存空间，因此可以充分利用零散的内存空间。
没有越界问题：由于链表是通过指针链接的，因此不存在数组中的越界问题。

然而，链表也存在一些缺点，如访问元素时需要通过指针逐个遍历，因此访问效率较低；同时，链表中的节点需要额外的空间来存储指针信息，因此空间开销相对较大。

三、单向链表的实现

下面我们以单向链表为例，详细讲解链表的实现方法。

1. 节点定义

在C语言中，可以使用结构体来定义链表节点。每个节点包含一个数据域（data）和一个指针域（next），其中指针域指向下一个节点。

typedef struct Node {
    int data;         // 数据域
    struct Node* next; // 指针域
} Node;

2. 链表初始化

链表初始化时，需要创建一个头节点（head），并将其指针域置为空（NULL），表示链表为空。

Node* initList() {
    Node* head = (Node*)malloc(sizeof(Node)); // 创建头节点
    if (!head) {
        exit(1); // 内存分配失败，退出程序
    }
    head->next = NULL; // 初始化头节点的指针域为空
    return head;
}

3. 插入节点

在链表中插入节点时，需要指定插入位置和前一个节点。根据插入位置的不同，可以分为头插法（在链表头部插入节点）和尾插法（在链表尾部插入节点）。以下以尾插法为例，展示插入节点的实现方法。

void insertNode(Node* head, int data) {
    Node* newNode = (Node*)malloc(sizeof(Node)); // 创建新节点
    if (!newNode) {
        exit(1); // 内存分配失败，退出程序
    }
    newNode->data = data; // 设置新节点的数据域
    newNode->next = NULL; // 初始化新节点的指针域为空
    // 找到链表的最后一个节点
    Node* cur = head;
    while (cur->next != NULL) {
        cur = cur->next;
    }
    // 将新节点插入到链表尾部
    cur->next = newNode;
}

4. 删除节点

在链表中删除节点时，需要指定要删除的节点或其前驱节点。以下以删除指定值的节点为例，展示删除节点的实现方法。

void deleteNode(Node* head, int data) {
    if (head == NULL || head->next == NULL) { // 空链表或只有一个节点的链表
        return;
    }
    // 如果要删除的节点是头节点
    if (head->next->data == data) {
        Node* temp = head->next; // 暂存要删除的节点
        head->next = temp->next; // 修改头节点的指针域，跳过要删除的节点
        free(temp); // 释放要删除的节点的内存空间
        return;
    }
    // 如果要删除的节点不是头节点
    Node* cur = head;
    while (cur->next != NULL && cur->next->data != data) { // 找到要删除的节点的前驱节点
        cur = cur->next;
    }
    if (cur->next == NULL) { // 未找到要删除的节点
        return;
    }
    Node* temp = cur->next; // 暂存要删除的节点
    cur->next = temp->next; // 修改前驱节点的指针域，跳过要删除的节点
    free(temp); // 释放要删除的节点的内存空间
}

5. 遍历链表

遍历链表时，可以从头节点开始，依次访问每个节点的数据域，直到遇到空指针为止。以下是一个简单的遍历链表的函数。

void traverseList(Node* head) {
    Node* cur = head->next; // 从头节点的下一个节点开始遍历
    while (cur != NULL) {
        printf("%d ", cur->data); // 访问当前节点的数据域
        cur = cur->next; // 移动到下一个节点
    }
    printf("\n");
}

6. 完整示例代码

下面是将以上函数整合到一起的完整示例代码：

#include 
#include 
typedef struct Node {
    int data;
    struct Node* next;
} Node;
Node* initList() {
    Node* head = (Node*)malloc(sizeof(Node));
    if (!head) {
        exit(1);
    }
    head->next = NULL;
    return head;
}
void insertNode(Node* head, int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (!newNode) {
        exit(1);
    }
    newNode->data = data;
    newNode->next = NULL;
    Node* cur = head;
    while (cur->next != NULL) {
        cur = cur->next;
    }
    cur->next = newNode;
}
void deleteNode(Node* head, int data) {
    if (head == NULL || head->next == NULL) {
        return;
    }
    if (head->next->data == data) {
        Node* temp = head->next;
        head->next = temp->next;
        free(temp);
        return;
    }
    Node* cur = head;
    while (cur->next != NULL && cur->next->data != data) {
        cur = cur->next;
    }
    if (cur->next == NULL) {
        return;
    }
    Node* temp = cur->next;
    cur->next = temp->next;
    free(temp);
}
void traverseList(Node* head) {
    Node* cur = head->next;
    while (cur != NULL) {
        printf("%d ", cur->data);
        cur = cur->next;
    }
    printf("\n");
}
int main() {
    Node* head = initList();
    insertNode(head, 1);
    insertNode(head, 2);
    insertNode(head, 3);
    insertNode(head, 4);
    traverseList(head); // 输出: 1 2 3 4
    deleteNode(head, 3);
    traverseList(head); // 输出: 1 2 4
    return 0;
}

四、链表的其他操作与扩展

1. 查找节点

在链表中查找特定值的节点时，通常需要从头节点开始遍历链表，逐个比较节点的数据域直到找到目标节点或遍历完整个链表。以下是一个简单的查找节点的函数实现：

Node* findNode(Node* head, int data) {
    Node* cur = head->next; // 从头节点的下一个节点开始遍历
    while (cur != NULL && cur->data != data) {
        cur = cur->next;
    }
    return cur; // 如果找到目标节点，返回该节点；否则返回NULL
}

2. 反转链表

反转链表是一个常见的链表操作，它将链表中的节点顺序进行反转。以下是反转链表的函数实现：

Node* reverseList(Node* head) {
    Node* prev = NULL;
    Node* cur = head->next;
    Node* next = NULL;
    while (cur != NULL) {
        next = cur->next; // 保存当前节点的下一个节点
        cur->next = prev; // 将当前节点的指针指向前一个节点
        prev = cur; // 移动prev到当前节点
        cur = next; // 移动cur到下一个节点
    }
    head->next = prev; // 反转后，新的头节点是prev
    return head;
}

3. 链表排序

链表排序通常使用插入排序、归并排序等算法。由于链表不是连续存储的，所以一些针对数组的排序算法（如快速排序、堆排序）可能不适合直接应用于链表。以下是使用插入排序算法对链表进行排序的示例：

void insertionSortList(Node** head_ref) {
    Node* sorted = NULL;
    Node* current = *head_ref;
    Node* next = NULL;
    while (current != NULL) {
        next = current->next; // 保存下一个节点
        // 将current节点插入到已排序链表sorted中
        if (sorted == NULL || sorted->data >= current->data) {
            current->next = sorted;
            sorted = current;
        } else {
            Node* prev = NULL;
            while (sorted != NULL && sorted->data data) {
                prev = sorted;
                sorted = sorted->next;
            }
            current->next = sorted;
            prev->next = current;
        }
        current = next; // 移动到下一个节点
    }
    *head_ref = sorted; // 排序后的链表
}

4. 双向链表

双向链表是链表的一种扩展，每个节点除了有一个指向下一个节点的指针外，还有一个指向前一个节点的指针。这样可以方便地进行向前和向后的遍历操作。双向链表的实现与单向链表类似，但需要额外处理指针的修改。

5. 循环链表

循环链表是链表的另一种扩展，它将链表的最后一个节点指向头节点，形成一个环形结构。循环链表常用于表示具有循环性质的数据，如环形队列、约瑟夫环问题等。循环链表的实现与单向链表类似，但在处理边界条件时需要特别注意。

五、链表的应用场景

链表在实际应用中具有广泛的应用场景，如：

文件存储：链表可以用于存储文件系统中的文件和目录信息，方便进行插入、删除和遍历操作。
网络路由：在计算机网络中，路由器使用链表来存储路由表信息，以便根据目标地址选择合适的下一跳节点。
哈希表冲突解决：当哈希表发生哈希冲突时，可以使用链表（称为链表法或链地址法）来解决冲突问题。
LRU缓存淘汰策略：在最近最少使用（LRU）缓存淘汰策略中，可以使用双向链表来记录元素的访问顺序，以便在需要淘汰元素时能够快速找到最久未访问的元素。
六、总结

链表作为一种重要的数据结构，具有动态分配、插入和删除操作方便等特点。通过定义节点结构、链表初始化、插入节点、删除节点和遍历链表等基本操作，可以实现链表的基本功能。此外，链表还有查找节点、反转链表、链表排序等扩展操作。链表在实际应用中具有广泛的应用场景，如文件存储、网络路由、哈希表冲突解决和LRU缓存淘汰策略等。掌握链表的基本原理和实现方法对于提高编程能力和解决实际问题具有重要意义。

VPS购买请点击我