目录
链表的基本概念
链表是一种动态数据结构，通过指针将一系列节点连接起来。每个节点包含数据域和指针域，数据域存储实际数据，指针域存储下一个节点的地址。链表的优势在于插入和删除操作高效，无需移动大量元素。
链表的存储结构
链表节点在C语言中通常用结构体表示：
struct Node {
int data; // 数据域
struct Node* next; // 指针域
};
data存储实际数据next指向下一个节点的地址
举个形象的例子
想象一列火车：
- 每节车厢相当于一个节点
- 车厢之间的挂钩相当于指针
- 车头指针指向第一节车厢
- 最后一节车厢的指针为NULL
链表与数组的对比
| 特性 | 数组 | 链表 |
|---|---|---|
| 内存分配 | 静态连续 | 动态非连续 |
| 插入/删除 | O(n) | O(1) |
| 随机访问 | O(1) | O(n) |
| 空间利用率 | 固定 | 按需分配 |
这里的O(n)和O(1)是时间复杂度，表示操作的效率（n一般指数据规模）。
常见链表类型
单链表
单链表是一种常见的线性数据结构，它由一系列节点组成。
每个节点包含两部分：
1、数据域：用于存储具体的数据值，比如图里节点中的 “1”“2”“4” 这些内容，就是数据域存储的数据。
2、指针域（通常称为next）：是一个指针（或引用），用于指向下一个节点。通过这个指针，把一个个节点连接起来，形成一条 “链”。
双向链表
（包含前驱和后继指针，支持双向遍历）
双向链表的每个节点包含三部分：
prev：指向前一个节点的指针，通过它可以从当前节点回溯到前一个节点。
data：存储节点的数据内容。
next：指向后一个节点的指针，通过它可以从当前节点访问到后一个节点。
这种结构让节点既能 “往后找” 下一个节点，也能 “往前找” 上一个节点，是双向链表区别于单向链表（只有next指针）的关键。
多个这样的节点通过prev和next指针依次连接，就形成了双向链表：
每个节点的next指向下一个节点，prev指向上一个节点。
链表的最后一个节点，它的next指针指向NULL（表示没有后续节点了），这样能明确链表的终点。
struct Node {
int data;
struct Node* prev;
struct Node* next;
};
循环链表
尾节点指向头节点，形成环形结构
链表的一些基本操作
单链表的基本操作实现
打印单链表
1、定义一个指针pcur，从链表的头节点（phead）开始。
2、通过while (pcur)循环遍历链表（只要pcur不是NULL，就继续遍历）。
3、在循环中，打印当前节点（pcur）的数据（格式为“数据->”），然后让pcur指向下一个节点（pcur = pcur->next;），继续打印下一个节点。
4、当循环结束（pcur为NULL，说明遍历完链表了），打印“NULL\n”，表示链表的末尾。
void SLTPrint(SLTNode* phead)
{
SLTNode* pcur = phead;
while (pcur)//pcur != NULL
{
printf("%d->", pcur->data);
pcur = pcur->next;
}
printf("NULL\n");
}动态申请一个节点
1、用 malloc 动态申请一块内存，用于存储一个链表节点（SLTNode 类型）
2、检查内存申请是否成功：如果失败（malloc 返回 NULL），就用 perror 打印错误信息，然后退出程序
3、对新节点进行初始化：把传入的参数 x 赋值给节点的数据域（data），把节点的指针域（next）初始化为 NULL（暂时不指向任何节点），返回这个新创建的节点的地址。
SLTNode* SLTBuyNode(SLTDataType x)
{
SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
if (newnode == NULL)
{
perror("malloc fail!");
exit(1);
}
newnode->data = x;
newnode->next = NULL;
return newnode;
}尾插
1、先通过assert(pphead)确保传入的头指针地址有效（避免空指针错误）。
2、调用SLTBuyNode(x)创建一个包含数据x的新节点
3、分两种情况处理：
如果链表是空的（*pphead == NULL）：直接让头指针指向新节点，新节点就成了链表的第一个节点。
如果链表不是空的：先通过while (ptail->next)循环找到链表的最后一个节点（尾节点），然后让尾节点的next指针指向新节点，这样新节点就成了新的尾节点。
简单讲，这段代码就像在队伍的最后面加一个人：如果队伍是空的，这个人就是第一个；如果队伍已有其他人，就找到最后一个人，让他 "拉着" 新来的人。
//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
assert(pphead);
//*pphead 就是指向第一个节点的指针
//空链表和非空链表
SLTNode* newnode = SLTBuyNode(x);
if (*pphead == NULL)
{
*pphead = newnode;
}
else
{
//找尾
SLTNode* ptail = *pphead;
while (ptail->next)
{
ptail = ptail->next;
}
//ptail指向的就是尾结点
ptail->next = newnode;
}
}头插
1、先通过assert(pphead)确保传入的头指针地址有效（避免空指针错误）。
2、调用SLTBuyNode(x)创建一个包含数据x的新节点。
3、让新节点的next指针指向原来的头节点（newnode->next = *pphead），相当于新节点 "链接" 到原来的第一个节点前面。
4、最后更新头指针（*pphead = newnode），让头指针指向新节点，这样新节点就成为了链表的新头部。
//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
assert(pphead);
SLTNode* newnode = SLTBuyNode(x);
newnode->next = *pphead;
*pphead = newnode;
}尾删
1、先通过assert(pphead && *pphead)确保传入的头指针地址有效，且链表不为空（避免对空链表执行删除操作）。
2、分两种情况处理：
如果链表只有一个节点（(*pphead)->next == NULL）：直接释放这个节点的内存（free(*pphead)），然后将头指针置为NULL，表示链表变为空。
如果链表有多个节点：
用prev指针跟踪尾节点的前一个节点，ptail指针找到最后一个节点（通过while (ptail->next)循环遍历）。
释放尾节点的内存（free(ptail)）。
将倒数第二个节点（prev）的next指针置为NULL，使其成为新的尾节点。
//尾删
void SLTPopBack(SLTNode** pphead)
{
//链表不能为空
assert(pphead && *pphead);
//链表只有一个节点
if ((*pphead)->next == NULL) //-> 优先级高于*
{
free(*pphead);
*pphead = NULL;
}
else {
//链表有多个节点
SLTNode* prev = *pphead;
SLTNode* ptail = *pphead;
while (ptail->next)
{
prev = ptail;
ptail = ptail->next;
}
//prev ptail
free(ptail);
ptail = NULL;
prev->next = NULL;
}
}头删
1、先通过assert(pphead && *pphead)确保传入的头指针地址有效，且链表不为空（避免对空链表执行删除操作）。
2、保存头节点的下一个节点（也就是原链表的第二个节点）的地址到next指针里。
3、释放头节点（原链表的第一个节点）的内存（free(*pphead)）。
4、将头指针指向next（原第二个节点），这样原第二个节点就成为了新的头节点。
//头删
void SLTPopFront(SLTNode** pphead)
{
//链表不能为空
assert(pphead && *pphead);
SLTNode* next = (*pphead)->next; //-> 优先级高于*
free(*pphead);
*pphead = next;
}查找
1、定义一个指针 pcur，从链表的头节点（phead）开始。
2、通过 while (pcur) 循环遍历链表（只要 pcur 不是 NULL，就继续遍历）。
3、在循环中，判断当前节点（pcur）的数据是否等于要查找的 x：
如果等于，直接返回当前节点的指针（return pcur;）。
如果不等于，让 pcur 指向下一个节点（pcur = pcur->next;），继续查找。
4、如果循环结束（说明遍历完链表了），还没找到，就返回 NULL。
//查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
SLTNode* pcur = phead;
while (pcur)//等价于pcur != NULL
{
if (pcur->data == x)
{
return pcur;
}
pcur = pcur->next;
}
//pcur == NULL
return NULL;
}在指定位置插入
1、首先进行断言（assert），确保头指针的地址有效、链表不为空，且指定的位置pos有效。
2、调用SLTBuyNode(x)创建一个包含数据x的新节点。
3、分两种情况处理：
如果指定位置pos就是头节点（pos == *pphead），那就调用之前的头插函数SLTPushFront，直接在头部插入新节点。
如果pos不是头节点，就通过while循环找到pos的前一个节点prev。然后将新节点的next指针指向pos，再将prev的next指针指向新节点，这样就完成了在pos之前插入新节点的操作。
//在指定位置之前插入数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
assert(pphead && *pphead);
assert(pos);
SLTNode* newnode = SLTBuyNode(x);
//若pos == *pphead;说明是头插
if (pos == *pphead)
{
SLTPushFront(pphead, x);
}
else {
SLTNode* prev = *pphead;
while (prev->next != pos)
{
prev = prev->next;
}
//prev -> newnode -> pos
newnode->next = pos;
prev->next = newnode;
}
}1、首先用assert(pos);确保指定的位置pos有效（不是NULL）。
2、调用SLTBuyNode(x)创建一个包含数据x的新节点。
3、进行指针调整：
先让新节点的next指针指向pos节点原本的下一个节点（newnode->next = pos->next;）。
再让pos节点的next指针指向新节点（pos->next = newnode;）。这样就完成了在pos节点之后插入新节点的操作。
//在指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
assert(pos);
SLTNode* newnode = SLTBuyNode(x);
//pos -> newnode -> pos->next
newnode->next = pos->next;
pos->next = newnode;
}
删除指定位置
1、首先进行断言（assert），确保头指针的地址有效、链表不为空，且要删除的节点pos有效。
2、分两种情况处理：
如果要删除的节点pos是头节点（pos == *pphead），就调用之前的头删函数SLTPopFront，直接删除头节点。
如果pos不是头节点，就通过while循环找到pos的前一个节点prev。然后将prev的next指针指向pos的下一个节点，接着释放pos节点的内存，并将pos置为NULL，从而完成删除操作。
//删除pos节点
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
assert(pphead && *pphead);
assert(pos);
//pos是头结点/pos不是头结点
if (pos == *pphead)
{
//头删
SLTPopFront(pphead);
}
else {
SLTNode* prev = *pphead;
while (prev->next != pos)
{
prev = prev->next;
}
//prev pos pos->next
prev->next = pos->next;
free(pos);
pos = NULL;
}
}
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
