链表是计算机科学中一种基础且重要的数据结构，它如同一条由珠子串成的项链，每个珠子（节点）都包含着数据和指向下一个珠子的线索。

与数组相比，链表在插入和删除操作上更加灵活，无需预先分配固定大小的内存空间。

一、单链表：数据结构的入门之选

基本形态与特点

单链表是链表家族中最基础的成员，它由一系列节点组成，每个节点包含两部分：

数据域和指针域。

数据域存储具体的数据，而指针域则指向下一个节点。

链表的起点由一个头指针（head）指向，最后一个节点的指针域指向 NULL，表示链表的结束。

特点总结：

        单向访问：只能从头节点开始，沿着指针方向依次访问后续节点

        插入和删除操作效率高：O (1) 时间复杂度（前提是已知操作位置的前驱节点）

        动态内存分配：无需预先分配固定大小的内存

        随机访问效率低：访问第 n 个节点需要 O (n) 时间

示例代码：单链表的实现

#include <stdio.h>
#include <stdlib.h>// 定义单链表节点结构
typedef struct Node {int data;           // 数据域struct Node* next;  // 指针域，指向下一个节点
} Node;// 创建新节点
Node* createNode(int data) {Node* newNode = (Node*)malloc(sizeof(Node));if (newNode == NULL) {printf("内存分配失败\n");exit(1);}newNode->data = data;newNode->next = NULL;return newNode;
}// 在链表尾部插入节点
void append(Node** head_ref, int data) {Node* newNode = createNode(data);if (*head_ref == NULL) {*head_ref = newNode;return;}Node* last = *head_ref;while (last->next != NULL) {last = last->next;}last->next = newNode;
}// 打印链表
void printList(Node* node) {while (node != NULL) {printf("%d -> ", node->data);node = node->next;}printf("NULL\n");
}// 释放链表内存
void freeList(Node* head) {Node* temp;while (head != NULL) {temp = head;head = head->next;free(temp);}
}int main() {Node* head = NULL;append(&head, 1);append(&head, 2);append(&head, 3);printf("单链表内容: ");printList(head);freeList(head);return 0;
}

单链表示意图

头指针 head↓┌───────┐    ┌───────┐    ┌───────┐│ 1 | ──┼──→ │ 2 | ──┼──→ │ 3 | NULL└───────┘    └───────┘    └───────┘

二、双向链表：支持双向导航的灵活结构

基本形态与特点

双向链表在单链表的基础上进行了扩展，每个节点除了包含数据域和指向下一个节点的指针外，还增加了一个指向前驱节点的指针。

这种结构使得双向链表支持双向遍历，既可以从头节点向后访问，也可以从尾节点向前访问。

特点总结：

                双向访问：支持从头节点和尾节点两个方向进行遍历

                插入和删除操作更加灵活：可以快速访问前驱节点

                每个节点占用更多内存：需要额外的指针域存储前驱节点信息

                操作复杂度增加：插入和删除操作需要维护两个指针

示例代码：双向链表的实现

#include <stdio.h>
#include <stdlib.h>// 定义双向链表节点结构
typedef struct DNode {int data;               // 数据域struct DNode* prev;     // 指向前驱节点的指针struct DNode* next;     // 指向后继节点的指针
} DNode;// 创建新节点
DNode* createDNode(int data) {DNode* newNode = (DNode*)malloc(sizeof(DNode));if (newNode == NULL) {printf("内存分配失败\n");exit(1);}newNode->data = data;newNode->prev = NULL;newNode->next = NULL;return newNode;
}// 在链表尾部插入节点
void appendDNode(DNode** head_ref, int data) {DNode* newNode = createDNode(data);if (*head_ref == NULL) {*head_ref = newNode;return;}DNode* last = *head_ref;while (last->next != NULL) {last = last->next;}last->next = newNode;newNode->prev = last;
}// 打印双向链表（正向）
void printForward(DNode* node) {while (node != NULL) {printf("%d <-> ", node->data);node = node->next;}printf("NULL\n");
}// 释放双向链表内存
void freeDList(DNode* head) {DNode* temp;while (head != NULL) {temp = head;head = head->next;free(temp);}
}int main() {DNode* head = NULL;appendDNode(&head, 1);appendDNode(&head, 2);appendDNode(&head, 3);printf("双向链表内容(正向): ");printForward(head);freeDList(head);return 0;
}

双向链表示意图

头指针 head↓┌───────┐    ┌───────┐    ┌───────┐
NULL←─| 1 | ──┼──→| 2 | ──┼──→| 3 |─→NULL└───────┘    └───────┘    └───────┘

三、循环链表：首尾相连的封闭结构

基本形态与特点

循环链表是一种特殊的链表结构，它的最后一个节点的指针域不再指向 NULL，而是指向链表的头节点，形成一个闭合的环。

循环链表可以是单循环链表（只使用一个方向的指针）或双循环链表（使用双向指针）。

特点总结：

                首尾相连：可以从任意节点开始遍历整个链表

                没有明显的头节点和尾节点：需要特别注意循环终止条件

                适合实现环形缓冲区、轮询调度等场景

                插入和删除操作需要考虑维护循环特性

示例代码：单循环链表的实现

#include <stdio.h>
#include <stdlib.h>// 定义循环链表节点结构
typedef struct CNode {int data;struct CNode* next;
} CNode;// 创建新节点
CNode* createCNode(int data) {CNode* newNode = (CNode*)malloc(sizeof(CNode));if (newNode == NULL) {printf("内存分配失败\n");exit(1);}newNode->data = data;newNode->next = newNode;  // 初始时指向自身return newNode;
}// 在链表尾部插入节点
void appendCNode(CNode** head_ref, int data) {CNode* newNode = createCNode(data);if (*head_ref == NULL) {*head_ref = newNode;return;}CNode* last = (*head_ref)->next;  // 找到尾节点while (last->next != *head_ref) {last = last->next;}last->next = newNode;newNode->next = *head_ref;
}// 打印循环链表
void printCList(CNode* head) {if (head == NULL) return;CNode* temp = head;do {printf("%d -> ", temp->data);temp = temp->next;} while (temp != head);printf("(回到头节点)\n");
}// 释放循环链表内存
void freeCList(CNode* head) {if (head == NULL) return;CNode* temp = head->next;while (temp != head) {CNode* next = temp->next;free(temp);temp = next;}free(head);
}int main() {CNode* head = NULL;appendCNode(&head, 1);appendCNode(&head, 2);appendCNode(&head, 3);printf("循环链表内容: ");printCList(head);freeCList(head);return 0;
}

单循环链表示意图

   ┌───────┐    ┌───────┐    ┌───────┐│ 1 | ──┼──→ │ 2 | ──┼──→ │ 3 | ──┼──┐└───────┘    └───────┘    └───────┘  │↑                                  │└──────────────────────────────────┘

四、双向循环链表：最灵活的链表结构

基本形态与特点

双向循环链表结合了双向链表和循环链表的特点，每个节点既包含指向前驱节点的指针，也包含指向后继节点的指针，并且链表的首尾节点相连形成一个环。

这种结构提供了最大的灵活性，但也需要更多的内存和更复杂的操作。

特点总结：

双向遍历：可以从任意节点开始向前或向后遍历首尾相连：

没有明显的头节点和尾节点插入和删除操作

需要维护四个指针（前驱和后继节点的指针）

适合需要频繁双向遍历和循环操作的场景

示例代码：双向循环链表的实现

#include <stdio.h>
#include <stdlib.h>// 定义双向循环链表节点结构
typedef struct DCNode {int data;struct DCNode* prev;struct DCNode* next;
} DCNode;// 创建新节点
DCNode* createDCNode(int data) {DCNode* newNode = (DCNode*)malloc(sizeof(DCNode));if (newNode == NULL) {printf("内存分配失败\n");exit(1);}newNode->data = data;newNode->prev = newNode;newNode->next = newNode;return newNode;
}// 在链表尾部插入节点
void appendDCNode(DCNode** head_ref, int data) {DCNode* newNode = createDCNode(data);if (*head_ref == NULL) {*head_ref = newNode;return;}DCNode* last = (*head_ref)->prev;  // 找到尾节点last->next = newNode;newNode->prev = last;newNode->next = *head_ref;(*head_ref)->prev = newNode;
}// 打印双向循环链表（正向）
void printDCListForward(DCNode* head) {if (head == NULL) return;DCNode* temp = head;do {printf("%d <-> ", temp->data);temp = temp->next;} while (temp != head);printf("(回到头节点)\n");
}// 释放双向循环链表内存
void freeDCList(DCNode* head) {if (head == NULL) return;DCNode* temp = head->next;while (temp != head) {DCNode* next = temp->next;free(temp);temp = next;}free(head);
}int main() {DCNode* head = NULL;appendDCNode(&head, 1);appendDCNode(&head, 2);appendDCNode(&head, 3);printf("双向循环链表内容(正向): ");printDCListForward(head);freeDCList(head);return 0;
}

双向循环链表示意图

   ┌───────┐    ┌───────┐    ┌───────┐│ 1 | ──┼──→ │ 2 | ──┼──→ │ 3 | ──┼──┐└───────┘    └───────┘    └───────┘  │↑  ↑                                ││  └────────────────────────────────┘│                                     │└─────────────────────────────────────┘

五、链表与数组的对比

特性	链表	数组
内存分配	动态分配，无需预先指定大小	静态分配，需要预先指定大小
插入 / 删除效率	O (1)（已知位置）	O (n)（需要移动元素）
随机访问效率	O(n)	O(1)
内存利用率	可能有碎片（每个节点需要额外指针）	连续内存，无碎片
适用场景	频繁插入删除，数据量不确定	频繁随机访问，数据量固定

总结

链表作为一种基础的数据结构，在计算机科学中有着广泛的应用。通过本文的介绍，我们了解了链表的四种主要类型：

        单链表：最简单的链表形式，支持单向遍历

        双向链表：增加了前驱指针，支持双向遍历

        循环链表：首尾相连，适合环形结构的应用

        双向循环链表：结合了双向链表和循环链表的特点，提供最大的灵活性

每种链表结构都有其独特的形态、特点和适用场景。

在实际编程中，我们可以根据具体需求选择合适的链表类型。

链表的核心优势在于动态内存分配和高效的插入删除操作，这使得它在许多场景下比数组更加适用。