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

最新推荐文章于 2023-08-19 23:47:02 发布
最新推荐文章于 2023-08-19 23:47:02 发布
阅读量296 收藏 4
点赞数 12
分类专栏： 数据结构 文章标签： 数据结构 链表 算法 c语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luoheng1114/article/details/127965928
版权

目录

1.带头双向循环链表

2.链表实现

2.1可完成带头双向可循环链表节点的结构体

2.2申请一个可双向循环的节点

2.3初始化链表

2.4尾插

2.5尾删

2.6头插

2.7头删

2.8打印

2.9查找（修改）

2.10在pos之前插入x

2.11删除pos位置

 2.12判空

2.13记录链表大小

2.14销毁

3.完整的带头双向循环链表代码

3.1——List.h

3.2——List.c

1.带头双向循环链表

对比：

我们实际中最常用还是 两种 链表结构：
1.无头单向非循环链表

用处： 

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

 用处：

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

2.链表实现

2.1可完成带头双向可循环链表节点的结构体

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

2.2申请一个可双向循环的节点

LTNode* BuyListNode(LTDataType x)
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	node->data = x;
	node->next = NULL;
	node->prev = NULL;
	return node;
}

2.3初始化链表

LTNode* ListInit()
{
	LTNode* phead = BuyListNode(-1);
	phead->next = phead;
	phead->prev = phead;

	return phead;
}

2.4尾插

void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);

	//方法1
	/*LTNode* newnode = BuyListNode(x);
	LTNode* tail = phead->prev;

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

	newnode->next = phead;
	phead->prev = newnode;*/
	
	//方法2
	LTInsert(phead, x);
}

2.5尾删

void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);  // 空

	//方法1
	//LTNode* tail = phead->prev;
	//LTNode* tailPrev = tail->prev;

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

	//方法2
	LTErase(phead->prev);
}

2.6头插

void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	
	//方法1（有关顺序）
	/*LTNode* newnode = BuyListNode(x);
	newnode->next = phead->next;
	phead->next->prev = newnode;

	phead->next = newnode;
	newnode->prev = phead;*/

	//方法2（无关顺序）
	//LTNode* newnode = BuyListNode(x);
	//LTNode* first = phead->next;

	 phead newnode first 
	 顺序无关
	//phead->next = newnode;
	//newnode->prev = phead;
	//newnode->next = first;
	//first->prev = newnode;

	//方法3
	LTInsert(phead->next, x);

}

2.7头删

void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead); // 空

	//方法1
	/*LTNode* first = phead->next;
	LTNode* second = first->next;

	free(first);

	phead->next = second;
	second->prev = phead;*/
	
	//方法2
	LTErase(phead->next);
}

2.8打印

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

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

2.9查找（修改）

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;
}

2.10在pos之前插入x

 

// 在pos之前插入x
void LTInsert(LTNode* pos, LTDataType 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;
}

2.11删除pos位置

// 删除pos位置
void LTErase(LTNode* pos)
{
	assert(pos);

	LTNode* prev = pos->prev;
	LTNode* next = pos->next;
	free(pos);

	prev->next = next;
	next->prev = prev;
}

 2.12判空

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

	/*if (phead->next == phead)
	{
		return true;
	}
	else
	{
		return false;
	}*/

	return phead->next == phead;
}

2.13记录链表大小

size_t LTSize(LTNode* phead)
{
	assert(phead);

	size_t size = 0;
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		++size;
		cur = cur->next;
	}

	return size;
}

2.14销毁

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

	LTNode* cur = phead->next;
	while (cur != phead)
	{
		LTNode* next = cur->next;
		free(cur);      

		cur = next;
	}

	free(phead);
	//phead = NULL;
}

3.完整的带头双向循环链表代码

3.1——List.h

#pragma once

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>

//typedef char LTDataType;
//typedef double LTDataType;
typedef int LTDataType;

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

//创建节点
LTNode* BuyListNode(LTDataType x);
//初始化
LTNode* LTInit();

//打印
void LTPrint(LTNode* phead);
//尾插尾删
void LTPushBack(LTNode* phead, LTDataType x);
void LTPopBack(LTNode* phead);
//头插头删
void LTPushFront(LTNode* phead, LTDataType x);
void LTPopFront(LTNode* phead);
//查找
LTNode* LTFind(LTNode* phead, LTDataType x);

// pos前面插入
void LTInsert(LTNode* pos, LTDataType x);
// pos位置删除
void LTErase(LTNode* pos);
//判空
bool LTEmpty(LTNode* phead);
//大小
size_t LTSize(LTNode* phead);
//销毁
void LTDestroy(LTNode* phead);

3.2——List.c

#include "List.h"

LTNode* BuyListNode(LTDataType x)
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	node->data = x;
	node->next = NULL;
	node->prev = NULL;
	return node;
}

LTNode* LTInit()
{
	LTNode* phead = BuyListNode(-1);
	phead->next = phead;
	phead->prev = phead;

	return phead;
}

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

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

void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);

	//方法1
	/*LTNode* newnode = BuyListNode(x);
	LTNode* tail = phead->prev;

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

	newnode->next = phead;
	phead->prev = newnode;*/
	
	//方法2
	LTInsert(phead, x);
}

void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);  // 空

	//方法1
	//LTNode* tail = phead->prev;
	//LTNode* tailPrev = tail->prev;

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

	//方法2
	LTErase(phead->prev);
}

void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	
	//方法1（有关顺序）
	/*LTNode* newnode = BuyListNode(x);
	newnode->next = phead->next;
	phead->next->prev = newnode;

	phead->next = newnode;
	newnode->prev = phead;*/

	//方法2（无关顺序）
	//LTNode* newnode = BuyListNode(x);
	//LTNode* first = phead->next;

	 phead newnode first 
	 顺序无关
	//phead->next = newnode;
	//newnode->prev = phead;
	//newnode->next = first;
	//first->prev = newnode;

	//方法3
	LTInsert(phead->next, x);

}

void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead); // 空

	//方法1
	/*LTNode* first = phead->next;
	LTNode* second = first->next;

	free(first);

	phead->next = second;
	second->prev = phead;*/
	
	//方法2
	LTErase(phead->next);
}

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之前插入x
void LTInsert(LTNode* pos, LTDataType 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;
}

// 删除pos位置
void LTErase(LTNode* pos)
{
	assert(pos);

	LTNode* prev = pos->prev;
	LTNode* next = pos->next;
	free(pos);

	prev->next = next;
	next->prev = prev;
}

//判空
bool LTEmpty(LTNode* phead)
{
	assert(phead);

	/*if (phead->next == phead)
	{
		return true;
	}
	else
	{
		return false;
	}*/

	return phead->next == phead;
}

size_t LTSize(LTNode* phead)
{
	assert(phead);

	size_t size = 0;
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		++size;
		cur = cur->next;
	}

	return size;
}

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

	LTNode* cur = phead->next;
	while (cur != phead)
	{
		LTNode* next = cur->next;
		free(cur);      

		cur = next;
	}

	free(phead);
	//phead = NULL;
}
待己以诚
关注
  • 12
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 9
    评论
专栏目录
【数据结构】带头节点双向循环链表
weixin_53269843的博客
11-21 2002
顺序表和链表的区别 带头双向循环链表分析 带头双向循环链表结构： 创建一个节点 哨兵位头节点 打印链表中的值 在pos前插入 删除pos位置的节点 尾插 尾删 头插： 头删 链表元素查找
数据结构初阶--带头双向循环链表
weixin_36194037的博客
07-26 634
循环单链表虽然能够实现从任一结点出发沿着链能找到其前驱结点，但时间耗费是O(n)。如果希望从表中快速确定某一个结点的前驱，另一个解决方法就是在单链表的每个结点里再增加一个指向其前驱的指针域prior。这样形成的链表中就有两条方向不同的链，称之为双(向)链表。与单链表类似，双链表也可增加头结点使双链表的某些运算变得方便。同时双向链表也可以有循环表，称为双向循环链表。由于在双向链表中既有前向链又有后向链，寻找任一结点的直接前驱结点与直接后继结点都变得非常方便了。//定义}LTNode;
【数据结构】带头双向循环链表（小白入门必备知识）
weixin_65186652的博客
08-19 2134
c语言数据结构--带头双向循环链表，小白入门必备知识
数据结构：双向链表（带头循环）
Yikefore的博客
05-11 1001
带头双向循环链表实现的详细介绍，带图解和完整的代码。
【C语言数据结构】双链表详解（带头双向循环链表）
dhgiuyawhiudwqha的博客
04-05 2192
我们把要存放的数据类型重命名，接着定义一个含有三个参数的结构体，分别用于存放数据，指向下一节点与指向上一节点。}ListNode;我们在进行插入操作以及建立头节点的时候都需要进行申请节点的操作，因此我们可以把它分装成一个函数。不管是进行插入还是删除操作，我们都需要传入哨兵位头节点，我们可以把哨兵位头节点的创立也分装成一个函数。然后剩下的的就是链表的通用功能：增删查改，pos位置的插入与删除以及链表的销毁。//双链表申请一个新节点// 创建返回链表的头结点// 双向链表打印。
C语言数据结构之双向循环链表的实例
08-30
C语言数据结构之双向循环链表的实例 在计算机科学中，链表是一种常用的数据结构，它可以动态地分配内存来存储数据，且可以随机访问和插入、删除数据。双向循环链表是一种特殊的链表，它可以同时在链表的头部和尾部...
带头结点的双向循环链表
07-17
总结来说，带头结点的双向循环链表是一种灵活且实用的数据结构，它在C++中的实现涉及节点定义、链表操作的实现以及封装为类。理解并掌握这一数据结构对于提升编程能力，尤其是处理复杂算法问题具有重要意义。
带头结点的双向循环链表数据结构
01-08
用C++和Java实现带头节点的双向循环链表，要继承linearList类，并实现它的所有功能，另外，必须实现双向迭代器。 实现带头节点的双向循环链表，要具有以下的功能： 判断表是否为空，如果为空则返回true，不空返回...
python实现数据结构中双向循环链表操作的示例
12-16
看此博客之前建议先看看B站的视频python数据结构与算法系列课程，该课程中未实现双向循环链表的操作，所以我按照该视频的链表思路实现了双向循环链表的操作，欢迎大家阅读与交流，如有侵权，请联系博主！ 下面附上...
【数据结构】双向带头循环链表
小侯宝的博客
05-12 775
在【数据结构】单链表中提到，链表为数据结构中的一种存储结构，链表属于线性存储结构，同时链表共有八种，此次所讲的链表为双向带头循环链表，属于链表中结构最复杂的结构；带头双向循环链表是链表中带头（哨兵位）、双向、循环三种属性的结合体；带头即带哨兵位哨兵位只负责存储第一个具有有效数据的节点，本身不存放数据，该处因为为双向循环链表，代表也可访问该链表的尾节点；双向即表示，每个节点不仅能访问该节点的后一个节点，同时也可访问本节点的前一个节点；循环即表示，第一个节点的prev指向尾节点；
数据结构------双向带头循环链表
喜欢编写一些小程序的科班菜鸟，但是由于准备考研，博客不能及时更新了，不好意思！
05-13 458
1.什么是双向带头循环链表？模型。 上次写的链表是单向的，就是只去不会，但是我想让他有来有回所以叫单向，带头是创建一个哨兵位头结点，但不影响实际写的链表。循环我就不解释了。 上模型： 2.初始化链表 ListNode* BuyListNode(SLTDateType x) { ListNode* node = (ListNode*)malloc(sizeof(ListNode)); //开辟一个结点 if (node == NULL) { perror(
链表界的“扛把子”—双向带头循环链表
weixin_60718941的博客
04-05 1090
一：链表的分类 链表的分类分为以下几种： 在实际中链表的结构非常多样，以上情况组合起来就有8种链表结构。我们在前面已经讲过最简单的结构：单向无头非循环链表。并且在我们所刷的OJ题里也涉及到了有无头结点情况，今天我们讲解最复杂结构：双向带头循环链表。在我们讲解之前我们先了解一下这两种结构在链表界的重要性。 1：无头单向非循环链表： 结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。 2：带头双向循环链表： 结.
数据结构-带头双向循环链表
m0_61433144的博客
07-18 1442
链表的种类非常丰富，有带头结点的或不带头结点的，有单向的或双向的，有循环的或非循环的，这样组合起来有2*2*2=8种链表结构。头结点与头指针的概念：不管带不带头结点，头指针都始终指向链表的第一个结点，而头结点是带头链表中第一个结点，该结点通常不存储数据。 引入头结点可以带来两个优点：1.由于第一个数据结点的位置被存储在头结点的指针域中，因此在链表的第一个位置上的操作和在链表其他位置上的操作一致，无须进行特殊处理。2.无论链表是否为空，其头指针都指向头结点，因此空表与非空表的处理也得到统一。........
带头节点的双向循环链表的基本操作
热门推荐
Ksaila的博客
08-30 1万+
双向循环链表： 双向循环链表中每一个节点都有一个直接的前驱和一个直接的后继 双向循环链表中的节点有两个指针域和一个存放数据的地方，两个指针域一个存放下一个节点的地址，一个存放前一个指针的地址 下面是双向循环链表的基本操作： CircularList.h #ifndef _LINKLIST_H_ #define _LINKLIST_H_ #include&lt;stdlib.h...
带头双向循环链表的实现
weixin_42307601的博客
07-31 257
双向链表 我们在学习了单链表和双链表之后，可以很明显的感受到，单链表因为只能单一的指向后继结点，想要找到前驱就不容易，因此，引入双向链表，当用单链表来进行插入删除时，显得比较麻烦,而带头双向循环链表就可以很好的解决这个问题，首先来看一下双向链表的结构： 首先定义了一个头结点，当只有一个头结点时，这里注意的是，头结点的next 和prev不再指向NULL 而是指向自己，这样就构成了一个双向循环带头...
带头双向循环链表
xiami
11-12 78
#pragma once typedef int DLDataType; typedef struct DListNode { struct DListNode* _pPre; struct DListNode* _pNext; DLDataType _data; }DLNode,*PDLNode; void DListInit(PDLNode* pHead); void DList...
带头节点的双向循环链表基本操作 --- (尾插，尾删，查找节点，指定位置插入，指定位置删除)
阿巴卡的博客
08-16 4291
链表分为单向链表和双向链表，前两篇都是关于单向链表的函数，这篇是有关双向循环链表的函数， 首先，我们我要知道双向循环链表长什么样子 双向循环链表结构体： typedef int DataType; typedef struct DListNode { struct DListNode* _pNext; struct DListNode* _pPre; Dat...
双向循环链表（带头）
weixin_44024891的博客
06-12 289
一般来说， 链表我们用的最多的是不带头单向链表 和 带头双向循环链表。 所谓带头与不带头的区别在于头结点是否存储数据。 1、带头意味着头结点不会真正存放结点信息， 一般存放一些记账信息（例如链表多长等） 2、不带头意味着会真正存放结点信息。 （但是请注意实现的时候我们还是会创建一个结点用来管理 – 为了方便实现） 在这里我讲一个小技巧， 用来区分带头与不带头。 在init初始化的时候， 带头的会开辟空间， 不带头会置为nullptr。 (置为nullptr的话，方便插入元素的时候判断头结点是否为空。) 双向
双向带头循环链表的介绍与实现
LiangXiay的博客
10-29 356
双向带头循环链表是结构上最为复杂的一种链表，但是正是因为其结构复杂，也给这种链表带来了其他链表所没有的优势。今天我们就介绍一下双向带头循环链表并且完成其构建。 1.双向 带头 循环都是什么意思？ 2.双向带头循环链表的结构 ...
数据结构-双向循环链表
最新发布
10-23
双向循环链表的节点结构包含三个部分：数据域、前驱指针和后继指针。其中，前驱指针指向前一个节点，后继指针指向后一个节点。在双向循环链表中，头节点的前驱指针指向尾节点，尾节点的后继指针指向头节点。 双向...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

待己以诚

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值