前言
`
链表
1.不带头单向链表概览
以下为头文件“SList.h”的内容
#pragma once
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef int SLTDataType;
typedef struct SListNode
{
SLTDataType data;
struct SListNode* next;
}SListNode;
// 动态申请一个节点
SListNode* BuySListNode(SLTDataType x);
// 单链表打印
void SListPrint(SListNode* plist);
// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDataType x);
// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDataType x);
// 单链表的尾删
void SListPopBack(SListNode** pplist);
// 单链表头删
void SListPopFront(SListNode** pplist);
// 单链表查找
SListNode* SListFind(SListNode* plist, SLTDataType x);
// 单链表在pos位置之后插入x
// 分析思考为什么不在pos位置之前插入？
void SListInsertAfter(SListNode* pos, SLTDataType x);
// 单链表删除pos位置之后的值
// 分析思考为什么不删除pos位置？
void SListEraseAfter(SListNode* pos);
// 单链表的销毁
void SListDestroy(SListNode* plist);
2.李姐
我们讲的“单链表“一般指的是不带“哨兵结点/头结点”的单向链表，没有特别强调的话大概就长下面这样：
我们把从左向右的3个结点依次称为L1、L2、L3；d1、d2、d3是结点中存储的数据
虽然大家讲链表的时候都喜欢用这张图，但对指针理解不到位的时候可能把自己搞糊涂，图中每两个紧紧挨在一起的小方块就是结点，每个节点在我们的头文件中是这样定义的：
typedef struct SListNode
{
SLTDataType data;//结点存储的数据
struct SListNode* next;//下一个节点
}SListNode;
由于结构体传参的时候需要传结构体的地址，所以向栈区动态申请一个节点要像下面这样写：
SListNode* BuySListNode(SLTDataType x)
{
SListNode* plist = (SListNode*)malloc(sizeof(SListNode));
if (plist==NULL)
{
perror("BuySListNode:malloc");
exit(-1);
}
plist->data = x;
plist->next = NULL;
return plist;
}
因此，示意图里画在结点之间的箭头只是起到一个指示的作用，
L1结点的成员next，也就是L1->next，表示的就是L2这个节点；
也就是说示意图我还可以这样画：
3.函数详解
“头插”即新创建一个节点，将它置于链表的开头，结构相当简单，代码如下：
void SListPushFront(SListNode** pplist, SLTDataType x)
{
SListNode* tmp = BuySListNode(x);
tmp->next = *pplist;
*pplist = tmp;
}
“头删”函数难度也不高，把链表的起点向后移动一位，再将原来的结点释放即可，如果删除之后一个结点也不剩了，我们就把*pplist置空；
函数开头也要加一个断言，收到NULL的时候就不要再删除了
void SListPopFront(SListNode** pplist)
{
assert(*pplist);
SListNode* cur = *pplist;
if (cur->next)
{
cur = *pplist;
(*pplist) = (*pplist)->next;
cur->next = NULL;
free(cur);
cur = NULL;
}
else
{
free(cur);
*pplist = NULL;
}
}
由于在这两个函数中我们需要改变链表起始结点，起始结点又是个一级指针，所以我们传的参数必须要是一个二级指针，这一点在其他需要改变起始结点的函数中同样适用，细心的读者应该在前文“概览”的部分就注意到了
函数中用**pplist表示一级指针的地址，*pplist即为起始结点
我们写的申请节点的函数BuySListNode默认把结点的next指向NULL，
所以尾插结点的函数就不用再重复一遍置空的动作了，难受的地方是还需要把传空指针的情况考虑进来，这时需要把起始结点*pplist的值修改为申请到的新节点：
因此这里也要用二级指针：
// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDataType x)
{
if (*pplist)
{
SListNode* tmp = BuySListNode(x), * cur = *pplist;
while (cur->next)
{
cur = cur->next;
}
cur->next = tmp;
}
else
{
*pplist = BuySListNode(x);
}
}
// 单链表的尾删
void SListPopBack(SListNode** pplist)
{
assert(*pplist != NULL);
SListNode* cur = *pplist, * prev = cur;
if(cur->next)
{
while (cur->next)
{
prev = cur;
cur = cur->next;
}
free(cur);
cur = NULL;
prev->next = NULL;
}
else
{
free(cur);
cur = NULL;
*pplist = NULL;
}
}
然后我们假设所有节点存储的数据各不相同，把这一点作为判断依据写出查找函数：
// 单链表查找
SListNode* SListFind(SListNode* phead, SLTDataType x)
{
SListNode* cur = phead;
while (cur)
{
if (cur->data == x)
{
return cur;
}
cur = cur->next;
}
return NULL;
}
有了上面的查找函数以后，写一些在特定位置插入节点和删除结点的函数就容易一点了；其中，Insert函数我们选择在查找到的结点之后插入新结点：
// 单链表在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDataType x)
{
assert(pos);
SListNode* cur = pos->next;
SListNode* tmp = BuySListNode(x);
pos->next = tmp;
tmp->next = cur;
}
这么做的原因还是因为在pos位置前插入新结点太麻烦了：
如果我真的要在pos位置之前插入结点，我必须重新遍历链表找出*pos的前一个结点，因此我要把SListInsertAfter改写，什么时候“(cur->next->data==x)”，什么时候就找到了
或者创建新变量prev，把cur变成cur->next之前的值存储起来，一切照旧，上面的写法当遇到指向NULL的结点前还得再来一个分支
但是这个语句对起始结点不适用，所以又得再写一个if else；
这还不算完，这种情况下的SListInsertAfter函数也要根据“pos是否为头结点”来判断“是否需要修改起始结点的值”--------没必要钻牛角尖折磨自己
所以我们的插入和删除函数都选择在*pos之后操作：
// 单链表在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDataType x)
{
assert(pos);
SListNode* cur = pos->next;
SListNode* tmp = BuySListNode(x);
pos->next = tmp;
tmp->next = cur;
}
// 单链表删除pos位置之后的值
void SListEraseAfter(SListNode* pos)
{
assert(pos);
if (pos->next == NULL)
{
return;
}
SListNode* cur = pos->next;
pos->next = pos->next->next;
free(cur);
cur = NULL;
}
然后是用来打印的函数：
// 单链表打印
void SListPrint(SListNode* plist)
{
SListNode* cur = plist;
if (plist == NULL)
{
printf("[]\n");
exit(0);
}
while (cur)
{
printf("%d->", cur->data);
cur = cur->next;
}
printf("\n");
}
最后打印一个回车是因为我想让每次打印的结果空出一行，这次的链表不像以前那样先写框架和菜单，而是把测试用例写成函数的形式，写完一个函数调试一下，会方便很多，我捋完一遍以后是这个结果：
#define _CRT_SECURE_NO_WARNINGS 1
#include "SList.h"
void test1(SListNode** pplist)//测试头插
{
SListPushFront(pplist, 1);
SListPrint(*pplist);
SListPushFront(pplist, 2);
SListPrint(*pplist);
SListPushFront(pplist, 3);
SListPrint(*pplist);
SListPushFront(pplist, 4);
SListPrint(*pplist);
SListPushFront(pplist, 5);
SListPrint(*pplist);
SListDestroy(pplist);
}
void test2(SListNode** pplist)//测试头删
{
SListPushBack(pplist, 1);
SListPrint(*pplist);
SListPushBack(pplist, 2);
SListPrint(*pplist);
SListPushBack(pplist, 3);
SListPrint(*pplist);
SListPushBack(pplist, 4);
SListPrint(*pplist);
SListPushBack(pplist, 5);
SListPrint(*pplist);
SListDestroy(pplist);
}
void test3(SListNode** pplist)//测试尾删
{
SListPushBack(pplist, 1);
SListPushBack(pplist, 2);
SListPushBack(pplist, 3);
SListPushBack(pplist, 4);
SListPushBack(pplist, 5);
SListPrint(*pplist);
SListPopBack(pplist);
SListPrint(*pplist);
SListPopBack(pplist);
SListPrint(*pplist);
SListPopBack(pplist);
SListPrint(*pplist);
SListPopBack(pplist);
SListPrint(*pplist);
SListPopBack(pplist);
SListPrint(*pplist);//已经assert*pplist不能为空指针
SListDestroy(pplist);
}
void test4(SListNode** pplist)//测试尾插
{
SListPushBack(pplist, 1);
SListPushBack(pplist, 2);
SListPushBack(pplist, 3);
SListPushBack(pplist, 4);
SListPushBack(pplist, 5);
SListPrint(*pplist);
SListPopFront(pplist);
SListPrint(*pplist);
SListPopFront(pplist);
SListPrint(*pplist);
SListPopFront(pplist);
SListPrint(*pplist);
SListPopFront(pplist);
SListPrint(*pplist);
SListPopFront(pplist);
SListPrint(*pplist);//已经assert*pplist不能为空指针
SListDestroy(pplist);
}
int main()
{
SListNode* plist = NULL;
test2(&plist);
printf("\n");
test1(&plist);
printf("\n");
test3(&plist);
printf("\n");
test4(&plist);
return 0;
}
最后是单链表的销毁，这里注意每个节点都必须一个一个的用free()释放，即使释放了起始结点，后面的结点也不会跟着一起释放，必须依次释放才行：
// 单链表的销毁
void SListDestroy(SListNode** pplist)
{
SListNode* cur = *pplist;
while (cur)
{
SListNode* next = cur->next;
free(cur);
cur = next;
}
*pplist = NULL;
}
4.“哨兵结点”以及其他细节
在这之前我的用词非常小心，把之前那些第一个结点就存储数据的结点简称为“起始结点”，我们讲的“哨兵节点”则是不存储数据的结点，这篇文章里我们把“哨兵结点”简称为“头结点”，头结点之后的结点才存储数据，这样的链表把它称作“带头链表”
在一些特定情况下用这样的“带头链表”比一般的链表要简单一些，毕竟一些空指针的情况就不用考虑了，我的语言有些无力，牛客网的这道题是个例子：
5.带头双向循环链表
到这里我们可以的发现，虽然大部分函数的思路很容易理清，但实际把单链表用起来的时候需要考虑一些特殊情况，用起来很不舒服，大概可以总结为以下几点：
（1）需要用循环语句才能找到尾结点
（2）不得不考虑参数为NULL时的情况
（3）由于链表是单向的，如果我已知某个位置，却想对这个位置之前的节点进行操 作，那么步骤会非常麻烦
下面的带头双向循环链表将会解决上述所有痛点，虽然听起来很麻烦，但是自己写起来还是很流畅的
下面是示意图：
(1)概览
#pragma once
//带头双向循环链表增删查改
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef int LTDataType;
typedef struct ListNode
{
LTDataType data;
struct ListNode* next;
struct ListNode* prev;
}ListNode;
ListNode* ListCreate();//创建头结点
void ListPushBack(ListNode* phead, LTDataType x);//尾插
void ListPopBack(ListNode* phead);//尾删
void ListPrint(ListNode* phead);//打印链表内容
void ListDestory(ListNode* phead);//链表的销毁
void ListPushFront(ListNode* phead, LTDataType x);//头插
void ListPopFront(ListNode* phead);//头删
ListNode* ListFind(ListNode* phead, LTDataType x);//查找
void ListErase(ListNode* pos);//删除pos位置的结点
void ListInsertBefore(ListNode* pos, LTDataType x);//在pos位置前插入数据x
(2)函数
带头双向链表的初始化很有意思，我们要让phead->next和phead->prev全部指向phead本身，让初始状态下“链表”还是循环的状态
ListNode* ListCreate()
{
ListNode* phead = (ListNode *)malloc(sizeof(ListNode));
assert(phead);
phead->next = phead;
phead->prev = phead;
return phead;
}
这样的话，无论何时链表都是循环的，如果你想要增加或者删除一个M结点，M都存在“指向M的结点”和“M指向的结点”：
如果你想删除M，那么把“指向M的结点”和“M指向的结点”相连接，再把M释放即可；
如果你想在M左右插入一个新结点N，也只需保存好“理应指向N的结点”和“N理应指向的结点”，再把N与它们相互连接即可，下面是函数代码：
ListNode* ListCreate()
{
ListNode* phead = (ListNode *)malloc(sizeof(ListNode));
assert(phead);
phead->next = phead;
phead->prev = phead;
return phead;
}
void ListPushBack(ListNode* phead, LTDataType x)
{
assert(phead);
ListNode* tmp = (ListNode*)malloc(sizeof(ListNode));
ListNode* tail = phead->prev;
tmp->data = x;
//其他增删函数的结构和下面这4条语句的思想都差不多
tail->next = tmp;
tmp->prev = tail;
tmp->next = phead;
phead->prev = tmp;
//
}
void ListPrint(ListNode* phead)
{
assert(phead);
assert(phead->next != phead);
ListNode* p = phead->next;
while (p != phead)
{
printf("%d ", p->data);
p = p->next;
}
printf("\n");
}
void ListDestory(ListNode* phead)
{
assert(phead);
ListNode* p = phead->next;
ListNode* tmp;
while (p != phead)
{
tmp = p->next;
free(p);
p = tmp;
}
free(phead);
}
void ListPopBack(ListNode* phead)
{
assert(phead);
assert(phead->next != phead);
ListNode* tail = phead->prev;
ListNode* tprev = tail->prev;
tprev->next = phead;
phead->prev = tprev;
free(tail);
}
void ListPushFront(ListNode* phead, LTDataType x)
{
ListNode* pnext = phead->next;
ListNode* tmp = (ListNode*)malloc(sizeof(ListNode));
tmp->data = x;
tmp->next = pnext;
pnext->prev = tmp;
phead->next = tmp;
tmp->prev = phead;
}
void ListPopFront(ListNode* phead)
{
assert(phead);
assert(phead->next != phead);
ListNode* pnext = phead->next;
ListNode* p = pnext->next;
phead->next = p;
p->prev = phead;
free(pnext);
}
ListNode* ListFind(ListNode* phead, LTDataType x)
{
assert(phead);
assert(phead->next!=phead);
ListNode* cur = phead->next;
while (cur != phead)
{
if (cur->data == x)
return cur;
cur = cur->next;
}
return NULL;
}
void ListErase(ListNode* pos)
{
ListNode* first = pos->prev;
ListNode* second = pos->next;
first->next = second;
second->prev = first;
free(pos);
}
void ListInsertBefore(ListNode* pos, LTDataType x)
{
ListNode* first, * second;
first = pos->prev;
second = pos;
ListNode* m = (ListNode*)malloc(sizeof(ListNode));
m->data = x;
first->next = m;
m->prev = first;
m->next = second;
second->prev = m;
}
增删的规则放在起始结点身上同样适用，所以代码看起来要比不带头的单向链表“整齐”很多，不需要套if else语句
总结
感谢支持！
186
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
