数据结构——带头双向循环链表

Posted 2023-04-08 Jambo!

目录

• 带头双向循环链表的结构
• 带头双向循环链表的实现
• • 建立新节点
  • 初始化函数
  • 打印函数
  • 判空函数
  • 尾插函数
  • 头插函数
  • 尾删函数
  • 头删函数
  • 查找函数
  • 插入函数
  • 删除函数
  • 销毁函数
• 带头双向循环链表的特点
• 链表和顺序表的对比

带头双向循环链表的结构

带头双向循环链表的结构如下图：

可以看到，带头双向循环链表是结构最复杂的链表

但是在实际使用链表结构存储数据时，都是使用带头双向循环链表，虽然这个结构有些复杂，但是这样的结构会给我们带来很多优势，实现代码的时候反而简单了

下面我们来实现一下带头双向循环链表

---

带头双向循环链表的实现

因为这是一个双向链表，所以要在结构体中定义2个结构体类型指针，用来指向节点的前一个结点和后一个结点

所以带头双向循环链表的结构体如下：

typedef int LTDataType;

typedef struct ListNode

	struct ListNode* prev;
	struct ListNode* next;
	LTDataType data;

LTNode;

---

建立新节点

这里还是使用malloc去建立一个结点，其余的与单链表中建立新节点类似，这里不多说。

LTNode* BuyNewNode(LTDataType x)

	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	
		perror("malloc fail");
		return;
	
	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;

	return newnode;

---

初始化函数

因为这个结构是包含头节点的，所以要在初始化函数中把头节点定义出来

LTNode* phead = BuyNewNode(-1);

因为此时只有头节点一个结点，又因为结构是循环的，所以头节点的下一个结点和上一个节点都是头节点自己

phead->next = phead;
phead->prev = phead;

所以，初始化的代码为：

LTNode* LTInit()

	LTNode* phead = BuyNewNode(-1);
	phead->next = phead;
	phead->prev = phead;
	return phead;

---

打印函数

void LTPrint(LTNode* phead)

	assert(phead);
	LTNode* cur = phead->next;
	printf("<=>head<=>");
	while (cur!= phead)
	
		printf("%d<=>", cur->data);
		cur = cur->next;
	
	printf("\\n");

---

判空函数

当只剩头节点一个节点时，链表就为空了，所以当phead->next == phead时，就说明链表为空了

bool LTEmpty(LTNode* phead)

	assert(phead);
	return phead->next == phead;

---

尾插函数

尾插函数第一步就是要找尾，在单链表中，想要找到尾就需要遍历一遍链表，效率低耗时

但是在带头双向循环链表中，找到尾很简单，尾节点就是头节点的前一个节点

然后再依次将结点前后链接上即可

void LTPushBack(LTNode* phead, LTDataType x)

	assert(phead);
	LTNode* newnode = BuyNewNode(x);
	LTNode* tail = phead->prev;
	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;

---

头插函数

在实现单链表时，头节点就是头指针指向的结点
在带头双向循环链表中，头节点就是头节点的下一个结点

void LTPushFront(LTNode* phead, LTDataType x)

	assert(phead);
	LTNode* newnode = BuyNewNode(x);
	LTNode* nex = phead->next;
	phead->next = newnode;
	newnode->prev = phead;
	newnode->next = nex;
	nex->prev = newnode;

---

尾删函数

在单链表中，我们循环需要找到尾节点以及尾节点前面的节点，十分的麻烦
但是在带头双向循环链表中，就没有这样的问题

头节点的prev就是尾节点tail，尾节点的prev就是尾节点的前一个节点tailprev

然后将tailprev当成尾节点链接起来，最后free掉tail

void LTPopBack(LTNode* phead)

	assert(phead);
	assert(!LTEmpty(phead));

	LTNode* tail = phead->prev;
	LTNode* tailprev = tail->prev;
	tailprev->next = phead;
	phead->prev = tailprev;
	free(tail);
	tail = NULL;

---

头删函数

void LTPopFront(LTNode* phead)

	assert(phead);
	assert(!LTEmpty(phead));
	LTNode* del = phead->next;
	LTNode* nex = del->next;
	phead->next = nex;
	nex->prev = phead;
	free(del);
	del = NULL;

头删与尾删类似，不多说

---

查找函数

在单链表中，查找某个节点的循环条件是什么时候遇到空，什么时候结束循环

在带头双向循环链表中，循环条件则是遇到头节点，就结束循环

LTNode* LTFind(LTNode* phead,LTDataType x)

	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	
		if (cur->data == x)
		
			return cur;
		
		cur = cur->next;
	

	return NULL;

---

插入函数

在pos位置前插入，这个pos的地址是由LTFind函数返回的

如果我们直接就将新的节点newnode插入到pos前面位置，它们之间的链接操作有一定的顺序，如果随意改变链接关系是会出问题的

所以我们可以用一个指针posprev去保存pos->prev的地址，然后再链接posprev、newnode和 pos间的链接关系，这时的链接关系的改变不需要按照一定的顺序，按照逻辑随意修改

void LTInsert(LTNode* pos, LTDataType x)

	assert(pos);
	LTNode* posprev = pos->prev;
	LTNode* newnode = BuyNewNode(x);
	posprev->next = newnode;
	newnode->prev = posprev;
	newnode->next = pos;
	pos->prev = newnode;

我们可以用这个删除函数与实现头插和尾插

尾插：因为在pos前插入，头节点的前一个结点就是尾结点，所以调用LTInsert函数时传的地址是phead

void LTPushBack(LTNode* phead, LTDataType x)

	assert(phead);
	LTInsert(phead, x); 
	//调用LTInsert函数尾插

头插：phead->next的前插入就是头插，所以传参为phead->next

void LTPushFront(LTNode* phead, LTDataType x)

	assert(phead);
	LTInsert(phead->next, x); 
	 //调用LTInsert函数头插

---

删除函数

这里的操作也如上个函数一样，用一个指针posprev保存pos->prev的地址，用指针posnext保存pos->next的地址，然后链接posprev和posnext

随后free掉pos即可

void LTErase(LTNode* pos)

	assert(pos);
	LTNode* posprev = pos->prev;
	LTNode* posnext = pos->next;
	posprev->next = posnext;
	posnext->prev = posprev;
	free(pos);
	pos = NULL;

这个函数还有个瑕疵就是：
如果pos传的是哨兵位头节点的地址，那么删除操作就会出错
这里如果想检查，就需要传一个参数，用来比较pos和头节点地址是否相同，但是没有必要
在后面C++中会有更好的写法

同样，可以调用LTErase去实现头删和尾删

头删：

void LTPopFront(LTNode* phead)

	assert(phead);
	assert(!LTEmpty(phead));
	LTErase(phead->next);

尾删：

void LTPopBack(LTNode* phead)

	assert(phead);
	assert(!LTEmpty(phead));
	LTErase(phead->prev);

---

销毁函数

void LTDestroy(LTNode* phead)

	assert(phead);

	LTNode* del = phead->next;
	LTNode* nex = del->next;
	while (del!= phead)
	
		free(del);
		del = nex;
		nex = nex->next;
	

	free(phead);
	phead = NULL;

---

带头双向循环链表的特点

在前面实现的过程中可以发现：

• 以往单链表的尾删、删除和插入操作的时间复杂度是 O(n),因为需要找尾或找前一个结点，但是带头双向循环链表完美得解决了这个问题，我们可以通过phead->prev找到尾，通过某一结点的prev找到前一个结点，所以在带头双向循环链表中，尾删和插入的时间复杂度为O(1)
• 在单链表的头插、尾插、头删、尾删等函数中，传的参数有二级指针，不容易理解，但是带头双向循环链表有头节点，传参是头节点的地址，因为在函数中是不会改变这个地址的指向，所以不用传二级指针

---

链表和顺序表的对比

这两个结构各有优势，很难说谁更优，这两个结构相辅相成

顺序表：

• 物理上存储空间连续
• 支持随机访问
• 任意位置插入或者删除元素可能需要搬移元素，效率低O(N)
• 连续物理空间，空间不够后需要增容。增容有一定程度的消耗

链表：

• 物理上存储空间不连续，但是逻辑上连续
• 不支持随机访问
• 任意位置插入删除效率高
• 按需申请释放空间

C语言带头双向循环链表增删改查的实现

带头双向循环链表：虽然结构比较复杂，一般用在单独存储数据，但实际中使用的链表数据结构大多数都是带头双向循环链表。带头双向循环链表虽然结构复杂，但是实际上实现起来比单链表和顺序表都要更加简单，这篇博客的内容就是带头双向循环链表增删改查的实现。

//list.h
#pragma  once
#include <stdio.h>
#include <assert.h>
#include <malloc.h>
typedef int LTDataType;
typedef struct ListNode 

	LTDataType data;
	struct ListNode* next;
	struct ListNode* prev;
ListNode;

ListNode* ListCreate();
void ListDestory(ListNode* phead); //双向链表销毁
void ListPrint(ListNode* phead);//双向链表打印
void ListPushBack(ListNode* phead, LTDataType x); //尾插
void ListPopBack(ListNode* phead); //尾删
void ListPushFront(ListNode* phead, LTDataType x);//头插
void ListPopFront(ListNode* phead);//头插
ListNode* ListFind(ListNode* phead, LTDataType x);//查找
void ListInsert(ListNode* pos, LTDataType x);//在pos前面进行插入
void ListErase(ListNode* pos);//删除pos位置的节点

//list.c
#include "list.h"
ListNode* ListCreate()

	ListNode* head = (ListNode*)malloc(sizeof(ListNode));
	head->next = head;
	head->prev = head; //前后都指向自己
	return head;

ListNode* NewListNode(LTDataType x)

	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	return newnode;

void ListDestory(ListNode* phead) //双向链表销毁

	ListNode* cur = phead->next;
	while (cur != phead)
	
		ListNode* next = cur->next;
		free(cur);
		cur = next;
	
	free(phead);
	phead = NULL;

void ListPrint(ListNode* phead)//双向链表打印

	ListNode*cur = phead->next;
	while (cur!= phead)
	
		printf("%d->", cur->data);
		cur = cur->next;
	
	printf("\\n");

void ListPushBack(ListNode* phead, LTDataType x) //尾插

	ListNode* newnode = NewListNode(x);
	ListNode* tail = phead->prev;
	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;

void ListPopBack(ListNode* phead) //尾删

	ListNode* tail = phead->prev;
	ListNode* prev = tail->prev;
	free(tail);
	prev->next = phead;
	phead->prev = prev;

void ListPushFront(ListNode* phead, LTDataType x)//头插

	ListNode* newnode = NewListNode(x);
	ListNode* first = phead->next; //此时顺序为 phead newnode first
	phead->next = newnode;
	newnode->prev = phead;
	newnode->next = first;
	first->prev = newnode;

void ListPopFront(ListNode* phead)//头删

	assert(phead->next != phead); //不能free掉头节点
	ListNode* first = phead->next;
	ListNode* second = first->next;
	free(first);
	phead->next = second;
	second->prev = phead;

ListNode* ListFind(ListNode* phead, LTDataType x)//查找

	ListNode* cur = phead->next;
	while (cur != phead)
	
		if (cur->data!=x)
		
			cur=cur->next;
		
		return cur;
	
	return NULL;

void ListInsert(ListNode* pos, LTDataType x)//在pos前面进行插入

	ListNode* prev = pos->prev;
	ListNode*newnode = NewListNode(x);
	prev->next = newnode;
	newnode->prev = prev;
	newnode->next = pos;
	pos->prev = newnode;  //使用ListInsert还可以实现头插ListInsert（head->next,x） 尾插ListInsert（head,x）

void ListErase(ListNode* pos)//删除pos位置的节点

	ListNode*prev = pos->prev;
	ListNode*next = pos->next;
	free(pos);
	prev->next = next;
	next->prev = prev;  //使用ListErase还可以实现头删ListErase（head->next） 尾删ListErase（head->prev）

void TestList()

	ListNode* list = ListCreate();
	ListPushBack(list, 1);
	ListPushBack(list, 2);
	ListPushBack(list, 3);
	ListPushBack(list, 4);
	ListPrint(list);

	ListPopBack(list);
	ListPrint(list);

	ListPushFront(list, 0);
	ListPrint(list);

	ListPopFront(list);
	ListPrint(list);

int main()

	TestList();
	system("pause");
	return 0;