前言:
- 本篇博客整理了数据结构初阶的链表相关知识,包括单链表、双向循环链表、以及哨兵位的介绍(这里的哨兵位在后面的链表OJ博客中会详细介绍)
- 单链表是作为学习其他高价数据结构的子结构
- 大部分笔试、面试题,以单链表为基础考察
- 代码实现:C语言
1. 链表的结构和概念
概念:链表是一种物理存储结构上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
注意:
- 从上图可以看出,链式结构在逻辑上是连续的,但在物理上不一定连续
- 现实中的结点一般都是从堆上申请出来的
- 从堆上申请的空间,是按照一定的策略来分配的两次申请的空间可能连续,也可能不连续
2. 链表的分类
实际中链表的结构非常多样,以下情况组合起来就有8种链表结构:
- 单向或者双向
- 带头或不带头
- 循环或不循环
虽然有这么多的链表结构,但是我们实际中最常用的还是两种结构:
- 无头单向非循环链表(单链表)
- 带头双向循环链表(最优链表)
注意:
- 无头单向非循环链表:结构简单,一般不会单独用来存数据,实际中更多是作为其他数据结构的子结构,如哈希桶、图的邻接表等等。另外这种结构在笔试面试中会出现很多。
- 带头双向循环链表:结构复杂,一般用来单独存储数据。实际中使用的链表数据结构,都是带头双向循环链表。另外这个结构虽然复杂,但使用代码实现以后会发现该结构会带来很多优势,实现反而简单了,后面我们实现就知道了。
3. 链表的实现
3.1 单链表的实现
单链表有以下接口函数
//无头+单向+非循环链表增删查改实现
typedef int SLTDateType;
typedef struct SListNode
{
SLTDateType date;
struct SListNode* next;
}SLTNode;
// 动态申请一个结点
SLTNode* BuySListNode(SLTDateType x);
// 单链表打印
void SListPrint(SLTNode* phead);
// 单链表尾插
void SListPushBack(SLTNode** pphead, SLTDateType x);
// 单链表的头插
void SListPushFront(SLTNode** pphead, SLTDateType x);
// 单链表的尾删
void SListPopBack(SLTNode** pphead);
// 单链表头删
void SListPopFront(SLTNode** pphead);
// 单链表查找
SLTNode* SListFind(SLTNode* phead, SLTDateType x);
// 单链表在pos位置之后插入x
// 分析思考为什么不在pos位置之前插入?
void SListInsertAfter(SLTNode* pos, SLTDateType x);
// 单链表在pos位置之前插入x
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDateType x);
// 单链表删除pos位置之后的值
// 分析思考为什么不删除pos位置?
void SListEraseAfter(SLTNode* pos);
// 单链表删除pos位置的值
void SListErase(SLTNode** pphead, SLTNode* pos);
3.1.1 动态申请一个结点
SLTNode* BuySListNode(SLTDateType x)
{
SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
assert(newnode);
newnode->date = x;
newnode->next = NULL;
return newnode;
}
3.1.2 单链表打印
void SListPrint(SLTNode* phead)
{
SLTNode* cur = phead;
while (cur != NULL)
{
printf("%d->", cur->date);
cur = cur->next;
}
printf("NULL\n");
}
3.1.3 单链表尾插 O(n)
void SListPushBack(SLTNode** pphead, SLTDateType x)
{
assert(pphead);
SLTNode* newnode = BuySListNode(x);
if (*pphead == NULL)
{
*pphead = newnode;
}
else
{
//找尾结点
SLTNode* tail = *pphead;
while (tail->next != NULL)
{
tail = tail->next;
}
tail->next = newnode;
}
}
3.1.4 单链表头插 O(1)
void SListPushFront(SLTNode** pphead, SLTDateType x)
{
assert(pphead);
SLTNode* newnode = BuySListNode(x);
newnode->next = *pphead;
*pphead = newnode;
}
3.1.5 单链表的尾删 O(n)
void SListPopBack(SLTNode** pphead)
{
assert(pphead);
assert(*pphead);
//只有一个结点
if ((*pphead)->next == NULL)
{
free(*pphead);
*pphead = NULL;
}
else
{
//有多个结点
//SLTNode* tailPrev = NULL;
//SLTNode* tail = *pphead;
//while (tail->next != NULL)
//{
// tailPrev = tail;
// tail = tail->next;
//}
//free(tail);
//tailPrev->next = NULL;
SLTNode* tail = *pphead;
while (tail->next->next != NULL)
{
tail = tail->next;
}
free(tail->next);
tail->next = NULL;
}
}
3.1.6 单链表头删 O(1)
void SListPopFront(SLTNode** pphead)
{
assert(pphead);
assert(*pphead != NULL);
//if (*pphead == NULL)
//{
// return;
//}
SLTNode* next = (*pphead)->next;
free(*pphead);
*pphead = next;
}
3.1.7 单链表查找
SLTNode* SListFind(SLTNode* phead, SLTDateType x)
{
SLTNode* cur = phead;
while (cur)
{
if (cur->date == x)
{
return cur;
}
cur = cur->next;
}
return NULL;
}
3.1.8 单链表在pos位置之后插入x O(1)
void SListInsertAfter(SLTNode* pos, SLTDateType x)
{
assert(pos);
SLTNode* newnode = BuySListNode(x);
newnode->next = pos->next;//注意链接顺序
pos->next = newnode;
}
3.1.9 单链表在pos位置之前插入x O(n)
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDateType x)
{
assert(pphead);
assert(pos);
//头插
if (pos == *pphead)
{
SListPushFront(pphead, x);
}
else
{
SLTNode* prev = *pphead;
while (prev->next != pos)
{
prev = prev->next;
}
SLTNode* newnode = BuySListNode(x);
prev->next = newnode;
newnode->next = pos;
}
}
3.1.10 单链表删除pos位置之后的值 O(1)
void SListEraseAfter(SLTNode* pos)
{
assert(pos);
if (pos->next == NULL)
return;
SLTNode* del = pos->next;
//pos->next = pos->next->next;
pos->next = del->next;
free(del);
del = NULL;
}
3.1.11 单链表删除pos位置的值 O(n)
void SListErase(SLTNode** pphead, SLTNode* pos)
{
assert(pphead);
assert(pos);
//头删
if (*pphead == pos)
{
SListPopFront(pphead);
}
else
{
SLTNode* prev = *pphead;
while (prev->next != pos)
{
prev = prev->next;
}
prev->next = pos->next;
free(pos);
pos = NULL;
}
}
3.2 带头双向循环链表的实现
带头双向循环链表有以下接口函数
// 带头+双向+循环链表增删查改实现
typedef int LTDateType;
typedef struct ListNode
{
struct ListNode* next;
struct ListNode* prev;
LTDateType date;
}LTNode;
//创建一个结点
LTNode* BuyListNode(LTDateType x);
//初始化 创建返回链表的头结点
//void ListInit(LTNode** phead);
LTNode* ListInit();
// 双向链表尾插
void ListPushBack(LTNode* phead, LTDateType x);
// 双向链表打印
void ListPrint(LTNode* phead);
// 双向链表头插
void ListPushFront(LTNode* phead, LTDateType x);
// 双向链表尾删
void ListPopBack(LTNode* phead);
// 双向链表头删
void ListPopFront(LTNode* phead);
//判断只否只剩下哨兵位
bool ListEmpty(LTNode* phead);
// 双向链表在pos位置之前插入x
void ListInsert(LTNode* pos, LTDateType x);
// 双向链表删除pos位置的结点
void ListErase(LTNode* pos);
// 求链表长度
int ListSize(LTNode* phead);
//struct List//这样可以解决求链表长度的O(N)问题
//{
// LTNode* phead;
// int szie;
//};
// 双向链表的销毁
void ListDestroy(LTNode* phead);
3.2.1 创建一个结点
LTNode* BuyListNode(LTDateType x)
{
LTNode* node = (LTNode*)malloc(sizeof(LTNode));
if (node == NULL)
{
perror("malloc fail");
exit(-1);
}
node->date = x;
node->next = NULL;
node->prev = NULL;
return node;
}
3.2.2 初始化 创建返回链表的头结点
//void ListInit(LTNode** pphead)
//{
// *pphead = BuyListNode(-1);
// (*pphead)->next = *pphead;
// (*pphead)->prev = *pphead;
//}
LTNode* ListInit()
{
LTNode* phead = BuyListNode(-1);
phead->next = phead;
phead->prev = phead;
return phead;
}
3.2.3 双向链表打印
void ListPrint(LTNode* phead)
{
assert(phead);
LTNode* cur = phead->next;//*
while (cur != phead)
{
printf("%d ", cur->date);
cur = cur->next;
}
printf("\n");
}
3.2.4 判断只否只剩下哨兵位
bool ListEmpty(LTNode* phead)
{
assert(phead);
return phead->next == phead;
}
3.2.5 双向链表头插
void ListPushFront(LTNode* phead, LTDateType x)
{
assert(phead);
//LTNode* newnode = BuyListNode(x);
//LTNode* next = phead->next;
phead newnode next
//phead->next = newnode;
//newnode->prev = phead;
//newnode->next = next;
//next->prev = newnode;
//直接复用ListInsert
ListInsert(phead->next, x);
}
3.2.6 双向链表尾插
void ListPushBack(LTNode* phead, LTDateType x)
{
assert(phead);
//LTNode* newnode = BuyListNode(x);
//LTNode* tail = phead->prev;
//tail->next = newnode;
//newnode->prev = tail;
//newnode->next = phead;
//phead->prev = newnode;
//直接复用ListInsert
ListInsert(phead, x);
}
3.2.7 双向链表头删
void ListPopFront(LTNode* phead)
{
assert(phead);
assert(!ListEmpty(phead));
//LTNode* del = phead->next;
//phead->next = del->next;
//del->next->prev = phead;
//free(del);
//复用ListErase
ListErase(phead->next);
}
3.2.8 双向链表尾删
void ListPopBack(LTNode* phead)
{
assert(phead);
assert(!ListEmpty(phead));//
//assert(phead->next!=phead);
//LTNode* tail = phead->prev;
//LTNode* tailPrev = tail->prev;
//free(tail);
//tailPrev->next = phead;
//phead->prev = tailPrev;
//复用ListErase
ListErase(phead->prev);
}
3.2.9 双向链表在pos位置之前插入x
void ListInsert(LTNode* pos, LTDateType x)
{
assert(pos);
LTNode* prev = pos->prev;
LTNode* newnode = BuyListNode(x);
//prev newnode pos
prev->next = newnode;
newnode->prev = prev;
newnode->next = pos;
pos->prev = newnode;
}
3.2.10 双向链表删除pos位置的结点
void ListErase(LTNode* pos)
{
assert(pos);
LTNode* prev = pos->prev;
LTNode* next = pos->next;
prev->next = next;
next->prev = prev;
free(pos);
}
3.2.11 求链表长度
//时间复杂度:O(n)
int ListSize(LTNode* phead)
{
assert(phead);
LTNode* cur = phead->next;
int size = 0;
while (cur != phead)
{
size++;
cur = cur->next;
}
return size;
}
3.2.12 双向链表的销毁
void ListDestroy(LTNode* phead)
{
assert(phead);
LTNode* cur = phead->next;
while (cur != phead)
{
LTNode* next = cur->next;
ListErase(cur);
cur = next;
}
free(phead);
}
4. 顺序表和带头双向循环链表的区别(面试题)
- 顺序表的优点:下标随机访问
- 顺序表的缺点:头部或中间插入删除效率低、扩容(有一定程度的消耗、可能存在一定程度空间浪费)
- 带头双向循环链表优点:任意位置插入删除时间复杂度O(1),按需申请释放
- 带头双向循环链表缺点:不支持下标随机访问
- 总的来说,他们是相辅相成的
5. 总结
- 空链表就是一个空指针。
- 哨兵位简单来说就是第一个结点不存储有效数据。
- 链表传参一般传递二级指针,当链表为空时,才能有效地插入新数据。涉及形参和实参的关系,以及NULL指针的解引用问题。
- 单链表要改变plist,就要传递二级指针;而带头双向循环链表,由于哨兵位的存在,可不用传递二级指针。
- 单链表插入数据不需要挪动数据,解决了顺序表需要挪动数据的效率问题
- 带头双向循环链表的插入删除时间复杂度均是O(1),核心代码是ListInsert和ListErase函数
- 可不敢直接用哨兵位的数据域记录链表长度,因为数据域的数据类型不一定是int
学习记录:
- 本篇博客整理于2022.6.23~2022.7.3
- 如果有错误的地方请多多指教🌹🌹🌹