[C语言数据结构]双向循环链表

已于 2022-11-10 20:06:51 修改
阅读量1.9k 收藏 14
点赞数 9
分类专栏： C语言 数据结构 文章标签： 链表 数据结构 c语言
于 2022-11-10 20:04:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61766635/article/details/127716053
版权

目录

💊1.双向循环链表：

💊1.1何为双向循环链表

💊1.2双向循环链表的实现

💊1.2.1结构体的创建

💊1.2.2双向循环链表的初始化

💊1.2.3双向链表的尾插

void  LTPushBack(LTNode* phead, LTDataType x);

💊1.2.4双向链表的尾部删除

💊1.2.5双向链表的头插

💊1.2.6双向链表的数据的打印

💊1.2.7双向链表的头部删除数据

💊1.2.8双向链表寻找数据

💊1.2.9在双向链表的任意位置插入数据

💊1.2.10在双向链表的任意位置删除数据

引:上次我们学习了单链表的实现，相对于双向循环链表来说，单链表的各中操作，比如说增删查改等都显得非常麻烦。所以接下来来学习一下双向循环链表吧！

💊1.双向循环链表：

💊1.1何为双向循环链表

 如上所示：每个节点都有包含有两个指针域和一个数据域；
两个指针域一个存储前一个节点的地址，另一个存储下一个节点的地址；

这种结构虽然看起来比单链表复杂一些，但是可以简化一系列后来的增删查改的操作；

💊1.2双向循环链表的实现

💊1.2.1结构体的创建

这个结构体的创建和单链表的结构体的创建是大同小异，我们需要两个指针域，一个数据域；

代码：

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

💊1.2.2双向循环链表的初始化

LTNode* InitList(LTNode* Phead);

这个函数实现的双向循环链表的初始化功能，函数参数的话这边选择了一级指针和单链表的初始化函数不同，单链表所使用的是二级指针；而且初始化函数内部也有所不同；

代码：

//申请节点函数
LTNode* BuyListNode(LTDataType x)
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	node->data = x;
	node->next = node->prev = NULL;
	return node;
}

//初始化双向链表
LTNode* InitList(LTNode* phead)
{
	phead = BuyListNode(-1);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}

💊1.2.3双向链表的尾插

void  LTPushBack(LTNode* phead, LTDataType x);

对于双向循环链表来说，它的尾插非常简单，因为它不需要去遍历链表来找到链表的尾部节点；

代码：

//双向链表的尾插
void  LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);

	LTNode* newnode = BuyListNode(x);
	LTNode* tail = phead->prev;

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

💊1.2.4双向链表的尾部删除

双向链表的尾部删除的和尾部插入同样简单，因为它不需要遍历链表，只需要进行相应的链接操作即可。

代码：

//双向链表的尾部删除
void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);

	LTNode* tail = phead->prev;
	LTNode* tailprev = tail->prev;

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

💊1.2.5双向链表的头插

链表的头插相对于单链表来说复杂程度不相上下，但也不难，因为有哨兵位节点的存在，在连接节点的时候还是相对方便的；

代码：

//双向链表的头插
void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);

	LTNode* newnode = BuyListNode(x);
	newnode->next = phead->next;
	phead->next->prev = newnode;

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

💊1.2.6双向链表的数据的打印

函数的实现非常简单，简单的遍历链表即可，唯一需要注意到的点就是我们什么时候停下来；

代码：

//双向链表的打印
void LTPrint(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

💊1.2.7双向链表的头部删除数据

双向链表头部删除数据很简单，只需要将phead->next删除之后再将phead->next->next和phead链接起来即可；

代码：

void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead->next != NULL);
	LTNode* first = phead->next;
	LTNode* second = first->next;

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

💊1.2.8双向链表寻找数据

方法和单链表是类似的，只是判断停止的条件不同；

代码：

//双向链表中寻找数据
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;
}

💊1.2.9在双向链表的任意位置插入数据

这里我们实现的是在这个位置前进行插入数据，逻辑非常简单。

分两个步骤：①申请空间；        ②链接节点；

代码：

//在双向链表的任意位置插入数据
void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* newnode = BuyListNode(x);
	LTNode* pre = pos->prev;

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

对此函数我们可以实现复用，重新构建头插和尾插：

//双向链表的头插
void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTInsert(phead->next, x);
}
//双向链表的尾插
void  LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTInsert(phead, x);
}

💊1.2.10在双向链表的任意位置删除数据

这个函数我们实现的就是删除传入地址的节点，大的步骤也是分两个，先记录这个节点的前一个节点和后一个节点，然后free掉这个节点后，再链接；

代码：

//在双向链表的任意位置删除数据
void LTErase(LTNode* pos)
{
	assert(pos);
	LTNode* pre = pos->prev;
	LTNode* next = pos->next;
	free(pos);
	pre->next = next;
	next->prev = pre;
}

对此函数进行复用，改进头删和尾部删除函数：

代码：

//双向连边头部删除数据
void LTPopFront(LTNode* phead)
{
	assert(phead);
	LTErase(phead->next);
}
//双向链表的尾部删除
void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);
	LTErase(phead->prev);
}

代码汇总：

#pragma once
#include<stdio.h>
#include<assert.h>
#include<stdbool.h>

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

//初始化双向链表
LTNode* InitList();

//获取新的节点
LTNode* BuyListNode(LTDataType x);

//双向链表的尾插
void  LTPushBack(LTNode* phead, LTDataType x);

//双向链表的尾部删除
void LTPopBack(LTNode* phead);


//双向链表的头插
void LTPushFront(LTNode* phead, LTDataType x);

//双向链表的打印
void LTPrint(LTNode* phead);

//双向连边头部删除数据
void LTPopFront(LTNode* phead);

//双向链表中寻找数据
LTNode* LTFind(LTNode* phead, LTDataType x);

//在双向链表的任意位置插入和删除数据
void LTInsert(LTNode* pos, LTDataType x);
void LTErase(LTNode* pos);

//双向链表的判空
bool LTEmpty(LTNode* phead);

//双向链表大小的计算
size_t LTSize(LTNode* phead);

//双向链表的销毁
void LTDestroy(LTNode* phead);

#define _CRT_SECURE_NO_WARNINGS 1
#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 = node->prev = NULL;
	return node;
}

//初始化双向链表
LTNode* InitList()
{
	LTNode* phead = BuyListNode(-1);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}

//双向链表的尾插
void  LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);

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

	//tail->next = newnode;
	//newnode->prev = tail;
	//phead->prev = newnode;
	//newnode->next = phead;
	LTInsert(phead, x);
}

//双向链表的尾部删除
void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);

	//LTNode* tail = phead->prev;
	//LTNode* tailprev = tail->prev;

	//tailprev->next = phead;
	//phead->prev = tailprev;
	//free(tail); 
	LTErase(phead->prev);
}

//双向链表的头插
void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);

	//LTNode* newnode = BuyListNode(x);
	//newnode->next = phead->next;
	//phead->next->prev = newnode;

	//phead->next = newnode;
	//newnode->prev = phead;
	LTInsert(phead->next, x);
}

//双向链表的打印
void LTPrint(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

//双向连边头部删除数据
void LTPopFront(LTNode* phead)
{
	assert(phead);
	//assert(phead->next != NULL);
	//LTNode* first = phead->next;
	//LTNode* second = first->next;

	//free(first);
	//phead->next = second;
	//second->prev = phead;
	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;
}

//在双向链表的任意位置插入和删除数据
void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* newnode = BuyListNode(x);
	LTNode* pre = pos->prev;

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

void LTErase(LTNode* pos)
{
	assert(pos);
	LTNode* pre = pos->prev;
	LTNode* next = pos->next;
	free(pos);
	pre->next = next;
	next->prev = pre;
}

//双向链表的判空
bool LTEmpty(LTNode* phead)
{
	assert(phead);
	return phead->next != phead;
}

//双向链表大小的计算
size_t LTSize(LTNode* phead)
{
	assert(phead);
	size_t x = 0;
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		x++;
		cur = cur->next;
	}
	return x;
}

//双向链表的销毁
void LTDestroy(LTNode* phead)
{
	assert(phead);

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

#define _CRT_SECURE_NO_WARNINGS 1
#include"List.h"


int main()
{
	LTNode* phead = InitList();
	LTPushBack(phead, 1);
	LTPushBack(phead, 2);
	LTPushBack(phead, 3);
	LTPushBack(phead, 4);
	LTPushBack(phead, 5);
	LTPrint(phead);
	LTPrint(phead);
	LTNode* x = LTFind(phead, 3);
	if (x)
	{
		x->data = 100;
		LTPrint(phead);
	}
	LTPopBack(phead);
	LTPrint(phead);
	printf("%d\n", LTSize(phead));
	LTDestroy(phead);
	return 0;
}

以上就是双向循环链表表的实现和各个函数需要注意的细节，如果有错误可以在评论区指正！ 

 

SummerM.
关注
专栏目录
c语言_数据结构_双向循环链表
SahPah的专栏
08-13 2058
双向循环链表与单向循环链表的区别在于，每个节点的指针域中除了有指向下一结点的next指针外，还有指向前一结点的prev指针：   在链表中，中间部分结点的next指针指向其直接后继结点，prev指针指向其直接前继结点。与单向循环链表相同，末结点的next指针不再指向NULL,而是指向头结点Head，而头结点的prev则指向末结点。 将新结点new插入到p所指向的结点之后：
C语言_双向循环链表的基本操作
A__B__C__的博客
09-11 1841
目录： 1、初始化 2、头部插入 3、头部删除 4、尾部插入 5、尾部删除 6、打印链表 7、任意位置插入 8、查找值为data的节点 9、指定位置删除 10、销毁链表 1、初始化： 创建一个节点，给节点赋值为0；因为是循环链表，所以让它的_pNext指针域和_pPre 指针域都指向自己 void DCListInit ...
c语言 链表 双向链表 双向循环链表
02-26
从linux内核移植出来，独立于用户数据结构，里面有实例参考。C语言代码。
【数据结构-C语言】双向循环链表
sakura0908的博客
03-02 1819
对链表而言，双向均可遍历是最方便的，另外首尾相连循环遍历也可打打增加链表操作的便捷性。因此，双向循环链表，是在实际运用中最常见的链表形态。
C语言双向循环链表
qq_45911878的博客
08-07 4553
C语言单向链表正向、反向、排序插入和链表逆转。
【C语言】双向循环链表
m0_47329175的博客
06-15 1407
引言 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 双向链表 双向链表节点 typedef int CycleList_Data; typedef struct Cycle_Node { CycleList_Data data; struct Cycle_Node* front; struct Cycle_Node* next; }Cycl
【C语言数据结构】双向循环链表
W1024201的博客
03-08 6974
目录 前言 一、双向循环链表 循环结构 1.双向循环链表头文件及函数声明 2.初始化 1.结点构造 2.初始化函数 3.结点申请 4.数据插入 1.按位置插入 2.尾插 3.头插 5.查找 6.数据删除 1.按位置删除 2.按值删除 3.尾删 4.头删 7.清空与销毁 1.清空 2.销毁 8.双向循环链表源文件及整体函数实现 总结 前言 这次我们将学习双向循环链表，首先了解双向链表和循环链表的定义和讲解。 双向链表也叫双链...
C语言数据结构——双向循环链表
weixin_44230855的博客
07-25 360
双向循环链表，就是在单链表的基础上加了一个前驱指针，链表首尾相连。 编译器：vc6 #include<stdio.h> #include<stdlib.h> //定义双向链表结构体 typedef struct student{ int score; struct student *next,*prio; } LinkList; //定义一个创建双向链表的方法 /* 传入链表长度 返回链表指针 */ LinkList *CreatLinkList(int n){
C语言数据结构双向循环链表
09-27
在C语言中，实现双向循环链表需要定义一个链表节点结构体，其中包含指向前驱节点和后继节点的指针，以及存储数据的成员。以下是一个示例的C语言代码来初始化一个双向循环链表： ``` typedef int LTDataType; ...
C语言|数据结构-双向循环链表
最新发布
qq_48757222的博客
01-21 503
类似类的方法操作，可以用函数指针来完成操作int size;// 函数指针 RetValueType (Pointer* Force Transfer)(Parameter List);}LLIST;则 在创建时就可以// 由于 循环列表 则只设置 两种模式 头插 或者 尾插LLIST *new;//！！！//双向循环链表 只有头，则 自己指向自己return new;//！！！//双向循环链表 只有头，则 自己指向自己return new;
C语言数据结构之双向循环链表的实例
08-30
C语言数据结构之双向循环链表的实例 在计算机科学中，链表是一种常用的数据结构，它可以动态地分配内存来存储数据，且可以随机访问和插入、删除数据。双向循环链表是一种特殊的链表，它可以同时在链表的头部和尾部...
c语言下的双向循环链表
qq_41256954的博客
04-01 656
二.双向循环链表 1.概念 双向循环链表的节点包含一个数据域，两个指针域，一个指针域指向上一个节点，另一个指针域指向下一个节点 这样双向循环链表构成了两个相反方向遍历的圆环 双向循环链表与单链表相比，提高了访问的效率，也付出了多维护一个指针的代价 双向循环链表的插入和删除操作比单向链表复杂，查找和修改和单向链表的算法一样 2.排序 对于链表的排序一般使用插入法排序 （1）取出一个元素，自然有序 ...
C语言实现双向循环链表
labrary的专栏
03-29 690
2009-04-16 21:45:56 这种方法见到过，也用过，转载过来记录一下： 原文地址：http://blog.chinaunix.net/uid-20696246-id-1892194.html /* 双向循环链表，带头指针 */ struct list_node {     s
循环双链表（C语言实现）
Mr_John
10-27 371
#include<stdio.h> #include<stdlib.h> #include<stdbool.h> typedef int DataType; typedef struct Node { DataType data; // 数据域 struct Node * prior; // 前趋指针 struct Node * next; // 后继指针 }Li...
c语言双向循环链表
weixin_33694172的博客
06-07 98
双向循环链表,先来说说双向链表,双向链表也叫双链表,是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点.而循环链表之前也有说过,单链表中就是让最后一个结点的指针指向第一个结点就能构成一个循环链表,这里其实也是一样的,只不过多了一步,让第一个结点的前驱指向最后一个结点就行了,(这里介绍的是带头结点的...
c语言数据结构双向循环链表操作题目
Starry_皮皮星
03-26 2811
【问题描述】输入n个整数，创建一个双向循环链表进行存储。这些整数从第二个开始，递增有序（设a2<a3<...<an） (ai为第i个整数)。试编写程序，创建双向循环链表，依次将输入的整数存储在该链表的各节点中。然后，将第一个结点删除并插入链表中的适当位置，使整个链表递增有序。 【输入形式】先输入整数的个数，再输入整数列。 【输出形式】以整数递增的顺序，依次输出双向循环链表各个节点...
双向循环链表C语言
qq_18431031的博客
03-01 174
#include <stdio.h> #include <stdlib.h> struct doubleList { int data; struct doubleList* front; struct doubleList* rear; }; struct doubleList* createList() { struct doubleList* headNode...
c语言之双向循环链表
qq_41555580的博客
05-03 202
//c语言之双向循环链表 #include<stdio.h> #include<malloc.h> typedef struct Student{ int data; struct Student *Next; struct Student *Prior;// }*PNode,Node; PNode creatlist(){ PNode he...
04 C语言实现双向循环链表
知识改变命运！
11-04 475
04 C语言实现双向循环链表
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

SummerM.

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

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

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

打赏作者

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

抵扣说明：

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

余额充值