目录
线性表的链式存储：链表
前言:
之前介绍过线性表的顺序存储方式：顺序表 发现顺序表在 插入删除操作需要移动大量元素；当静态顺序表长度变化较大时，难以确定存储空间的容量；造成存储空间的碎片。
数据结构中：
注意 这里的是没有哨兵卫的链表。
单链表
1.单链表的存储定义
单链表的存储与顺序表的存储不一样，单链表不仅仅存放数值，还要存放下一个结点的地址
代码
typedef int SLNDataType;
typedef struct SListNode
{
SLNDataType val; //存放单链表的值
struct SListNode* next; //存放下一个单链表的地址
}SLNode;当有了单链表的存储定义，我们就可以对单链表进行存放结点。
2.结点的创建
这里使用malloc函数进行创建
代码
//创建一个结点
SLNode* CreateNode(SLNDataType x)
{
SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
if (newnode == NULL)
{
perror("CreateNode->malloc");
exit(-1);
}
newnode->val = x; //结点赋值
newnode->next = NULL; //结点下一个结点为NULL
return newnode;
}3.链表尾插入结点
尾插结点：这里需要考虑两方面。
1、单链表为空，插入结点的情况，这里直接让头指针指向创建的新结点即可。
2、单链表不为空时，例如下图要尾插结点4
这里只需创建一个尾指针tail 遍历到第三个结点,把 第三个结点的next 指向 第四个结点即可
代码
//尾插结点
void SListPushBack(SLNode** pphead, SLNDataType x)
{
assert(pphead);
SLNode* newnode = CreateNode(x); //创建一个结点
if (*pphead == NULL) //单链表为空直接指向新结点
{
*pphead = newnode;
}
else
{
SLNode* tail = *pphead; //定义一个尾指针
while (tail->next != NULL) //找到表尾
{
tail = tail->next; //指向下一个结点
}
//找到表尾后指向新结点即可
tail->next = newnode;
}
}注意这里的二级指针。*pphead == phead,指向第一个结点。
4.单链表尾删结点
单链表尾部删除结点：分两种情况。1)只有一个结点的情况 2)多个结的情况
因为平时删除结点，对于单链表，我们需要找到前面的结点。所以这里采取经典的双指针的方法
定义一个指向当前的结点(cur)，一个指向前面的结点(pre)，当遍历到表尾时，释放cur指向的结点后，把pre->next = NULL，这样就完成了尾删一个结点。
但是我们发现只有一个结点时
这里free(cur) ,但是pre指向NULL, 这条语句 pre->next = NULL 就是错的。
当然有些人会可能想到，为什么不让pre也指向第一个结点，如果这样想，这里显然是对free()这知识点模糊不清 。因为free(cur) 时 第一个结点的内存空间已经释放返还给操作系统了，所以pre此时指向的内存空间，属于访问野指针了。
所以我们对 1)只有一个结点的情况 2)多个结点的情况 分别处理
1）一个结点的情况
if ((*pphead)->next == NULL) //只有一个结点的情况
{
free(*pphead);
*pphead = NULL;
}2) 多个结点的情况
定义一个指向当前的结点(cur)，一个指向前面的结点(pre)，当遍历到表尾时，释放cur指向的结点后，把pre->next = NULL，这样就完成了尾删一个结点。
SLNode* cur = *pphead;
SLNode* pre = NULL;
while (cur->next != NULL)
{
pre = cur;
cur = cur->next;
}
free(cur);
cur = NULL;
pre->next = NULL;代码
//尾删结点
void SListPopBack(SLNode** pphead)
{
assert(pphead);
assert(*pphead); //避免链表为空
if ((*pphead)->next == NULL) //只有一个结点的情况
{
free(*pphead);
*pphead = NULL;
}
else //多个结点的情况
{
SLNode* cur = *pphead;
SLNode* pre = NULL;
while (cur->next != NULL)
{
pre = cur;
cur = cur->next;
}
free(cur);
cur = NULL;
pre->next = NULL;
}
}当然上方代码也可以不用定义pre,来实现
//尾删结点
void SListPopBack(SLNode** pphead)
{
assert(*pphead); //避免链表为空
if ((*pphead)->next == NULL) //只有一个结点的情况
{
free(*pphead);
*pphead = NULL;
}
else //多个结点的情况
{
SLNode* cur = *pphead;
while (cur->next->next != NULL)
{
cur = cur->next;
}
free(cur->next);
cur->next = NULL;
}
}5.单链表头插入结点
首先创建一个新结点，然后让新结点指向 头指针指向的结点，头指针再指向新结点。
注意先后指向的顺序不能变。
代码
//头插结点
void SListPushFront(SLNode** pphead, SLNDataType x)
{
assert(pphead);
SLNode* newnode = CreateNode(x); //创建一个新结点
newnode->next = *pphead; //新结点指向 头指针指向的结点
*pphead = newnode; //再让头指针指向新结点
}
这样就变成
如果指向的顺序变了，那就会出现这种错误
结点的next指向自己,这样是错误的
6.单链表头删结点
单链表头删除结点时，先临时创建一个next指针来指向第一个结点的下一个结点，然后释放第一个结点，再让头指针指向next，这样就完成删除第一个结点。
代码
//头删结点
void SListPopFront(SLNode** pphead)
{
assert(pphead);
assert(*pphead);
SLNode* next = (*pphead)->next;
free(*pphead);
*pphead = next;
}方法二
当然也可以先临时存放第一个结点，让*pphead指向第二个结点，然后再删除第一个结点。
代码
//头删结点
void SListPopFront(SLNode** pphead)
{
assert(pphead);
assert(*pphead);
SLNode* tmp = *pphead;
*pphead = (*pphead)->next;
free(tmp);
}7.查找元素，返回结点
代码
//查找元素，返回结点
SLNode* SListFind(SLNode* phead, SLNDataType x)
{
SLNode* cur = phead;
while (cur)
{
if (cur->val == x)
return cur; //查找成功返回当前结点
cur = cur->next;
}
return NULL; //查找失败返回NULL
}8.在pos结点前插入一个结点
assert(phead&&pos); 这里的意思是避免是空指针的情况
首先，在某结点前插入结点，当在第一个结点前插入结点时，这相当于表头插入结点；当在不是第一个结点前插入结点时，定义一个pre的指针遍历找到pos结点的前一个结点。
代码
//在pos结点前插入一个结点
void SListInsert(SLNode** pphead, SLNode* pos, SLNDataType x)
{
//避免指针为空
assert(pphead);
assert(*pphead);
assert(pos);
if (*pphead == pos)
{
SListPushFront(pphead,x);
return;
}
SLNode* newnode = CreateNode(x);
SLNode* pre = *pphead; //定义一个指向第一个结点的指针
while (pre->next != pos)
{
assert(pre);//避免空指针
pre = pre->next;
}
pre->next = newnode;
newnode->next = pos;
}图解
注意更改顺序
上述说的是在有头指针的情况下进行在pos结点前插入一个结点。
题目变形
当在没有给头指针的情况下，在pos的结点前如何插入一个结点？
解析：这里给出一个取巧的方法，即，先在pos后面插入结点，然后再把pos的值和新插入结点的值交换一下。这样就完成了在没有头指针的情况下在pos前插入一个结点。
代码
//在pos结点前插入一个结点
void SListInsert(SLNode* pos, SLNDataType x)
{
//避免指针为空
assert(pos);
SLNode* newnode = CreateNode(x);
//先在pos后插入结点
newnode->next = pos->next;
pos->next = newnode;
//交换两个结点的值
SLNDataType tmp = pos->val;
pos->val = newnode->val;
newnode->val = tmp;
}图解
9.在pos结点后插入一个结点
这里定义一个指针next用于记录pos后面结点的地址，pos指向newnode, newnode指向next。
代码
//在pos结点后插入结点
void SListInsertAfter(SLNode* pos, SLNDataType x)
{
assert(pos);
SLNode* next = pos->next; //先记录pos后面的结点
SLNode* newnode = CreateNode(x);
pos->next = newnode;
newnode->next = next;
}
也可以这样写,注意顺序，避免指向自己。
代码
//在pos结点后插入结点
void SListInsertAfter(SLNode* pos, SLNDataType x)
{
assert(pos);
SLNode* newnode = CreateNode(x);
newnode->next = pos->next;
pos->next = newnode;
}10.删除结点
例：删除结点pos, 在只有一个结点中删除结点，在多个结点中删除结点。
在只有一个结点中删除，那就相当于头删结点。
在多个结点中删除结点，那就需要知道被删除结点的前一个结点。这里采用双指针的思想进行删除结点。pre指针负责记录pos的前一个结点，next指针记录pos后面的结点。这样释放pos结点后，pre指向next，就完成了pos结点的删除。
代码
//删除结点pos
void SListErase(SLNode** pphead, SLNode* pos)
{
assert(pphead);
assert(pos);
assert(*pphead);
//pos为第一个结点且是第一个结点
if (*pphead == pos)
{
//相当于头删结点
SListPopFront(pphead);
}
else
{
//在多个结点中删除结点pos
SLNode* pre = *pphead;
SLNode* next = pos->next;
while (pre->next != pos)
{
pre = pre->next;
}
free(pos);
pos = NULL;
pre->next = next;
}
}图解
11.删除pos后面的结点
首先断言一下，避免头指针和pos后面的结点为空。（assert(phead && pos->next);）
代码
//删除pos之后的一个结点
void SListEraseAfter(SLNode* pos)
{
assert(pos);
assert(pos->next); //避免为空指针
//先使用next记录pos后面的结点
SLNode* next = pos->next->next;
free(pos->next);
pos->next = next;
}图解
12.修改链表结点的值
代码
//修个pos结点中的值
void SListModify(SLNode* phead, SLNode* pos, SLNDataType x)
{
assert(phead&&pos); //避免为空指针
SLNode* cur = phead; //cur指向头指针
while(cur != pos)
{
cur = cur->next;
}
cur->val = x; //修个值
}13.打印链表
代码
//打印结点
void SListPrint(SLNode* phead)
{
SLNode* cur = phead;
while (cur)
{
printf("%d->",cur->val);
cur = cur->next;
}
printf("NULL\n");
}14.销毁链表
这里因为是使用mallco开辟的空间，所以是需要进行手动释放的。
注意：可能是多个结点，也就是开辟了多个不连续内存空间，
所以，首先应该记录被释放结点的下一个结点的地址，避免释放后找不到下一个结点
释放完所有的结点,头指针置为NULL
代码
//销毁链表
void SListDestory(SLNode** pphead)
{
assert(pphead);
SLNode* p = *pphead;
//注意结点的内存空间的释放，要释放多个
while (p)
{
//首先应该记录被释放结点的下一个结点的地址，避免释放后找不到下一个结点
SLNode* tmp = p->next;
free(p);
p = tmp; //指向下一个结点
}
//释放完所有的结点,头指针置为NULL
*pphead = NULL;
}总结：
单链表在找出位置的指针后，插入和删除时间复杂度为O(1),
但在查找方面上，单链表的时间复杂度为O(n),
当线性表中的元素个数变化较大或者根本不知道有多大时，最好用单链表结构。
2062
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
