赞
踩
概念:链表是一种物理存储结构上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表的指针链表中的指针链表次序实现的。
- 链表的结构跟火车车厢相似,淡季时车次的车厢会相应减少,旺季时车次的车厢会额外增加几节。只需要将火车里的某节车厢去掉 / 加上,不会影响其他车厢,每节车厢都是独立存在的。
- 车厢是独立存在的,且每节车厢都有车门。想象一下这样的场景,假设每节车厢的车门都是锁上的状态,需要不同的钥匙才能解锁,每次只能携带一把钥匙的情况下如何从车头走到车尾?
最简单的做法:每节车厢里都放一把下一节车厢的钥匙。
在链表里,每节“车厢”是什么样的呢?
- 与顺序表不同的是,链表里的每一个“车厢”都是独立申请下来的空间,称之为“节点/结点”。
- 节点的组成主要有两个部分:当前节点要保存的数据和保存下一个节点的地址(指针变量)。
- 图中的指针 plist 保存的是第一个节点的地址,称之为“指向”第一个节点,如果希望 plist “指向”第二个节点时,只需要修改plist保存的内容0x0012FFA0。
为什么还需要指针变量来保存下一个节点的位置?
链表中的每一个节点都是独立申请的(即需要插入数据时才去申请一块结点的空间),需要通过指针变量来保存下一个节点位置才能从当前节点找到下一个节点。
结合前面学过的结构体知识,可以给出每个节点对应的结构体代码:
假设当前保存的节点为整型:
struct SListNode
{
int data;//节点数据
struct SListNode* next;//指针变量用保存下一个节点的地址
};
当想要保存一个整型数据时,实际是向操作系统申请一块内存,这个内存不仅要保存整型数据,也要保存下一个节点的地址(当下一个节点为空时保存的地址为空)。
当想要从第一个节点走到最后一个节点时,只需要在前一个结点拿上下一个节点地址(下一个结点的钥匙)就可以了。
给定的链表结构中,如何实现节点从头到尾的打印?
void SListTest01() { //链表是由一个个节点组成 //创建几个节点 SLTNode* node1 = (SLTNode*)malloc(sizeof(SLTNode)); node1->data = 1; SLTNode* node2 = (SLTNode*)malloc(sizeof(SLTNode)); node2->data = 2; SLTNode* node3 = (SLTNode*)malloc(sizeof(SLTNode)); node3->data = 3; SLTNode* node4 = (SLTNode*)malloc(sizeof(SLTNode)); node4->data = 4; //将四个节点连接起来: node1->next = node2; node2->next = node3; node3->next = node4; node4->next = NULL; //调用链表的打印 SLTNode* plist = node1; SLTPrint(plist); }
思考:当想要保存的数据类型为字符串类型、浮点型或者其他自定义类型时,该如何修改?
补充说明:
//链表的打印
void SLTPrint(SLTNode* phead)
{
//相当于遍历链表
SLTNode* pcur = phead;
while (pcur)//等价于pcur != NULL
{
printf("%d->", pcur->data);
//让pcur走到下一个节点
pcur = pcur->next;
}
printf("NULL\n");
}
图文理解:
//节点的申请
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;
}
//单链表的尾插 void SLTPushBack(SLTNode** pphead, SLTDataType x) { assert(pphead); //*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; } }
图文理解:
//单链表的头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
assert(pphead);
SLTNode* newnode = SLTBuyNode(x);
//直接把新节点插在头节点之前
newnode->next = *pphead;
//再让*pphead走到newnode的位置
*pphead = newnode;
}
图文理解:
解释:
情况1就是正常的头插,没有问题。情况2头插的是空链表,也符合要求。
//单链表的尾删 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前一个指针 prev = ptail; ptail = ptail->next; } free(ptail); ptail = NULL; prev->next = NULL; } }
图文理解:
//单链表的头删
void SLTPopFront(SLTNode** pphead)
{
//既然要删除节点,那链表不能为空
assert(pphead && *pphead);
//先把下一个节点的指针存储下来,防止等到删除掉头节点之后,找不到后面的节点
SLTNode* next = (*pphead)->next;//->的优先级高于*
free(*pphead);
//让*pphead走到next位置,变成新的头节点
*pphead = next;
}
图文理解:
//单链表节点的查找 SLTNode* SLTFind(SLTNode* phead, SLTDataType x) { //本质也是遍历单链表 SLTNode* pcur = phead; while (pcur) { if (pcur->data == x) { return pcur; } pcur = pcur->next; } //到这一步,已经证明找不到x了 return NULL; }
//在指定位置之前插入数据 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; } //就是把新节点newnode插在prev与pos中间: //prev -> newnode -> pos newnode->next = pos; prev->next = newnode; } }
图文理解:
//在指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
//在pos之后插入数据,证明这个链表就不为空,不用判断
assert(pos);
SLTNode* newnode = SLTBuyNode(x);
//就是在pos与pos->next之间插入新的节点:
//pos -> newnode -> pos->next
newnode->next = pos->next;
pos->next = newnode;
}
图文理解:
//删除pos节点 void SLTErase(SLTNode** pphead, SLTNode* pos) { assert(pphead && *pphead); assert(pos); //pos是头节点 / 不是头节点 if (pos == *pphead) { //调用头删的方法 SLTPopFront(pphead); } else { SLTNode* prev = *pphead; while (prev->next != pos) { prev = prev->next; } //就是在pos与pos->next删除节点 //prev -> pos -> pos->next prev->next = pos->next; free(pos); pos = NULL; } }
图文理解:
//删除pos之后的节点
void SLTEraseAfter(SLTNode* pos)
{
assert(pos && pos->next);
SLTNode* del = pos->next;
//就是在pos与del->next删除节点
//pos -> del -> del->next
pos->next = del->next;
free(del);
del = NULL;
}
图文理解:
//单链表的销毁 void SListDestroy(SLTNode** pphead) { assert(pphead && *pphead); SLTNode* pcur = *pphead; while (pcur) { //从第一个节点开始销毁,每销毁一个节点之前,先保存当前节点的下一个节点的指针, //否则销毁当前结点的时候,后面的节点找不到了 SLTNode* next = pcur->next; free(pcur); pcur = NULL; } //把头节点手动置为空 *pphead = NULL; }
SList.h
#pragma once #define _CRT_SECURE_NO_WARNINGS 1 #include <stdio.h> #include <stdlib.h> #include <assert.h> //定义结点的结构 //数据+下一个结点的地址 typedef int SLTDataType; typedef struct SListNode { SLTDataType data; struct SListNode* next; }SLTNode; //链表的打印 void SLTPrint(SLTNode* phead); //单链表的尾插 void SLTPushBack(SLTNode** pphead, SLTDataType x); //单链表的头插 void SLTPushFront(SLTNode** pphead, SLTDataType x); //单链表的尾删 void SLTPopBack(SLTNode** pphead); //单链表的头删 void SLTPopFront(SLTNode** pphead); //单链表节点的查找 SLTNode* SLTFind(SLTNode* phead, SLTDataType x); //在指定位置之前插入数据 void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x); //在指定位置之后插入数据 void SLTInsertAfter(SLTNode* pos, SLTDataType x); //删除pos节点 void SLTErase(SLTNode** pphead, SLTNode* pos); //删除pos之后的节点 void SLTEraseAfter(SLTNode* pos); //单链表的销毁 void SListDestroy(SLTNode** pphead);
SList.c
#include "SList.h" //节点的申请 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; } //链表的打印 void SLTPrint(SLTNode* phead) { //相当于遍历链表 SLTNode* pcur = phead; while (pcur)//等价于pcur != NULL { printf("%d->", pcur->data); //让pcur走到下一个节点 pcur = pcur->next; } printf("NULL\n"); } //单链表的尾插 void SLTPushBack(SLTNode** pphead, SLTDataType x) { assert(pphead); //*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; } } //单链表的头插 void SLTPushFront(SLTNode** pphead, SLTDataType x) { assert(pphead); SLTNode* newnode = SLTBuyNode(x); //直接把新节点插在头节点之前 newnode->next = *pphead; //再让*pphead走到newnode的位置 *pphead = newnode; } //单链表的尾删 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前一个指针 prev = ptail; ptail = ptail->next; } free(ptail); ptail = NULL; prev->next = NULL; } } //单链表的头删 void SLTPopFront(SLTNode** pphead) { //既然要删除节点,那链表不能为空 assert(pphead && *pphead); //先把下一个节点的指针存储下来,防止等到删除掉头节点之后,找不到后面的节点 SLTNode* next = (*pphead)->next;//->的优先级高于* free(*pphead); //让*pphead走到next位置,变成新的头节点 *pphead = next; } //单链表节点的查找 SLTNode* SLTFind(SLTNode* phead, SLTDataType x) { //本质也是遍历单链表 SLTNode* pcur = phead; while (pcur) { if (pcur->data == x) { return pcur; } pcur = pcur->next; } //到这一步,已经证明找不到x了 return NULL; } //在指定位置之前插入数据 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; } //就是把新节点newnode插在prev与pos中间: //prev -> newnode -> pos newnode->next = pos; prev->next = newnode; } } //在指定位置之后插入数据 void SLTInsertAfter(SLTNode* pos, SLTDataType x) { //在pos之后插入数据,证明这个链表就不为空,不用判断 assert(pos); SLTNode* newnode = SLTBuyNode(x); //就是在pos与pos->next之间插入新的节点: //pos -> newnode -> pos->next newnode->next = pos->next; pos->next = newnode; } //删除pos节点 void SLTErase(SLTNode** pphead, SLTNode* pos) { assert(pphead && *pphead); assert(pos); //pos是头节点 / 不是头节点 if (pos == *pphead) { //调用头删的方法 SLTPopFront(pphead); } else { SLTNode* prev = *pphead; while (prev->next != pos) { prev = prev->next; } //就是在pos与pos->next删除节点 //prev -> pos -> pos->next prev->next = pos->next; free(pos); pos = NULL; } } //删除pos之后的节点 void SLTEraseAfter(SLTNode* pos) { assert(pos && pos->next); SLTNode* del = pos->next; //就是在pos与del->next删除节点 //pos -> del -> del->next pos->next = del->next; free(del); del = NULL; } //单链表的销毁 void SListDestroy(SLTNode** pphead) { assert(pphead && *pphead); SLTNode* pcur = *pphead; while (pcur) { //从第一个节点开始销毁,每销毁一个节点之前,先保存当前节点的下一个节点的指针, //否则销毁当前结点的时候,后面的节点找不到了 SLTNode* next = pcur->next; free(pcur); pcur = NULL; } //把头节点手动置为空 *pphead = NULL; }
test.c
#include "SList.h" void SListTest02() { SLTNode* plist = NULL; //1.单链表的尾插 SLTPushBack(&plist, 1); SLTPrint(plist); SLTPushBack(&plist, 2); SLTPushBack(&plist, 3); SLTPushBack(&plist, 4); SLTPrint(plist); //2.单链表的头插 SLTPushFront(&plist, 4); SLTPushFront(&plist, 3); SLTPushFront(&plist, 2); SLTPushFront(&plist, 1); SLTPrint(plist); //3.单链表的尾删 SLTPopBack(&plist); SLTPopBack(&plist); SLTPopBack(&plist); SLTPopBack(&plist); SLTPrint(plist); //4.单链表的头删 SLTPopFront(&plist); SLTPopFront(&plist); SLTPopFront(&plist); SLTPopFront(&plist); SLTPrint(plist); //5.单链表节点的查找 SLTNode* find = SLTFind(plist, 1); if (find == NULL) { printf("找不到!\n"); } else { printf("找到了!\n"); } //6.在指定位置之前插入数据 SLTNode* find = SLTFind(plist, 3); SLTInsert(&plist, find, 6); SLTPrint(plist); //7.在指定位置之前插入数据 SLTNode* find = SLTFind(plist, 3); SLTInsertAfter(find, 6); SLTPrint(plist); //8.删除pos节点 SLTNode* find = SLTFind(plist, 3); SLTErase(&plist, find); SLTPrint(plist); //9.删除pos之后的节点 SLTNode* find = SLTFind(plist, 3); SLTEraseAfter(find); SLTPrint(plist); //10.单链表的销毁 SListDestroy(&plist); SLTPrint(plist); } int main() { SListTest02(); return 0; }
链表的结构非常多样,以下情况组合起来就有8种(2 x 2 x 2)链表结构:
链表说明:
虽然有这么多的链表的结构,但是实际上中最常用还是两种结构:单链表和双向带头循环链表。
无头单向非循环链表:结构简单,一般不会单独用来存放数据。实际中更多是作为其他数据结构的子结构,如哈希桶、图的邻接表等。
带头双向循环链表:结构最复杂,一般用于单独存储数据。实际中使用的是链表数据结构,都是带头双向循环链表。另外,这个结构虽然结构复杂,但是使用代码实现以后会发现结构会带来很多优势,实现反而简单了。
Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。