带头双向循环链表

1 链表的种类

1.1 第一对

1、单链表

2、双向链表

1.2 第二对

3、不带头单链表

4、带头单链表

1.3 第三对

5、单链表

6、循环单链表

1.4 常用

• 无头单向非循环链表

​ 结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。

• 带头双向循环链表

​ 结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而更简单。

2 带头双向循环链表的实现

2.1 创建

typedef int LTDateType;    // 定义存入的数据类型，以后方便修改

typedef struct LTNode
{
	LTDateType data;
	struct LTNode* next;   //下一个节点
	struct LTNode* prev;   //前一个节点
}LTNode;
1
2
3
4
5
6
7
8

2.2 初始化

思路

声明

LTNode*  ListInit();
1

定义

LTNode*  ListInit()
{
    LTNode* phead = (LTNode*)malloc(sizeof(LTNode)); // malloc一个哨兵位头节点
    phead->next = phead; // 使头尾相连
    phead->prev = phead;

    return phead;
}
1
2
3
4
5
6
7
8

2.3 打印

声明

void ListPrint(LTNode* phead);
1

定义

void ListPrint(LTNode* phead)
{
	assert(phead);

	LTNode* cur = phead->next;
	while (cur != phead) // cur不等于head时执行
	{
		printf("%d\n", cur->data);
		cur = cur->next;
	}
    printf("\n");
}
1
2
3
4
5
6
7
8
9
10
11
12

2.4 尾插

思路：

声明

void ListPushBack(LTNode* phead, LTDateType x);
1

定义

void ListPushBack(LTNode* phead, LTDateType x)
{
	assert(phead);
    
    //1.
	LTNode* tail = phead->prev;
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode)); // 创建新节点
	newnode->data = x;    // 先存数据

	tail->next = newnode;    //使尾和新节点相连
	newnode->prev = tail; 

	phead->prev = newnode;   //使头和新节点相连
	newnode->next = phead;
    
    //2.直接调用Insert函数
	ListInsert(phead, x); 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

注意

• 由于是带有头节点，所有尾插时不改变plist，只改变plist里指向的结构体，所以不用传地址
• 而无头单向非循环单链表要改变plist(NULL)，所以要传地址
• 返回值也不用传地址

2.5 尾删

思路

声明

void ListPopBack(LTNode* phead);
1

定义

void ListPopBack(LTNode* phead)
{
	assert(phead);

	LTNode* tail = phead->prev;
	phead->prev = tail->prev;
	tail->prev->next = phead;
}
1
2
3
4
5
6
7
8

2.6 头插

思路

定义

void ListPushFront(LTNode* phead, LTDateType x)
{
	assert(phead);
	// 1.常规方法
	/*LTNode* next = phead->next;
	LTNode* newnode = BuyListNode(x);

	phead->next = newnode;
	newnode->prev = phead;
	 
	newnode->next = next;
	next->prev = newnode;*/
	
	// 2.直接调用insert函数
	ListInsert(phead->next, x);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2.7 头删

2.7.1 两个变量

2.7.2 三个变量

定义

void ListPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);

	// 1.
	//LTNode* next = phead->next;
	//phead->next = next->next;
	//next->next->prev = phead;
	//free(next);
	//2. 差别不大
	LTNode* next = phead->next;
	LTNode* nextNext = next->next;
	free(next);
	phead->next = nextNext;
	nextNext->prev = phead;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2.8 查找x所在位置

定义：和Print打印差不多

LTNode* ListFind(LTNode* phead, LTDateType x)
{
	assert(phead);
	LTNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
			return cur;
		else if (cur->next == phead)
			return NULL;
		cur = cur->next;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

2.9 在pos节点前插入x

思路

定义

void ListInsert(LTNode* pos, LTDateType x)// 在pos节点之前插入
{
	assert(pos);
	LTNode* newnode = BuyListNode(x);
	LTNode* prev = pos->prev;
	prev->next = newnode;
	newnode->prev = prev;

	newnode->next = pos;
	pos->prev = newnode;
}
1
2
3
4
5
6
7
8
9
10
11

2.10 删除pos节点

思路

定义

void ListErase(LTNode* pos)// 删除pos节点
{
	assert(pos);
	LTNode* prev = pos->prev;
	LTNode* next = pos->next;
	free(pos);
	prev->next = next;
	next->prev = prev;
}
1
2
3
4
5
6
7
8
9

注意：有了insert函数后，可以修改头插和尾插函数，使其直接调用insert函数即可，头插即在head的next处插入即可，尾插即在head处插入即可

2.11 销毁链表

思路

void ListDestroy(LTNode* phead)
{
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		LTNode* next = cur->next;
		free(cur);
		cur = next;
	}
}
1
2
3
4
5
6
7
8
9
10

但是，由于传的是一级指针，最后无法把phead（即哨兵位头节点）给销毁，所以在结束函数后，我们使用函数的人在主函数可以写上plist=NULL，手动置空

因为整个链表我们每个函数接口都用的一级指针，所以最后这里销毁也用一级指针，所以会有无法销毁哨兵位的问题，但是为了保证 接口一致性，我们并不把它写为二级指针(其他都一级就别二级了)