【C实现数据结构】双向带头循环链表的实现（增删查改，判空，销毁）

已于 2023-09-13 11:30:17 修改
阅读量411 收藏 5
点赞数 6
文章标签： 链表 数据结构 c语言
于 2023-04-06 14:10:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72575802/article/details/129898077
版权

文章目录

关于带表头的单链表的实现->带表头的单链表

一、双向（带头）循环链表的作用

典型的面恶心善的数据结构
乍一看，似乎结构在几种链表里最复杂，然而其实际的实现并没有困难到哪里去，反而因为其优秀的双向循环结构可以支持 O(1) 时间复杂度的情况下找到前驱结点，双向链表在多数情况下的插入、删除等操作都要比单链表简单、高效。

单独存储数据相较于其他链表也是更优的选择
222

二、基本的实现

1.基本的函数声明（DList.h）

基本的增删查改，与创建与摧毁链表

  • 增【头插，尾插(可用更普遍的前插，后插来代替)】
  • 删【头删，尾删，根据数据删除】
  • 查（配合插入使用）
  • 改 （修改节点存储数据，本处简写）
  • 创建表头节点 不存储数据
  • 摧毁 释放整条链表（包括表头），防止内存泄漏
#include<stdio.h>
#include<stdbool.h>
#include<stdlib.h>
#include<assert.h>

//本链表为双向带头链表
#pragma once
typedef int LTDataType;//存储的数据类型，方便统一修改
typedef struct ListNode
{
	LTDataType data;
	struct ListNode* next;
	struct ListNode* prev;
}ListNode;

// 创建返回链表的头结点.
ListNode* ListCreate();
//创建节点
ListNode* BuyNode(LTDataType x);
// 双向链表销毁
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);
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos);
//看链表除了表头是否为空
bool IsEmpty(ListNode* pHead);
// 双向链表在pos的前面进行插入
void ListInsertFront(ListNode* pos, LTDataType x);
//后插
void ListInsertBack(ListNode* pos, LTDataType x);
//修改
void ListModify(ListNode* pos, LTDataType x);

2.表头/节点的创建

两函数并无本质区别，但表头不用于存储数据，所以加以区别
另外，创建循环链表的节点时切记将新节点的next prev都指向自身，作为最小的循环单元参与程序以避免意想不到的NULL指针

ListNode* ListCreate() {
	ListNode* Head=(ListNode*)malloc(sizeof(ListNode));
	if (Head == NULL)
	{
		perror("malloc error：");
			exit(-1);
	}
	Head->next = Head;//形成循环
	Head->prev = Head;

	return Head;
}

ListNode* BuyNode(LTDataType x) {//创建节点
	ListNode* node = (ListNode*)malloc(sizeof(ListNode));
	if (node == NULL)
	{
		perror("malloc error：");
		exit(-1);
	}
	node->next = node;//形成循环
	node->prev = node;
	node->data = x;
	return node;
}

3.判断链表是否为空

实质在判断链表中是否存在两个及以上节点（包括表头）
无论传址是否为表头都不影响判断

bool IsEmpty(ListNode* pHead) {
	assert(pHead);
	ListNode* cur = pHead->next;
	if (cur != pHead)
		return false;
	else
		return true;
}

更加简便的写法：

bool IsEmpty(ListNode* pHead) {
assert(pHead);
return pHead->next==pHead;
}

4.插入（头插 尾插 前插 后插）

表头的存在为插入的前提判断带来了方便。尾插头插不用考虑链表为空时的特殊情况。
头插，尾插只是插入的特殊情况，往往都可以使用普遍的插入函数来代替实现；写在此处只是为了方便更好的理解

  • 头插
void ListPushFront(ListNode* pHead, LTDataType x) {//头插
	assert(pHead); //若不是有表头的双向链表 则可以不用断言 但此时尾插头插代码里必须加入判断链表是否为空 进行分支执行
	ListNode* newnode = BuyNode(x);
	pHead->next->prev = newnode;
	newnode->next = pHead->next;//具体代码实现
	newnode->prev = pHead;
	pHead->next = newnode;
	
	//ListInsertBack(pHead,x);//利用后插实现
	//ListInsertFront(pHead->next, x);//利用前插实现
}
  • 尾插
void ListPushBack(ListNode* pHead, LTDataType x) {//尾插
	assert(pHead);                          
	ListNode* newnode = BuyNode(x);//注释同头插
	pHead->prev->next = newnode;//直接使用前节点
	newnode->prev = pHead->prev;//具体代码实现
	newnode->next = pHead;
	pHead->prev = newnode;

	//ListInsertFront(pHead,x);//利用前插实现尾插
	//ListInsertBack(pHead->prev, x);//后插实现尾插
}
  • 前插
void ListInsertFront(ListNode* pos, LTDataType x) {//插到前面
	assert(pos);
	ListNode* newnode = BuyNode(x);
	pos->prev->next = newnode;
	newnode->prev = pos->prev;
	newnode->next = pos;
	pos->prev = newnode;
}
  • 尾插
void ListInsertBack(ListNode* pos, LTDataType x) {
	assert(pos);
	ListNode* newnode = BuyNode(x);
	pos->next->prev = newnode;
	newnode->next = pos->next;
	pos->next = newnode;
	newnode->prev = pos;
}

5.删除（头删 尾删 普遍的删除）

  • 头删
void ListPopFront(ListNode* pHead) {
	assert(pHead);
	if (IsEmpty(pHead))
		return;
	else
	{
		ListNode* front = pHead->next->next;
		free(pHead->next);//同尾删
		pHead->next = front;
		front->prev = pHead;
	}
	//ListErase(pHead->next);
}
  • 尾删
void ListPopBack(ListNode* pHead){//尾删
	assert(pHead);
	if (IsEmpty(pHead))//空链表 不再删除
		return;
	else
	{
		ListNode* end = pHead->prev->prev;
		end->next = pHead;
		free(pHead->prev);//释放该指针指向的地址，该指针任然存在
		pHead->prev = end;
	}
	//ListErase(pHead->prev);	
}
  • 通用的删除
void ListErase(ListNode* pos) {
	assert(pos);
	if (IsEmpty(pos))//pos为表头时 不执行；非表头时，不可能为空; 加上是为了可以替换尾删 头删
		return;
	else 
	{
		ListNode* prev0 = pos->prev;
		ListNode* next0 = pos->next;
		prev0->next = next0;
		next0->prev = prev0;
		free(pos);
	}
}

6.查找与修改

  • 查找
ListNode* ListFind(ListNode* pHead, LTDataType x) {//最简单形式，只找到第一个相同数据的节点
	assert(pHead);
	ListNode* cur = pHead->next;
	while (cur != pHead)
	{
		if (cur->data == x)
			return cur;
		cur = cur -> next;
	}
	printf("未查询到该数据：%d", x);
	return NULL;
}
  • 修改（实际使用往往不仅仅存储一个数据，而是用结构体存储一类数据，此处为简写）
//void ListModify(ListNode* pos, LTDataType x) {//修改节点数据
//	assert(pos);
//	pos->data = x;
//}

7.销毁链表（手动释放内存）

在某一结构确定不再使用时，手动释放内存极为重要。 虽然在程序结束后系统会自动释放内存，但在如服务器等长期运行的环境中，程序往往不会或很久才会停止一次，此时未进行手动的释放内存很容易导致严重的内存泄漏

void ListDestory(ListNode* pHead) {
	assert(pHead);
	
		ListNode* cur = pHead->next;
		ListNode* f=NULL ;
		while (cur != pHead)
		{
			f = cur;
			cur = cur->next;
			free(f);
		}

		free(pHead);//不要忘记释放表头 如链表为空，cur一开始就==pHead
}

三、源码汇总

#include"DList.h"

//本链表为双向带头链表

ListNode* ListCreate() {
	ListNode* Head=(ListNode*)malloc(sizeof(ListNode));
	if (Head == NULL)
	{
		perror("malloc error：");
			exit(-1);
	}
	Head->next = Head;//形成循环
	Head->prev = Head;

	return Head;
}

ListNode* BuyNode(LTDataType x) {//创建节点
	ListNode* node = (ListNode*)malloc(sizeof(ListNode));
	if (node == NULL)
	{
		perror("malloc error：");
		exit(-1);
	}
	node->next = node;//形成循环
	node->prev = node;
	node->data = x;
	return node;
}

bool IsEmpty(ListNode* pHead) {
	assert(pHead);
	ListNode* cur = pHead->next;
	if (cur != pHead)
		return false;
	else
		return true;
}

void ListPrint(ListNode* pHead)
{
	assert(pHead);
	printf(" >= Head =>");
	ListNode* cur=pHead->next;
	while (cur != pHead)
	{
		printf("%d =>", cur->data);//如果LTDataType 改变，printf输出时打印的数据类型也要改变
		cur = cur->next;
	}
	printf("\n");

}
void ListPushBack(ListNode* pHead, LTDataType x) {//尾插(默认有表头，或头结点不为NULL)
	assert(pHead);                           //若不是有表头的双向链表 则可以不用断言 但尾插头插代码里必须加入判断链表是否为空 进行分支执行
	ListNode* newnode = BuyNode(x);
	pHead->prev->next = newnode;//直接使用前节点
	newnode->prev = pHead->prev;//具体代码实现
	newnode->next = pHead;
	pHead->prev = newnode;

	//ListInsertFront(pHead,x);//利用前插实现尾插
	//ListInsertBack(pHead->prev, x);//后插实现尾插
}

void ListPopBack(ListNode* pHead){//尾删
	assert(pHead);
	if (IsEmpty(pHead))//空链表 不再删除
		return;
	else
	{
		ListNode* end = pHead->prev->prev;
		end->next = pHead;
		free(pHead->prev);//释放该指针指向的地址，该指针任然存在
		pHead->prev = end;
	}

	//ListErase(pHead->prev);
	
}

void ListPushFront(ListNode* pHead, LTDataType x) {//头插(默认有表头，或头结点不为NULL)
	assert(pHead);//注释同尾插
	ListNode* newnode = BuyNode(x);
	pHead->next->prev = newnode;
	newnode->next = pHead->next;//具体代码实现
	newnode->prev = pHead;
	pHead->next = newnode;
	
	//ListInsertBack(pHead,x);//利用后插实现
	//ListInsertFront(pHead->next, x);//利用前插实现
}

void ListPopFront(ListNode* pHead) {
	assert(pHead);
	if (IsEmpty(pHead))
		return;
	else
	{
		ListNode* front = pHead->next->next;
		free(pHead->next);//同尾删
		pHead->next = front;
		front->prev = 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;
	}
	printf("未查询到该数据：%d", x);
	return NULL;
}

void ListInsertFront(ListNode* pos, LTDataType x) {//插到前面
	assert(pos);
	ListNode* newnode = BuyNode(x);
	pos->prev->next = newnode;
	newnode->prev = pos->prev;
	newnode->next = pos;
	pos->prev = newnode;
}

void ListInsertBack(ListNode* pos, LTDataType x) {
	assert(pos);
	ListNode* newnode = BuyNode(x);
	pos->next->prev = newnode;
	newnode->next = pos->next;
	pos->next = newnode;
	newnode->prev = pos;
}

void ListErase(ListNode* pos) {
	assert(pos);
	if (IsEmpty(pos))//pos为表头时 不执行；非表头时，不可能为空; 加上是为了可以替换尾删 头删
		return;
	else 
	{
		ListNode* prev0 = pos->prev;
		ListNode* next0 = pos->next;
		prev0->next = next0;
		next0->prev = prev0;
		free(pos);
	}
}

//void ListModify(ListNode* pos, LTDataType x) {//修改节点数据
//	assert(pos);
//	pos->data = x;
//}

void ListDestory(ListNode* pHead) {
	assert(pHead);
	
		ListNode* cur = pHead->next;
		ListNode* f=NULL ;
		while (cur != pHead)
		{
			f = cur;
			cur = cur->next;
			free(f);
		}

		free(pHead);//不要忘记释放表头 如链表为空，cur一开始就==pHead
}
Dandely_蒲公英
关注
  • 6
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
双向链表创建插入删除销毁等
11-29
双向链表，创建，插入，删除，销毁等，写的一个代码（包括详细的注释，初学者都看得懂），已经成功测试。及拿即用。
2.3.5 双链表的销毁操作
qq_62642833的博客
04-14 116
1.while循环，只要头结点的后继结点不为空，就删除一次它的后继结点。2.直到只剩头结点，然后把头结点释放掉。3.然后让头指针指向NULL。
带头结点双向循环 -- 双向链表
qq_53010164的博客
04-06 2940
一、双向链表初始化 图解：phead链表的最后一个节点要指向第一个节点，第一个节点要指向最后一个节点，而第一个节点和最后一个节点都是第一个节点，所以phead->next = phead->prev = phead; 代码： LTNode* InitList() { //带头节点，循环链表 //哨兵位头结点 LTNode* phead = (LTNode*)malloc(sizeof(LTNode)); phead->next = phead->prev = phe
精讲双向链表的销毁
最新发布
X_do_myself的博客
02-07 629
关关难过，关关过！
双向链表的创建-插入-删除-遍历-销毁操作
Comme_un_chien的博客
07-04 768
#include<iostream> using namespace std; /* 循环链表：将单链表的终端节点的指针端由空指针改为指向头节点，即头尾相接 双向循环链表：每个节点保存指向前驱节点的指针 两个表： head->A->B->C->D->E->F->head head->a->b->c->d->e->f->head 合成为一个循环链表的思路： 1、将尾指针指向第二个链表的首节点 2、将第二个链表的.
C语言如何建立链表并实现增删查改详解
08-25
主要给大家介绍了关于C语言如何建立链表并实现增删查改的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用C语言具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
C语言之航空信息查询系统-使用双向循环链表实现系统的增删改查操作
09-20
C语言之航空信息查询系统-使用双向循环链表实现系统的增删改查操作
C语言数据结构之双向循环链表的实例
08-30
主要介绍了C语言数据结构之双向循环链表的实例的相关资料,需要的朋友可以参考下
python实现数据结构中双向循环链表操作的示例
12-16
看此博客之前建议先看看B站的视频python数据结构与算法系列课程，该课程中未实现双向循环链表的操作，所以我按照该视频的链表思路实现了双向循环链表的操作，欢迎大家阅读与交流，如有侵权，请联系博主！ 下面附上...
双向链表的初始化销毁插入删除
Andy_chen1990的博客
05-10 314
初始化 ： 头结点 尾结点 都赋值为空删除 ： 判定条件链表长度做判断条件 删除 释放 插入： 1，给一个结点后面插入 2，在一个结点前面插入 1）a,分配结点失败 返回 -1 b, 链表长度为0. 头部尾部都链接新结点，最后将新结点的头部尾部置为空 正常的插入四步 也得判断一下被插入结点 下一个结点是否为空 2）a,...
双向链表的创建、增加和删除，销毁
changke的博客
06-10 4968
双向链表的创建，增加，删除和查看 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; typedef struct student{ int id; char name[20]; struct student*pre,*next; }Student; Student* Create();//创建双向循环链表 void Pr...
数据结构C语言-双链表的定义、销毁及增删改查
T1cH9的博客
06-08 847
学习自用
双向链表的创建、打印、求长、插入、删除、查值、清空、销毁
刘明的博客
06-11 834
删除双向链表中的最后一个结点需单独对待 doublyLinkedList.h #include "iostream" using namespace std; typedef struct DuLNode { int data; struct DuLNode *prior; struct DuLNode *next; }DuLNode, *DuLinkedList; //创建链表 bo
_02-祖玛大消除
wl7777777777的博客
10-19 981
题意： 如果射出的球击中球链，且此时生成的新链中相同颜色的球大于等于3个。则这些球可以被消除。 例如，你有一串链是：112233。此时你射出一个2的球，球击中了链中的第一个2（第3个球），此时链变成：1122233 因为中间的2有3个，满足消除的条件，他们会被消除，于是你获得： 1133 消除可以连击，例如：11221133，射出2还是击中第一个2。此时链变成112221133，消除2后，链变成： 111333 前后两串1拼接在一起后，形成四个1，又满足消除条件，继续消除，得到：
C 双向循环链表：创建、插入、遍历、求长、查找、删除、排序、销毁
Bryan_QAQ的博客
07-10 2276
C 双向链表：创建、插入、遍历、求长、查找、删除、排序、销毁 一、双向链表存在的意义 数组这样的结构提供了连续内存的访问和使用，链表是对内存零碎空间的有效组织和使用，双向循环链表增大了访问的自由度。 ...
双链表的定义、初始化、插入、删除和销毁
youngurt的博客
05-15 573
1.双链表定义 //双链表定义 typedef struct DNode{ ElemType data; //数据域 struct DNode *prior, *next; //前驱和后继指针 }DNode, *DLinkList; 2.初始化双链表 //初始化双链表 bool InitDLinkList(DLinkList &L){ L = (DNode *)malloc(sizeof(DNode)); //创建头结点 if(L==NULL) return false; //内存
【DS双向链表—祖玛】
sjdxcg的博客
12-13 412
个人总结思考
【id:43】【8分】L. DS双向链表—祖玛
归忆_AC的博客
07-11 226
祖玛是一款曾经风靡全球的游戏，其玩法是：在一条轨道上初始排列着若干个彩色珠子，其中任意三个相邻的珠子不会完全同色。若插入前共有m颗珠子，位置0-m-1，则k ∈ [0, m]表示新珠子嵌入在轨道上的位置。给定轨道上初始的珠子序列，然后是玩家所做的一系列操作。你的任务是，在各次操作之后及时计算出新的珠子序列。第一行是一个由大写字母'A'~'Z'组成的字符串，表示轨道上初始的珠子序列，不同的字母表示不同的颜色。输出共n行，依次给出各次操作（及可能随即发生的消除现象）之后轨道上的珠子序列。
【数据结构】线性表之双链表（增删查改等）
丨归凡的博客
08-02 327
完美解决顺序表和单链表的缺陷——双向带头循环链表
数据结构链表增删查改
07-28
链表是一种常见的数据结构，它由一个个节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。对于链表的增删查改操作，可以按照以下方式进行： 1. 增加节点：在链表中插入新的节点。要插入一个新节点，需要修改上一个节点的指针，使其指向新节点，并将新节点的指针指向原先下一个节点。 2. 删除节点：从链表中删除指定的节点。要删除一个节点，需要修改上一个节点的指针，使其指向下一个节点，跳过待删除的节点。 3. 查找节点：在链表中查找指定的节点。可以遍历链表，依次比较每个节点的数据元素，直到找到匹配的节点或到达链表末尾。 4. 修改节点：修改链表中指定节点的数据元素。可以先查找到待修改的节点，然后更新其数据元素。 需要注意的是，在链表中插入、删除和修改操作时，需要注意边界条件和特殊情况，比如插入或删除头节点、尾节点或链表为空的情况。 这只是链表的基本操作，实际应用中可能还会有其他操作和优化方式。希望这些信息能对你有所帮助！如果你还有其他问题，请继续提问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值