1. 链表的概念及结构
概念：链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表
中的指针链接次序实现的 。
链表的结构跟⽕⻋⻋厢相似，淡季时⻋次的⻋厢会相应减少，旺季时⻋次的⻋厢会额外增加⼏节。只需要将⽕⻋⾥的某节⻋厢去掉/加上，不会影响其他⻋厢，每节⻋厢都是独⽴存在的。
⻋厢是独⽴存在的，且每节⻋厢
都有⻋⻔。在链表⾥，的结构如下所示：
与顺序表不同的是，链表⾥的每节"⻋厢"都是独⽴申请下来的空间，我们称之为“结点/节点”
节点的组成主要有两个部分：当前节点要保存的数据和保存下⼀个节点的地址（指针变量）。
图中指针变量 plist保存的是第⼀个节点的地址，我们称plist此时“指向”第⼀个节点，如果我们希望plist“指向”第⼆个节点时，只需要修改plist保存的内容为0x0012FFA0。
为什么还需要指针变量来保存下⼀个节点的位置？
链表中每个节点都是独⽴申请的（即需要插⼊数据时才去申请⼀块节点的空间），我们需要通过指针变量来保存下⼀个节点位置才能从当前节点找到下⼀个节点。
结合结构体知识，我们可以给出每个节点对应的结构体代码：
假设当前保存的节点为整型：
struct SListNode
{
int data; //节点数据
struct SListNode* next; //指针变量⽤保存下⼀个节点的地址
};
当我们想要保存⼀个整型数据时，实际是向操作系统申请了⼀块内存，这个内存不仅要保存整型数据，也需要保存下⼀个节点的地址（当下⼀个节点为空时保存的地址为空）。
当我们想要从第⼀个节点⾛到最后⼀个节点时，只需要在前⼀个节点拿上下⼀个节点的地址（下⼀个节点的钥匙）就可以了。
给定的链表结构中，如何实现节点从头到尾的打印？
另：当我们想保存的数据类型为字符型、浮点型或者其他⾃定义的类型时，该如何修改？一般我们在定义时会对链表的类型进行重命名，当我们想修改数据类型时，只需修改命名行即可。
补充说明：
1、链式机构在逻辑上是连续的，在物理结构上不⼀定连续
2、节点⼀般是从堆上申请的
3、从堆上申请来的空间，是按照⼀定策略分配出来的，每次申请的空间可能连续，可能不连续
2. 单链表的实现
先对单链表的功能进行声明：
#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include "student.h"
typedef student SLTDataType;
struct SListnode
{
SLTDataType date;
struct SListnode* next;
};
typedef struct SListnode SLTNode;
//单链表打印
void int_SLTPrint(SLTNode* phead);
//申请空间存储数据
SLTNode* SLTBuyNode(SLTDataType x);
//尾插
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);因为多次要申请节点，故申请节点另立为一个函数
SLTNode* SLTBuyNode(SLTDataType x)
{
SLTNode* newSListnode = (SLTNode*)malloc(sizeof(SLTNode));
assert(newSListnode != NULL);
newSListnode->date = x;
newSListnode->next = NULL;
return newSListnode;
}//头部插尾部插⼊
//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
assert(pphead != NULL);
SLTNode* newnode=SLTBuyNode(x);
if (*pphead == NULL)
{
*pphead = newnode;
}
else
{
//找尾
SLTNode* ptail = *pphead;
while (ptail->next !=NULL)
{
ptail = ptail->next;
}
ptail->next = newnode;
}
}
//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
assert(pphead != NULL);
SLTNode* newnode = SLTBuyNode(x);
newnode->next = *pphead;
*pphead = newnode;
}//头删尾删
//尾删
void SLTPopBack(SLTNode** pphead)
{
assert(pphead != NULL && *pphead!=NULL);
if ((*pphead)->next == NULL) //-> 优先级高于*
{
free(*pphead);
*pphead = NULL;
}
else
{
//找尾
SLTNode* ptail = *pphead;
while (ptail->next->next != NULL)
{
ptail = ptail->next;
}
free(ptail->next);
ptail->next = NULL;
}
}
//头删
void SLTPopFront(SLTNode** pphead)
{
assert(pphead != NULL && *pphead != NULL);
SLTNode* next = (*pphead)->next;
free(*pphead);
*pphead = next;
}//查找
//查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
SLTNode* pcur = phead;
while (pcur != NULL)
{
if (pcur->date == x)
{
return pcur;
}
pcur = pcur->next;
}
return NULL;
}//删除pos节点
//删除pos节点
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
assert(pphead && *pphead);
assert(pos);
if (pos == *pphead)
{
SLTPopFront(pphead);
}
else
{
SLTNode* prev = *pphead;
while (prev->next != pos)
{
prev = prev->next;
}
prev->next = pos->next;
free(pos);
pos = NULL;
}
}//在指定位置之后插⼊数据
//在指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
assert(pos);
SLTNode* newnode = SLTBuyNode(x);
newnode->next = pos->next;
pos->next = newnode;
}//删除pos之后的节点
//删除pos之后的节点
void SLTEraseAfter(SLTNode* pos)
{
assert(pos && pos->next);
pos->next = pos->next->next;
free(pos->next);
pos->next = NULL;
}
//销毁链表
//销毁链表
void SListDesTroy(SLTNode** pphead)
{
assert(pphead && *pphead);
SLTNode* pcur = *pphead;
while (pcur)
{
SLTNode* next = pcur->next;
free(pcur);
pcur = NULL;
pcur = next;
}
*pphead = NULL;
}3. 链表的分类
链表的结构⾮常多样，以下情况组合起来就有8种（2 x 2 x 2）链表结构：
虽然有这么多的链表的结构，但是我们实际中最常⽤还是两种结构： 单链表 和 双向带头循环链表
1. ⽆头单向⾮循环链表：结构简单，⼀般不会单独⽤来存数据。实际中更多是作为其他数据结
构的⼦结构，如哈希桶、图的邻接表等等。另外这种结构在笔试⾯试中出现很多。
2. 带头双向循环链表：结构最复杂，⼀般⽤在单独存储数据。实际中使⽤的链表数据结构，都
是带头双向循环链表。另外这个结构虽然结构复杂，但是使⽤代码实现以后会发现结构会带
来很多优势，实现反⽽简单了，后⾯我们代码实现了就知道了
4. 双向链表的结构
5. 双向链表的实现
在实现之剪先对双问链表的功能和定义进行声明：
#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
typedef int LTDataType;
typedef struct ListNode
{
LTDataType data;
struct ListNode* next;
struct ListNode* prev;
}LTNode;
LTNode* LTBuyNode(LTDataType x);
//
void LTDestroy(LTNode* phead);
//打印
void LTPrint(LTNode* phead);
bool LTEmpty(LTNode* phead);
//尾插
void LTPushBack(LTNode* phead, LTDataType x);
//尾删
void LTPopBack(LTNode* phead);
//头插
void LTPushFront(LTNode* phead, LTDataType x);
//头删
void LTPopFront(LTNode* phead);
//查找
LTNode* LTFind(LTNode* phead, LTDataType x);
//在pos位置之后插入数据
void LTInsert(LTNode* pos, LTDataType x);
//删除pos节点
void LTErase(LTNode* pos);申请节点：
注意双向链表申后节点的next和prev指针并不指向空而是指的它本身。
双向链表的初始化也等价于申请一个头结点
//申请节点
LTNode* LTBuyNode(LTDataType x)
{
LTNode* node = (LTNode*)malloc(sizeof(LTNode));
if (node == NULL)
{
perror("malloc fail!");
exit(1);
}
node->data = x;
node->next = node->prev = node;
return node;
}
打印（以要型为例）
用next指针从头结点的下一个结点开始编历，当编历结点又回到头结点的停下来
void LTPrint(LTNode* phead)
{
LTNode* pcur = phead->next;
while (pcur != phead)
{
printf("%d->", pcur->data);
pcur = pcur->next;
}
printf("head\n");
}
尾插和头插
//尾插
void LTPushBack(LTNode* phead, LTDataType x)
{
assert(phead);
LTNode* newnode = LTBuyNode(x);
newnode->next = phead;
newnode->prev = phead->prev;
LTNode* tail = phead->prev;
tail->next = newnode;
phead->prev = newnode;
}
//头插
void LTPushFront(LTNode* phead, LTDataType x)
{
assert(phead);
LTNode* newnode = LTBuyNode(x);
newnode->prev = phead;
newnode->next = phead->next;
LTNode* cur = phead->next;
cur->prev = newnode;
phead->next = newnode;
}尾删和头删
//尾删
void LTPopBack(LTNode* phead)
{
//链表必须有效且链表不能为空（只有一个哨兵位）
assert(phead && phead->next != phead);
LTNode* del = phead->prev;
del->prev->next = phead;
phead->prev = del->prev;
free(del);
del = NULL;
}
//头删
void LTPopFront(LTNode* phead)
{
assert(phead && phead->next != phead);
LTNode* del = phead->next;
del->next->prev = phead;
phead->next = del->next;
free(del);
del = NULL;
}查找
//查找
LTNode* LTFind(LTNode* phead, LTDataType x)
{
LTNode* cur = phead->next;
while (cur != phead)
{
if (cur->data == x)
{
return cur;
}
cur = cur->next;
}
return NULL;
}
指定位置之后插入
//在pos位置之后插入数据
void LTInsert(LTNode* pos, LTDataType x)
{
assert(pos);
LTNode* newnode = LTBuyNode(x);
newnode->prev = pos;
newnode->next = pos->next;
pos->next->prev = newnode;
pos->next = newnode;
}删除指定位置结点
//删除pos节点
void LTErase(LTNode* pos)
{
assert(pos);
LTNode* del = pos;
del->prev->next = del->next;
del->next->prev = del->prev;
free(del);
del = NULL;
}
双向链表的销毁
void LTDesTroy(LTNode* phead)
{
assert(phead);
LTNode* pcur = phead->next;
while (pcur != phead)
{
LTNode* next = pcur->next;
free(pcur);
pcur = next;
}
free(phead);
phead = NULL;
}6. 顺序表和链表的优缺点分析
顺序表和链表是优劣互补的两种结构，
在存储空间上：
顺序表是连续存储，这种存储的优势会有利于计算机系统的缓存提取，有利于加快访问内存的速度。而因为链表是不一定连续（其实基本不连续）反而会造成缓存的污染，缓存命中率低。
在访问上：
顺序表能直接用下标进行访问，访问效率高。而链表只能通过遍历进行访问，访问的速度相对比较慢。
在插入删除数据上：
顺序表因需要对数据进行移动和扩容这两步操作，而链表仅需申请节点即可，故在插入数据这一方面链表具有天然的优势
应用：
它们的优劣势也影响了它们在实际的应用。顺序表多用于元素高效存储和频繁访问数据的场景下。而链表则是应用在需频繁在任意位置插入和删除的场景下。
扫一扫
679
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
