线性表链式存储的特点是：用一组任意的存储单元存储线性表的数据元素（这组存储单元可以是连续的，也可以是不连续的）。
因此，为了表示每个数据元素a(i)与其直接后继数据元素a(i+1)之间的逻辑关系，对于数据元素a(i)来说，除了存储其本身的信息之外，还需要存储一个指示其直接后继的信息（直接后继存储位置）。这两部分组成信息组成元素a(i)的存储映像，称为节点（node）。
它包括两个域：其中存储数据元素信息的域称为数据域；存储直接后继存储位置的域称为指针域。
指针域中的存储信息称为指针或链。
链表节点的逻辑结构：
线性表的链式表示与实现
1. 链表的概念及结构
概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。
举个栗子:
链表的结构就像火车的结构是一节一节的。不同于火车的是，链表它在物理存储结构上不是连续存储的，而是通过指针链接次序实现的 。
单链表的逻辑结构：
2.链表的分类
实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：
- 单向或者双向
- 带头或者不带头
- 循环或者非循环
以上3大类可以组合成：
（1）不带头单向不循环链表
（2）不带头双向不循环链表
（3）不带头单向循环链表
（4）不带头双向循环链表
（5）带头单向不循环链表
（6）带头双向不循环链表
（7）带头单向循环链表
（8）带头双向循环链表
虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：
2.1 无头单向非循环链表
无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。
2.2 带头双向循环链表
带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了，后面我们代码实现了就知道了。
3.无头单向非循环链表的实现
3.1 链表需要实现的接口
// 1、无头+单向+非循环链表增删查改实现
typedef int SLTDateType;
typedef struct SListNode
{
SLTDateType data;
struct SListNode* next;
}SListNode;
// 动态申请一个结点
SListNode* BuySListNode(SLTDateType x);
// 单链表打印
void SListPrint(SListNode* plist);
//创建单链表
SListNode* CreateSListNode(SLTDateType x);
// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x);
// 单链表的尾删
void SListPopBack(SListNode** pplist);
// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x);
// 单链表头删
void SListPopFront(SListNode** pplist);
// 单链表查找
SListNode* SListFind(const SListNode* pplist, SLTDateType x);
// 单链表在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDateType x);
// 单链表删除pos位置之后的值
void SListEraseAfter(SListNode* pos);
//单链表的销毁
void SListDestroy(SListNode* plist);
3.2 链表接口的具体实现
3.2.1 动态申请一个结点
SListNode* BuySListNode(SLTDateType x);
【算法步骤】
1.动态开辟一个新的节点。用指针newnode指向开辟的节点。
2.判断内存开辟是否成功，不成功的话，则结束程序。
3.新节点的数据域赋值为x。
4.新节点的指针域置NULL。
5.返回新节点的地址。
【算法实现】
SListNode* BuySListNode(SLTDateType x)
{
SListNode* newnode = (SListNode*)malloc(sizeof(SListNode));
if (!newnode)
{
perror("malloc fail\n");
exit(-1);
}
newnode->data = x;
newnode->next = NULL;
return newnode;
}
3.2.2 单链表的打印
void SListPrint(SListNode* plist);
【算法步骤】
1.判断头结点的地址是否为空，为空的的话，程序停止，这里我选择的是暴力的处理方式，当然你也可以选择温柔的方式，打印错误的原因，不直接停止程序。
2.定义一个指针cur，让他向后遍历。
3.如果指针cur不为空，就打印该节点的数据域。
4.指针cur再指向下一个节点，直到指针cur为空。
【算法实现】
void SListPrint(SListNode* plist)
{
assert(plist);
SListNode* cur = plist;
while (cur)
{
printf("%d->", cur->data);
cur = cur->next;
}
printf("NULL\n");
}
3.2.3 创建单链表
SListNode* CreateSListNode(SLTDateType x);
【算法步骤】
1.创建两个指针phead和指针ptail，指针phead用于指向创建的链表的头结点，指针ptail用于指向新建链表的尾节点。
2.循环生成n个节点。需要注意的是，第一次生成节点时，要将新建的节点地址赋给指针phead,不然当整个链表创建完的时候，就找不到头结点了，造成内存泄露，并且，没有完成我们需要的功能。
3.链表创建完成，将头结点的地址返回。
【算法实现】
SListNode* CreateSListNode(int n)
{
SListNode* phead = NULL,*ptail = NULL;
for (int i = 0;i < n;i++)
{
SListNode* newnode = BuySListNode(i);
if (phead == NULL)
{
ptail = phead = newnode;
}
else
{
ptail->next = newnode;
ptail = newnode;
}
}
return phead;
}
3.2.4 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x);
【算法步骤】
1.生成一个新节点，用指针newnode指向该节点。
2.需要判断头指针是否为空，分类处理，这里是允许头指针为空的，不需要停止程序，头指针为空说明链表为空。
3.头指针为空：指向将新节点的地址赋给头指针。
4.头指针不为空：定义一个指针cur从头指针开始向后遍历，找到链表的尾，将新节点插入到尾节点后面。
【算法实现】
void SListPushBack(SListNode** pplist, SLTDateType x)
{
SListNode* newnode = BuySListNode(x);
if (*pplist == NULL)
{
*pplist = newnode;
}
else
{
SListNode* cur = *pplist;
//找尾
while (cur->next)
{
cur = cur->next;
}
cur->next = newnode;
}
}
3.2.5 单链表的尾删
void SListPopBack(SListNode** pplist);
【算法步骤】
1.先判断头指针是否为空，为空则直接退出程序，此处头指针为空的情况不允许存在，因为头指针为空，说明链表为空，此时不能尾删。
2.但是我们需要判断一下链表是否只有一个节点，如果只有一个节点的话，直接将头指针释放，并且头指针置空。
3.如果链表不止一个节点，定义两个指针tail和指针prev,指针tail从头指针向后遍历找到链表的尾节点，指针prev则在指针tail向后遍历之前先记录一下指针tail指向的节点，方便我们进行尾删。
4.将指针tail释放，将prev的指针域置空。
【算法实现】
void SListPopBack(SListNode** pplist)
{
assert(*pplist);
if ((*pplist)->next == NULL)
{
free(*pplist);
pplist = NULL;
}
else
{
SListNode* tail = *pplist,*prev = *pplist;
while (tail->next)
{
prev = tail;
tail = tail->next;
}
free(tail);
prev->next = NULL;
}
}
3.2.6 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x);
【算法步骤】
1.此时我们不需要判断头节点是否为空，大家可以考虑一下为什么。
2.生成一个新的节点，用指针newnode指向新节点。
3.指针newnode的指针域指向头结点。
4.将指针newnode的地址赋给头指针。
【算法实现】
void SListPushFront(SListNode** pplist, SLTDateType x)
{
SListNode* newnode = BuySListNode(x);
newnode->next = *pplist;
*pplist = newnode;
}
3.2.7 单链表头删
void SListPopFront(SListNode** pplist);
【算法步骤】
1.首先我们需要判断一下头节点是否为空，为空则停止程序。
2.定义一个指针cur指向头结点的下一个节点。
3.将头结点释放。
4.将指针cur的地址赋给头指针。
【算法实现】
void SListPopFront(SListNode** pplist)
{
assert(*pplist);
SListNode* cur = (*pplist)->next;
free(*pplist);
*pplist = cur;
}
3.2.8 单链表查找
SListNode* SListFind(const SListNode* pplist, SLTDateType x);
【算法步骤】
1.判断头节点是否为空。为空则停止程序。
2.定义一个指针cur指向头结点。
3.判断指针cur的数据域是否等于x。
4.找到的话就返回该节点的地址，找到尾结点都找不到的话就返回NULL。
【算法实现】
SListNode* SListFind(const SListNode* plist, SLTDateType x)
{
assert(plist);
SListNode* cur = plist;
while (cur->next != NULL)
{
if (cur->data == x)
return cur;
else
cur = cur->next;
}
return NULL;
}
3.2.9 单链表在pos位置之后插入x节点
void SListInsertAfter(SListNode* pos, SLTDateType x);
【算法步骤】
1.判断指针pos是否为空。为空则停止程序。
2.生成一个新的节点，用指针tmp指向新节点。
3.新节点的指针域先指向pos结点的指针域，再将pos结点的指针域指向新节点。
大家可以考虑一下，可不可以将3的这两步的顺序调换一下，调换之后会发生什么。
大家还可以考虑一下，可不可以在pos位置之前插入x结点。
【算法实现】
void SListInsertAfter(SListNode* pos, SLTDateType x)
{
assert(pos);
SListNode* tmp = BuySListNode(x);
tmp->next = pos->next;
pos->next = tmp;
}
3.2.10 单链表删除pos位置之后的值
void SListEraseAfter(SListNode* pos);
【算法步骤】
1.判断pos结点和pos后面的节点是否为空。
2.定义一个指针cur指向pos节点的指针域。
3.将pos节点的指针域指向下一个节点的指针域。
4.再将指针cur指向的节点释放。
【算法实现】
void SListEraseAfter(SListNode* pos)
{
assert(pos);
assert(pos->next);
SListNode* cur = pos->next;
pos->next = pos->next->next;
free(cur);
}
3.2.11 单链表的销毁
void SListDestroy(SListNode* plist);
【算法步骤】
1.判断头结点是否为空，为空则停止程序。
2.定义一个指针指向头结点的指针域。
3.将头结点释放，再将指针cur的地址给头指针。
4.重复步骤2和步骤3。
【算法实现】
void SListDestroy(SListNode* plist)
{
assert(plist);
while (plist != NULL)
{
SListNode* cur = plist->next;
free(plist);
plist = cur;
}
}
3.3 单链表的原码
4.带头双向循环链表的实现
4.1 链表需要实现的接口
typedef int LTDataType;
typedef struct ListNode
{
struct ListNode* prev;
struct ListNode* next;
LTDataType data;
}LTNode;
//创建一个节点
LTNode* BuyLTNode(LTDataType x);
//双向链表初始化
LTNode* LTNodeInit();
// 双向链表打印
void LTNodePrint(LTNode* plist);
//双向链表的尾插
void LTNodePushBack(LTNode* plist, LTDataType x);
//双向链表的尾删
void LTNodePopBack(LTNode* plist);
//双向链表的头插
void LTNodePushFront(LTNode* plist, LTDataType x);
//双向链表的头删
void LTNodePopFront(LTNode* plist);
// 双向链表查找
LTNode* LTFind(LTNode* plist, LTDataType x);
// 双向链表在pos的前面进行插入
void LTInsert(LTNode* pos, LTDataType x);
// 双向链表删除pos位置的结点
void LTErase(LTNode* pos);
// 双向链表销毁
void LTDestory(LTNode* plist);
4.2 链表接口的具体实现
4.2.1 动态申请一个节点
LTNode* BuyLTNode(LTDataType x);
【算法步骤】
1.动态开辟一个新的节点，用指针newnode指向新生成的节点。
2.如果指针newnode为空，说明生成失败，程序停止。
3.将新节点的数据域赋值为x。
4.将新节点的prev指针和next指针都置空。
5.返回新节点的地址。
【算法实现】
LTNode* BuyLTNode(LTDataType x)
{
LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
if (!newnode)
{
perror("malloc fail\n");
exit(-1);
}
newnode->data = x;
newnode->next = NULL;
newnode->prev = NULL;
return newnode;
}
4.2.2 双向链表初始化
LTNode* LTNodeInit();
【算法步骤】
1.定义一个哨兵节点（头结点）,数据域赋值为-1。
2.哨兵节点的前驱指针和后继指针都置空。
【算法实现】
LTNode* LTNodeInit()
{
LTNode* plist = BuyLTNode(-1);
plist->prev = plist;
plist->next = plist;
return plist;
}
4.2.3 双向链表打印
void LTNodePrint(LTNode* plist);
【算法步骤】
1.判断哨兵节点是否为空，为空则停止程序。
2.定义一个指针cur指向哨兵节点的下一个节点。
3.打印节点cur的数据域，将指针cur指向cur的下一个节点。
4.重复步骤3，直到指针cur为空。
【算法实现】
void LTNodePrint(LTNode* plist)
{
assert(plist);
LTNode* cur = plist->next;
while (cur != plist)
{
printf("%d ", cur->data);
cur = cur->next;
}
printf("\n");
}
4.2.4 双向链表的尾插
void LTNodePushBack(LTNode* plist, LTDataType x);
【算法步骤】
1.判断哨兵节点是否为空，为空则停止程序。
2.生成一个新的节点，用指针newnode指向新节点。
3.定义一个指针tail指向哨兵节点的前驱节点，即为链表的尾结点。
4.将指针tail的后继指针指向新节点。将新节点的前驱指针指向tail节点。
5.将哨兵位的前驱指针指向新节点，将新节点的后继指针指向哨兵节点。
【算法实现】
void LTNodePushBack(LTNode* plist, LTDataType x)
{
assert(plist);
LTNode* newnode = BuyLTNode(x);
LTNode* tail = plist->prev;
tail->next = newnode;
newnode->prev = tail;
plist->prev = newnode;
newnode->next = plist;
}
4.2.5 双向链表的尾删
void LTNodePopBack(LTNode* plist);
【算法步骤】
1.断言哨兵节点和哨兵节点的后继节点不为空。为空则停止程序。
2.定义一个指针cur指向哨兵节点的前驱节点。
3.定义一个指针curprev指向cur节点的前驱节点。
4.将curprev节点的后继指针指向哨兵节点。
5.将哨兵节点的前驱指针指向cureprev节点。
【算法实现】
void LTNodePopBack(LTNode* plist)
{
assert(plist);
assert(plist->next != plist);
LTNode* cur = plist->prev;
LTNode* curprev = cur->prev;
curprev->next = plist;
plist->prev = curprev;
free(cur);
}
4.2.6 双向链表的头插
void LTNodePushFront(LTNode* plist, LTDataType x);
【算法步骤】
1.断言哨兵节点不为空，为空则停止程序。
2.生成一个新的节点，用指针newnode指向新节点。
3.定义一个指针指向哨兵节点的后继节点。
4.将哨兵节点的后继指针指向新节点，新节点的前驱指针指向哨兵节点。
5.将新节点的后继指针指向cur节点，cur节点的前驱指针指向新节点。
【算法实现】
void LTNodePushFront(LTNode* plist, LTDataType x)
{
assert(plist);
LTNode* newnode = BuyLTNode(x);
LTNode* cur = plist->next;
plist->next = newnode;
newnode->prev = plist;
newnode->next = cur;
cur->prev = newnode;
}
4.2.7 双向链表的头删
void LTNodePopFront(LTNode* plist);
【算法步骤】
1.断言哨兵节点和哨兵节点的后继节点不为空，为空则停止程序。
2.定义一个指针cur指向哨兵节点的后继节点。
3.定义一个指针curnext指向cur节点的后继节点。
4.将哨兵节点的后继指针域指向curnext节点，curnext节点的前驱指针域指向哨兵节点。
5.将cur节点释放。
【算法实现】
void LTNodePopFront(LTNode* plist)
{
assert(plist);
assert(plist->next != plist);
LTNode* cur = plist->next;
LTNode* curnext = cur->next;
plist->next = curnext;
curnext->prev = plist;
free(cur);
}
4.2.8 双向链表查找
LTNode* LTFind(LTNode* plist, LTDataType x);
【算法步骤】
1.断言哨兵节点不为空，为空则停止程序。
2.定义一个指针cur指向哨兵节点的后继节点。
3.如果cur的数据域等于x则返回该节点的地址。
4.如果找到哨兵节点还没有找到，就返回NULL。
【算法实现】
LTNode* LTFind(LTNode* plist, LTDataType x)
{
assert(plist);
LTNode* cur = plist->next;
while (cur != plist)
{
if (cur->data == x)
return cur;
cur = cur->next;
}
return NULL;
}
4.2.9 双向链表在pos的前面进行插入
void LTInsert(LTNode* pos, LTDataType x);
【算法步骤】
1.断言pos节点不为空，为空则停止程序。
2.生成一个新的节点，用指针newnode指向新节点。
3.定义一个指针cur指向pos节点的前驱节点。
4.将cur节点的后继指针指向新节点，新节点的前驱节点指向cur节点。
5.将pos节点的前驱指针指向新节点，新节点的后继指针指向pos节点。
【算法实现】
void LTInsert(LTNode* pos, LTDataType x)
{
assert(pos);
LTNode* newnode = BuyLTNode(x);
LTNode* cur = pos->prev;
cur->next = newnode;
newnode->prev = cur;
pos->prev = newnode;
newnode->next = pos;
}
4.2.10 双向链表删除pos位置的结点
void LTErase(LTNode* pos);
【算法步骤】
1.断言pos节点和pos节点不为空。
2.定义一个指针prev指向pos节点的前驱节点。
3.定义一个指针next指向pos节点的后继节点。
4.将prev节点的后继指针指向next节点。
5.将next节点的前驱指针指向prev节点。
6.释放pos节点。
【算法实现】
void LTErase(LTNode* pos)
{
assert(pos);
assert(pos->next != pos);
LTNode* prev = pos->prev;
LTNode* next = pos->next;
prev->next = next;
next->prev = prev;
free(pos);
}
4.2.11 双向链表销毁
void LTDestory(LTNode* plist);
【算法步骤】
1断言哨兵节点不为空。为空则停止程序。
2.定义一个指针cur指向哨兵节点的后继节点。
3.定义一个指针next指向cur节点的后继节点。
4.将cur节点释放，再将next节点的地址赋给指针cur。
5.重复步骤3和步骤4，直到指向哨兵节点。
6.将哨兵节点释放。
【算法实现】
void LTDestory(LTNode* plist)
{
assert(plist);
LTNode* cur = plist->next;
while (cur != plist)
{
LTNode* next = cur->next;
free(cur);
cur = next;
}
free(plist);
}
4.3 带头双向循环链表的原码
结语：
感谢大家看到这里，如有错误，希望各位大佬多多指正！
祝大家心情愉悦！
1015
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
