链表（数据结构、C语言、单链表、带头双向循环链表）

前言：

• 本篇博客整理了数据结构初阶的链表相关知识，包括单链表、双向循环链表、以及哨兵位的介绍（这里的哨兵位在后面的链表OJ博客中会详细介绍）
• 单链表是作为学习其他高价数据结构的子结构
• 大部分笔试、面试题，以单链表为基础考察
• 代码实现：C语言

---

---

1. 链表的结构和概念

概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。

注意：

1. 从上图可以看出，链式结构在逻辑上是连续的，但在物理上不一定连续
2. 现实中的结点一般都是从堆上申请出来的
3. 从堆上申请的空间，是按照一定的策略来分配的两次申请的空间可能连续，也可能不连续

---

2. 链表的分类

实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：

1. 单向或者双向
   
2. 带头或不带头
   
3. 循环或不循环
   

虽然有这么多的链表结构，但是我们实际中最常用的还是两种结构：

• 无头单向非循环链表（单链表）
• 带头双向循环链表（最优链表）
  

注意：

1. 无头单向非循环链表：结构简单，一般不会单独用来存数据，实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中会出现很多。
2. 带头双向循环链表：结构复杂，一般用来单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然复杂，但使用代码实现以后会发现该结构会带来很多优势，实现反而简单了，后面我们实现就知道了。

---

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);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

3.1.1 动态申请一个结点

SLTNode* BuySListNode(SLTDateType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	assert(newnode);
	newnode->date = x;
	newnode->next = NULL;

	return newnode;
}
1
2
3
4
5
6
7
8
9

3.1.2 单链表打印

void SListPrint(SLTNode* phead)
{
	SLTNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d->", cur->date);
		cur = cur->next;
	}
	printf("NULL\n");
}
1
2
3
4
5
6
7
8
9
10

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;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3.1.4 单链表头插 O(1)

void SListPushFront(SLTNode** pphead, SLTDateType x)
{
	assert(pphead);

	SLTNode* newnode = BuySListNode(x);

	newnode->next = *pphead;
	*pphead = newnode;
}
1
2
3
4
5
6
7
8
9

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;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

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;
}
1
2
3
4
5
6
7
8

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;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

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;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

---

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);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

---

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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

---

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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

---

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");
}
1
2
3
4
5
6
7
8
9
10
11
12

---

3.2.4 判断只否只剩下哨兵位

bool ListEmpty(LTNode* phead)
{
	assert(phead);

	return phead->next == phead;
}
1
2
3
4
5
6

---

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);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

---

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);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

---

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);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

---

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);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

---

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;
}
1
2
3
4
5
6
7
8
9
10
11
12

---

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);
}
1
2
3
4
5
6
7
8
9
10
11

---

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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

---

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);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

---

4. 顺序表和带头双向循环链表的区别（面试题）

• 顺序表的优点：下标随机访问
• 顺序表的缺点：头部或中间插入删除效率低、扩容（有一定程度的消耗、可能存在一定程度空间浪费）

---

• 带头双向循环链表优点：任意位置插入删除时间复杂度O(1)，按需申请释放
• 带头双向循环链表缺点：不支持下标随机访问

---

• 总的来说，他们是相辅相成的

---

5. 总结

1. 空链表就是一个空指针。
2. 哨兵位简单来说就是第一个结点不存储有效数据。
3. 链表传参一般传递二级指针，当链表为空时，才能有效地插入新数据。涉及形参和实参的关系，以及NULL指针的解引用问题。
4. 单链表要改变plist，就要传递二级指针；而带头双向循环链表，由于哨兵位的存在，可不用传递二级指针。
5. 单链表插入数据不需要挪动数据，解决了顺序表需要挪动数据的效率问题
6. 带头双向循环链表的插入删除时间复杂度均是O(1)，核心代码是ListInsert和ListErase函数
7. 可不敢直接用哨兵位的数据域记录链表长度，因为数据域的数据类型不一定是int

---

学习记录：

• 本篇博客整理于2022.6.23~2022.7.3
• 如果有错误的地方请多多指教🌹🌹🌹