【数据结构与算法】(6):带头结点的双向循环链表

博客主页:Code_文晓

本文专栏:数据结构与算法

欢迎关注:感谢大家的点赞评论+关注,祝您学有所成!


 ✨✨想要学习更多数据结构与算法点击专栏链接查看✨✨  


目录

一.双向循环链表

二.双向循环链表基础操作 

1.存储结构 

2.生成新结点 

3.初始化链表 

4.判断链表是否为空 

5.打印链表 

三.双向循环链表进阶操作

1.尾插法

2.头插法

3.尾删法

4.头删法 

5.查找结点 

6.在pos位置之前插入结点 

7.删除pos位置的结点 

8.改进后的尾插法和头插法 

9.改进后的尾删法和头删法 

10.链表的销毁 

四.归纳总结 


一.双向循环链表

我们说双向循环链表,它也被称为循环双链表。在学习双向循环链表之前先来看一一下双链表的结构:

虽然双链表可以很方便地找到某个结点前后的所有结点,但寻找效率却不一定高。比如已经拿到了双链表中最后一个节点的指针,那我们要如何快速寻找第 1 个节点呢?双循环链表可以很好的解决这个问题。 

在双链表的基础上,我们将链表中最后一个结点的后继指针由指向 nullptr 修改为指向头结点,将链表头结点的前趋指针由指向 nullptr 修改为指向最后一个结点,也就构成了双循环链表。 

为了让实现代码简单,依旧在链表中引入头结点。当双循环链表为空时,头结点的前趋指针和后继指针都指向自身,如图所示: 

【数据结构与算法】(6):带头结点的双向循环链表_第1张图片

空双循环链表头结点的后继和前趋指针都指向自身

当双循环链表不为空时,最后一个结点的后继指针指向头结点,头结点的前趋指针指向最后一 个结点,如图所示: 

带头结点的双循环链表数据存储描述图 

从上图可以看到,双循环链表的所有后继指针形成了一个环,所有前趋指针也形成了一个环 (一共两个环)。这样的话,给定一个数据结点,无论访问链表的后继结点还是前趋结点,都非常灵活和方便。 


二.双向循环链表基础操作 

这里先给出以下双向循环链表各种操作的接口函数,以便查看所实现的功能:

// 存储结构
typedef int  LTDataType;
typedef struct ListNode
{
	struct ListNode* prev;
	struct ListNode* next;
	LTDataType data;
}ListNode;

// 双向循环链表生成新结点
ListNode* ListCreate(LTDataType x);

// 双向循环链表初始化
ListNode* ListInit();

// 双向循环链表销毁
void ListDestroy(ListNode* phead); 

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

//判断循环链表是否为空
bool ListEmpty(ListNode* phead);

// 双向循环链表尾插
void ListPushBack(ListNode* phead,  LTDataType x);
// 双向循环链表头插
void ListPushFront(ListNode* phead,  LTDataType x);

// 双向循环链表尾删
void ListPopBack(ListNode* phead);
// 双向循环链表头删
void ListPopFront(ListNode* phead);

// 双向循环链表结点查找
ListNode* ListFind(ListNode* phead,  LTDataType x);

// 双向循环链表在pos位置前面插入结点
ListNode* ListInsert(ListNode* pos,  LTDataType x);
// 双向循环链表删除pos位置结点
void ListErase(ListNode* pos);

1.存储结构 

双向循环链表的存储结构内容有一个前驱指针prev用来指向该结点的前一个结点;一个后继指针next指向后后一个结点;以及本结点存储的数据data。 

typedef int  LTDataType;
typedef struct ListNode
{
	struct ListNode* prev;
	struct ListNode* next;
	LTDataType data;
}ListNode;

2.生成新结点 

为了方便后续对双向循环链表的各种操作,这里把malloc新结点封装成一个函数。 

// 双向循环链表生成新结点
ListNode* ListCreate(LTDataType x)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (newnode == NULL)
	{
		perror("malloc failed");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;

	return newnode;
}

3.初始化链表 

首先创建一个头结点,初始化双向循环链表的时候, 头结点的前驱指针和后继指针都要指向头结点,这样做有后续操作有很大的优势。例如:更方便判断链表是否为空;新结点头插到链表时的操作可以统一等。

【数据结构与算法】(6):带头结点的双向循环链表_第2张图片

// 双向循环链表初始化
ListNode* ListInit()
{
	ListNode* phead = ListCreate(-1);
	phead->next = phead;
 	phead->prev = phead;

	return phead;
}

4.判断链表是否为空 

由上图也知,当头结点的next指针指向本身时,链表是空的。

// 双向循环链表判断是否为空 
bool ListEmpty(ListNode* phead)
{
	assert(phead);
	
	return phead->next == phead;
}

5.打印链表 

从链表的第一个结点(头结点后面的一个结点)开始往后遍历,每遍历到一个结点打印该结点的data数值。这里有一个问题,遍历带头结点的双向循环链表的终止条件是什么? 

我们知道双向循环链表的特点是链表的最后一个结点的next指针是指向头结点的,遍历结束最后一个结点时再往后遍历就回到了头结点。所以cur指针指向头结点时,整个链表从第一个结点到最后一个结点都已经遍历一遍了。

// 双向循环链表打印
void ListPrint(ListNode* phead)
{
	assert(phead);

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

三.双向循环链表进阶操作

1.尾插法

【数据结构与算法】(6):带头结点的双向循环链表_第3张图片

// 双向循环链表尾插方式1:
void ListPushBack(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListNode* newnode = ListCreate(x);
	ListNode* tail = phead->prev; //找到记录尾结点

	tail->next = newnode; //尾结点的next指针指向要插入的新结点
	newnode->prev = tail; //新结点的前驱指针指向尾结点
	newnode->next = phead; //新结点的后继指针指向头结点
	phead->prev = newnode; //头结点的前驱指针指向新结点

    // 最后形成了一个新的双向循环链表
}

2.头插法

头插法的两种方式,基本原理是一样的。一种没有记录第一个结点,操作过程中顺序不可以改变,否则头插就会失败。另外一种用first指针记录第一个结点,这样顺序随意更自由。

【数据结构与算法】(6):带头结点的双向循环链表_第4张图片

第一种: 

// 双向循环链表头插方式1:step1和step2顺序不能变
void ListPushFront(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListNode* newnode = ListCreate(x);

	//step1:
	newnode->next = phead->next;
	phead->next->prev = newnode;
	//step2:
	phead->next = newnode;
	newnode->prev = phead;
}

第二种: 

// 双向循环链表头插方式 2:step1和step2顺序随意
void ListPushFront(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListNode* newnode = ListCreate(x);
	ListNode* first = phead->next; //用指针first记录首元结点,即链表的第一个有效结点

	//step1:
	phead->next = newnode;
	newnode->prev = phead;
	//step2:
	newnode->next = first;
	first->prev = newnode;
}

3.尾删法

【数据结构与算法】(6):带头结点的双向循环链表_第5张图片

// 双向循环链表尾删方式1:
void ListPopBack(ListNode* phead)
{
	assert(phead);
	assert(!ListEmpty(phead));

	ListNode* tail = phead->prev;
	ListNode* tailPrev = tail->prev;

	free(tail);
	tailPrev->next = phead;
	phead->prev = tailPrev;
}

4.头删法 

【数据结构与算法】(6):带头结点的双向循环链表_第6张图片

// 双向循环链表头删方式1:
void ListPopFront(ListNode* phead)
{
	assert(phead);
	assert(!ListEmpty(phead));

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

	//phead->next = first->next;
	//first->next->prev = phead;
	//free(first);

	ListNode* first = phead->next;
	ListNode* second = first->next;

	phead->next = second;
	second->prev = phead;
	free(first);
}

5.查找结点 

遍历链表,找到data为X的结点,找到的话返回这个结点的地址,找不到返回NULL。 

// 双向循环链表结点查找
ListNode* ListFind(ListNode* phead, LTDataType x)
{
	assert(phead);

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

6.在pos位置之前插入结点 

【数据结构与算法】(6):带头结点的双向循环链表_第7张图片

// 双向循环链表在pos位置之前插入结点
ListNode* ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);
	
	//方式1:
	/*ListNode* newnode = ListCreate(x);
	
	pos->prev->next = newnode;
	newnode->prev = pos->prev;
	newnode->next = pos;
	pos->prev = newnode;*/

	//方式2:
	ListNode* newnode = ListCreate(x);
	ListNode* posPrev = pos->prev;

	posPrev->next = newnode;
	newnode->prev = posPrev;
	newnode->next = pos;
	pos->prev = newnode;
}

7.删除pos位置的结点 

【数据结构与算法】(6):带头结点的双向循环链表_第8张图片

// 双向循环链表删除pos位置的结点
void ListErase(ListNode* pos)
{
	assert(pos);

	//方式1:
	/*
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;
	free(pos);
	*/
	//方式2:
	ListNode* posPrev = pos->prev;
	ListNode* posNext = pos->next;

	posPrev->next = posNext;
	posNext->prev = posPrev;
	free(pos);
}

8.改进后的尾插法和头插法 

由方法6在pos位置之前插入结点 ,可以改进尾插法和头插法。

尾插法:是在最后一个结点后面位置插入新的结点,就相当于头结点位置的前一个,所以pos相当于头结点。 

头插法:就相当于在第一个结点位置前插入新的结点,所以pos相当于第一个结点。 


尾插法: 

// 双向循环链表尾插方式2:
void ListPushBack(ListNode* phead, LTDataType x)
{
	ListInsert(phead, x);
}

 头插法:

// 双向循环链表头插方式3:
void ListPushFront(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListInsert(phead->next, x);
}

9.改进后的尾删法和头删法 

由方法7删除pos位置的结点 ,可以改进尾删法和头删法。

尾删法:就是删除最后一个结点位置的结点,就相当于头结点前一个位置的结点,所以pos相当于头结点前一个。 

头删法:就是删除在第一个结点位置的结点,所以pos相当于第一个结点。


尾删法:

// 双向循环链表尾删方式2:
void ListPopBack(ListNode* phead)
{
	assert(phead);
	
	ListEras(phead->prev);
}

头删法:

// 双向循环链表头删方式2:
void ListPopFront(ListNode* phead)
{
	assert(phead);

	ListErase(phead->next);
}

10.链表的销毁 

// 双向循环链表销毁
void ListDestroy(ListNode* phead)
{
	assert(phead);
	ListNode* cur = phead->next;

	while (cur != phead)
	{
		ListNode* curNext = cur->next;
		free(cur);
		cur = curNext;
	}
	
	free(phead);
}

四.归纳总结 

这里提供所有代码,可以直接运行。创建三个文件,分别是List.h,List.c,Test.c。

List.h:

#define _CRT_SECURE_NO_WARNINGS 1

#include
#include
#include
#include

// 2、带头+双向+循环链表增删查改实现

typedef int  LTDataType;
typedef struct ListNode
{
	struct ListNode* prev;
	struct ListNode* next;
	LTDataType data;
}ListNode;

//  双向循环链表生成新结点
ListNode* ListCreate(LTDataType x);

// 双向循环链表初始化
ListNode* ListInit();

// 双向循环链表销毁
void ListDestroy(ListNode* phead); 

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

//判断循环链表是否为空
bool ListEmpty(ListNode* phead);

// 双向循环链表尾插
void ListPushBack(ListNode* phead,  LTDataType x);
// 双向循环链表头插
void ListPushFront(ListNode* phead,  LTDataType x);

// 双向循环链表尾删
void ListPopBack(ListNode* phead);
// 双向循环链表头删
void ListPopFront(ListNode* phead);

// 双向循环链表结点查找
ListNode* ListFind(ListNode* phead,  LTDataType x);

// 双向循环链表在pos位置前面插入结点
ListNode* ListInsert(ListNode* pos,  LTDataType x);
// 双向循环链表删除pos位置结点
void ListErase(ListNode* pos);

List.c:

#define _CRT_SECURE_NO_WARNINGS 1

#include"List.h"

// 双向循环链表生成新结点
ListNode* ListCreate(LTDataType x)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (newnode == NULL)
	{
		perror("malloc failed");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;

	return newnode;
}

// 双向循环链表初始化
ListNode* ListInit()
{
	ListNode* phead = ListCreate(-1);
	phead->next = phead;
 	phead->prev = phead;

	return phead;
}

// 双向循环链表打印
void ListPrint(ListNode* phead)
{
	assert(phead);

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

// 双向循环链表判断是否为空 
bool ListEmpty(ListNode* phead)
{
	assert(phead);
	
	return phead->next == phead;
}

// 双向循环链表尾插方式1:
void ListPushBack(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListNode* newnode = ListCreate(x);
	ListNode* tail = phead->prev;

	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;
}

// 双向循环链表尾插方式2:
//void ListPushBack(ListNode* phead, LTDataType x)
//{
//	ListInsert(phead, x);
//}

// 双向循环链表头插方式1:step1和step2顺序不能变
void ListPushFront(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListNode* newnode = ListCreate(x);

	//step1:
	newnode->next = phead->next;
	phead->next->prev = newnode;
	//step2:
	phead->next = newnode;
	newnode->prev = phead;
}

// 双向循环链表头插方式2:step1和step2顺序随意
//void ListPushFront(ListNode* phead, LTDataType x)
//{
//	assert(phead);
//	ListNode* newnode = ListCreate(x);
//	ListNode* first = phead->next; //用指针first记录首元结点,即链表的第一个有效结点
//
//	//step1:
//	phead->next = newnode;
//	newnode->prev = phead;
//	//step2:
//	newnode->next = first;
//	first->prev = newnode;
//}

// 双向循环链表头插方式3:
//void ListPushFront(ListNode* phead, LTDataType x)
//{
//	assert(phead);
//	ListInsert(phead->next, x);
//}



// 双向循环链表尾删方式1:
void ListPopBack(ListNode* phead)
{
	assert(phead);
	assert(!ListEmpty(phead));

	ListNode* tail = phead->prev;
	ListNode* tailPrev = tail->prev;

	free(tail);
	tailPrev->next = phead;
	phead->prev = tailPrev;
}

// 双向循环链表尾删方式2:
//void ListPopBack(ListNode* phead)
//{
//	assert(phead);
//	
//	ListEras(phead->prev);
//}

// 双向循环链表头删方式1:
void ListPopFront(ListNode* phead)
{
	assert(phead);
	assert(!ListEmpty(phead));

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

	//phead->next = first->next;
	//first->next->prev = phead;
	//free(first);

	ListNode* first = phead->next;
	ListNode* second = first->next;

	phead->next = second;
	second->prev = phead;
	free(first);
}

// 双向循环链表头删方式2:
//void ListPopFront(ListNode* phead)
//{
//	assert(phead);
//
//	ListErase(phead->next);
//}


// 双向循环链表结点查找
ListNode* ListFind(ListNode* phead, LTDataType x)
{
	assert(phead);

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

// 双向循环链表在pos位置之前插入结点
ListNode* ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);
	
	//方式1:
	/*ListNode* newnode = ListCreate(x);
	
	pos->prev->next = newnode;
	newnode->prev = pos->prev;
	newnode->next = pos;
	pos->prev = newnode;*/

	//方式2:
	ListNode* newnode = ListCreate(x);
	ListNode* posPrev = pos->prev;

	posPrev->next = newnode;
	newnode->prev = posPrev;
	newnode->next = pos;
	pos->prev = newnode;
}

// 双向循环链表删除pos位置的结点
void ListErase(ListNode* pos)
{
	assert(pos);

	//方式1:
	/*
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;
	free(pos);
	*/
	//方式2:
	ListNode* posPrev = pos->prev;
	ListNode* posNext = pos->next;

	posPrev->next = posNext;
	posNext->prev = posPrev;
	free(pos);
}

// 双向循环链表销毁
void ListDestroy(ListNode* phead)
{
	assert(phead);
	ListNode* cur = phead->next;

	while (cur != phead)
	{
		ListNode* curNext = cur->next;
		free(cur);
		cur = curNext;
	}
	
	free(phead);
}

Test.c:

#define _CRT_SECURE_NO_WARNINGS 1

#include"List.h"

void TestList()
{
	ListNode* plist = ListInit();
	printf("尾插1,2:\n");
	ListPushBack(plist, 1);
	ListPushBack(plist, 2);
	ListPrint(plist);

	printf("头插3,4,5:\n");
	ListPushFront(plist, 3);
	ListPushFront(plist, 4);
	ListPushFront(plist, 5);
	ListPrint(plist);

	printf("尾删一个元素:\n");
	ListPopBack(plist);
	ListPrint(plist);

	printf("头删一个元素:\n");
	ListPopFront(plist);
	ListPrint(plist);

	int i = 0;
	printf("请输入你要查找的结点:\n");
	scanf("%d", &i);
	ListNode* pos = ListFind(plist, i);
	if (pos)
	{
		printf("查找data为%d的结点并打印其data:\n", i);
		printf("%d\n", pos->data);
	}
	else
	{
		printf("没有data为%d的结点\n",i);
	}

	printf("请输入两个结点,一是插入的位置前面,二是插入的结点:\n");
	int k = 0, j = 0;
	scanf("%d%d", &k, &j);
	pos = ListFind(plist, k);
	if (pos)
	{
		ListInsert(pos, j);
		printf("在data为%d的结点前插入一个值为%d的结点后的链表:\n", k, j);
		ListPrint(plist);
	}
	else
	{
		printf("没有data为%d的结点,插入失败\n",k);
	}
	
	printf("请输入你要删除的结点:\n");
	int m = 0;
	scanf("%d", &m);
	pos = ListFind(plist, m);
	if (pos)
	{
		ListErase(pos);
		printf("删除结点%d后的链表:\n", m);
		ListPrint(plist);
	}
	else
	{
		printf("没有data为%d的结点,删除失败\n",m);
	}

	ListDestroy(plist);
	plist = NULL;
}
 
int main()
{
	TestList();
	return 0;
}

你可能感兴趣的:(数据结构与算法,链表,数据结构,算法)