C语言实现双向循环链表

于 2023-07-05 15:35:19 发布
阅读量98 收藏
点赞数 2
文章标签： c语言 链表 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_70339595/article/details/131555866
版权

前言

首先呢，我个人是不推荐写链表的，不过作为初学者来说，学会怎么写这个链表确实很重要。那么我们知道，一般的链表都是单链表，就是他是只有next（我们这边叫只有子没有父），如果你要定位到此节点的前一个节点的话，在单链表中就只能循环遍历一遍来找了。

但是在学会了双向循环链表之后，你就不用再担心这个问题了。那么双向循环链表呢，顾名思义，他是一个既有left（parents）父节点指向指针，又有right（son）子节点指向指针的链表结构。

同样的，作者直接把源代码放文章末尾了，有需要的直接拿走不谢！当然作者很希望各位看官能给本人点个小赞，谢谢！

准备工作

首先呢，头文件是经典的stdio和stdlib（这个是用来malloc分配动态堆空间内存的），然后作者多加了一个assert.h，这个是经典防止参数传空值的。

结构体DuLNode就是节点类型，结构体DuLinkList就是链式结构标准写法。

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#define OK 0
#define ERROR -1
typedef int Status;
typedef int ElemType;
typedef struct DuLNode
{
	struct DuLNode* prev;
	struct DuLNode* next;
	ElemType data;
}DuLNode, * PDuLNode;  //12byte 
typedef struct
{
	DuLNode* head;
	int cursize;//个数
}DuLinkList;

 建立节点

在传参时默认父子节点不传值就都为空指针。sizeof就是获取类型内存长度。

//建立节点
DuLNode* Buynode(ElemType val, DuLNode* parg = nullptr, DuLNode* narg = nullptr)
{
	//DuLNode * s = (DuLNode*)malloc(sizeof(*s));
	DuLNode* s = (DuLNode*)malloc(sizeof(DuLNode));   //12
	if (nullptr == s)  // if(s = nullptr)
	{
		exit(EXIT_FAILURE);
	}
	s->prev = (parg == nullptr) ? s : parg;
	s->next = (narg == nullptr) ? s : narg;
	s->data = val;
	return s;
}

 释放节点

由于创建的时候是用malloc创建的，所以在释放时就要用free来回收内存。

//释放节点
void Freenode(DuLNode* q)
{
	free(q);
}

初始化节点

直接利用建立节点的函数Buynode对头结点进行创建。

void InitList(DuLinkList* plist) {
	assert(plist != nullptr);
	plist->cursize = 0;
	plist->head = Buynode(0);
}

 获取长度

//获得长度
int GetSize(DuLinkList* plist)
{
	assert(plist != nullptr);
	return plist->cursize;
}

判断是否为空

//是否为空
bool IsEmpty(DuLinkList* plist)
{
	assert(plist != nullptr);
	return GetSize(plist) == 0;
}

插入链表

在ptr前先建立一个节点s，并使其成为ptr的父指向，然后将s节点所指向的父节点即原本ptr的父节点的子指向从指向ptr改变为指向s。

void InsertPrev(DuLinkList* plist, DuLNode* ptr, ElemType val)
{
	assert(plist != nullptr && ptr != nullptr);
	ptr->prev = Buynode(val, ptr->prev, ptr);
	DuLNode* s = ptr->prev;
	s->prev->next = s;
	plist->cursize++;
}

尾插

这里有人会问，你尾插不应该循环到尾部然后再调用插入函数吗？那作者想告诉你，这是双向循环链表，你忽视了他循环的属性。所谓循环，就是尾部不在指向null，而是直接指向头结点。

这么一来，你从头节点往头结点前面插入不就等同于尾插？没有问题吧？

//尾插
void Push_Back(DuLinkList* plist, ElemType val) {
	assert(plist != nullptr);
	InsertPrev(plist, plist->head, val);
}

头插

放到头结点后面插入不就是头插？没问题吧？

//头插
void Push_Front(DuLinkList* plist, ElemType val) {
	assert(plist != nullptr);
	InsertPrev(plist, plist->head->next, val);
}

打印

//打印
void PrintList(DuLinkList* plist) {
	assert(plist != nullptr);
	DuLNode* p = plist->head->next;
	while (p != plist->head) {
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

查询

//查询
DuLNode* FindValue(DuLinkList* plist, ElemType val) {
	assert(plist != nullptr);
	DuLNode* p = plist->head->next;
	while (p != plist->head && p->data != val) {
		p = p->next;
	}
	if (p == plist->head) {
		p = nullptr;
	}
	return p;
}

删除节点

//删除ptr节点
void Erase(DuLinkList* plist, DuLNode* ptr) {
	assert(plist != nullptr && ptr != nullptr);
	if (ptr == nullptr) return;
	ptr->next->prev = ptr->prev;
	ptr->prev->next = ptr->next;
	Freenode(ptr);
	plist->cursize -= 1;
}

尾删

//删除尾节点
void Pop_back(DuLinkList* plist)
{
	assert(plist != nullptr);
	Erase(plist, plist->head->prev);
}

头删

//删除第一个结点
void Pop_front(DuLinkList* plist)
{
	assert(plist != nullptr);
	Erase(plist, plist->head->next);
}

按数据值删

//删除val值的节点
void Remove(DuLinkList* plist, ElemType val)
{
	assert(plist != nullptr);
	DuLNode* p = FindValue(plist, val);
	if (p != nullptr)
	{
		Erase(plist, p);
	}
}

清空链表

void ClearList(DuLinkList* plist)
{
	assert(plist != nullptr);
	while (!IsEmpty(plist))
	{
		Pop_back(plist);
	}
}

销毁链表

//销毁链表
void DestroyList(DuLinkList* plist)
{
	assert(plist != nullptr);
	ClearList(plist);
	Freenode(plist->head);
	plist->head = nullptr;
}

源代码

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#define OK 0
#define ERROR -1
typedef int Status;
typedef int ElemType;
typedef struct DuLNode
{
	struct DuLNode* prev;
	struct DuLNode* next;
	ElemType data;
}DuLNode, * PDuLNode;  //12byte 
typedef struct
{
	DuLNode* head;
	int cursize;//个数
}DuLinkList;
//建立节点
DuLNode* Buynode(ElemType val, DuLNode* parg = nullptr, DuLNode* narg = nullptr)
{
	//DuLNode * s = (DuLNode*)malloc(sizeof(*s));
	DuLNode* s = (DuLNode*)malloc(sizeof(DuLNode));   //12
	if (nullptr == s)  // if(s = nullptr)
	{
		exit(EXIT_FAILURE);
	}
	s->prev = (parg == nullptr) ? s : parg;
	s->next = (narg == nullptr) ? s : narg;
	s->data = val;
	return s;
}
//释放节点
void Freenode(DuLNode* q)
{
	free(q);
}
void InitList(DuLinkList* plist) {
	assert(plist != nullptr);
	plist->cursize = 0;
	plist->head = Buynode(0);
}
//获得长度
int GetSize(DuLinkList* plist)
{
	assert(plist != nullptr);
	return plist->cursize;
}
//是否为空
bool IsEmpty(DuLinkList* plist)
{
	assert(plist != nullptr);
	return GetSize(plist) == 0;
}
//用Prev插入节点
void InsertPrev(DuLinkList* plist, DuLNode* ptr, ElemType val)
{
	assert(plist != nullptr && ptr != nullptr);
	ptr->prev = Buynode(val, ptr->prev, ptr);
	DuLNode* s = ptr->prev;
	s->prev->next = s;
	plist->cursize++;
}
//尾插
void Push_Back(DuLinkList* plist, ElemType val) {
	assert(plist != nullptr);
	InsertPrev(plist, plist->head, val);
}
//头插
void Push_Front(DuLinkList* plist, ElemType val) {
	assert(plist != nullptr);
	InsertPrev(plist, plist->head->next, val);
}
//打印
void PrintList(DuLinkList* plist) {
	assert(plist != nullptr);
	DuLNode* p = plist->head->next;
	while (p != plist->head) {
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}
//查询
DuLNode* FindValue(DuLinkList* plist, ElemType val) {
	assert(plist != nullptr);
	DuLNode* p = plist->head->next;
	while (p != plist->head && p->data != val) {
		p = p->next;
	}
	if (p == plist->head) {
		p = nullptr;
	}
	return p;
}
//删除ptr节点
void Erase(DuLinkList* plist, DuLNode* ptr) {
	assert(plist != nullptr && ptr != nullptr);
	if (ptr == nullptr) return;
	ptr->next->prev = ptr->prev;
	ptr->prev->next = ptr->next;
	Freenode(ptr);
	plist->cursize -= 1;
}
//删除尾节点
void Pop_back(DuLinkList* plist)
{
	assert(plist != nullptr);
	Erase(plist, plist->head->prev);
}
//删除第一个结点
void Pop_front(DuLinkList* plist)
{
	assert(plist != nullptr);
	Erase(plist, plist->head->next);
}
//删除val值的节点
void Remove(DuLinkList* plist, ElemType val)
{
	assert(plist != nullptr);
	DuLNode* p = FindValue(plist, val);
	if (p != nullptr)
	{
		Erase(plist, p);
	}
}
//销毁链表中每一个节点
void ClearList(DuLinkList* plist)
{
	assert(plist != nullptr);
	while (!IsEmpty(plist))
	{
		Pop_back(plist);
	}
}
//销毁链表
void DestroyList(DuLinkList* plist)
{
	assert(plist != nullptr);
	ClearList(plist);
	Freenode(plist->head);
	plist->head = nullptr;
}

最后，写文不易，不收藏也请给个赞，谢谢亲~！ 

（本文仅供学习时参考，如有错误，纯属作者技术不到位，不足之处请多指教，谢谢）

倦鸟馀生
关注
循环双链表（C语言实现）
Mr_John
10-27 342
#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语言双循环链表,循环链表之双循环链表（C语言版）
weixin_35822833的博客
05-19 591
依然沿袭过去的风格，进入双循环链表之前，先提另一种结构，双向链表，先有了双向链表再有了双循环链表。这两种结构和单链表一样都有带头结点和不带头结点之分。我们先来看一下这几种结构的结构图:双链表双循环链表既然单向链表有普通的链表也就是不循环的链表、那么双向链表也一样，也有普通的双向链表和双向循环链表；也有带头结点，不带头结点的结构，这里依然是两种结构都给出算法，但是普通的循环链表不写，这里只写循环双链...
C语言双向循环链表
weixin_44181627的博客
04-25 494
#include<stdio.h> #include<stdlib.h> #include<string.h> #define LINE (struct Student *) struct Student { int num; float score; /char name[20];/ struct Student *next; struct Student *...
c语言实现双向循环链表
03-27
以下是一种简单的C语言实现双向循环链表的代码： ``` #include #include struct node { int data; struct node *prev; struct node *next; }; struct node *createNode(int data) { struct node *newNode =...
用C语言实现双向循环链表初始化
最新发布
09-16
在C语言中，双向循环链表是一种特殊的链表结构，其中每个节点都有两个指针，一个指向前一个节点，另一个指向后一个节点，形成了一个首尾相连的环形结构。下面是一个简单的例子展示了如何初始化一个双向循环链表： `...
C语言中双向链表和双向循环链表详解
08-30
本文主要介绍了C语言中双向链表和双向循环链表的实现与操作，包括双向链表和双向循环链表的定义、初始化、插入操作、删除操作等。 一、双向链表和双向循环链表的定义 在C语言中，双向链表是一种数据结构，具有前驱...
[C语言数据结构]双向循环链表
本科在读，致力于Linux/C++方向的学习，同时涉及数据结构与算法，操作系统，数据库mysql等等
11-10 1777
上次我们学习了单链表的实现，相对于双向循环链表来说，单链表的各中操作，比如说增删查改等都显得非常麻烦。所以接下来来学习一下双向循环链表吧！
c语言 链表 双向链表 双向循环链表
02-26
从linux内核移植出来，独立于用户数据结构，里面有实例参考。C语言代码。
c语言双循环链表,双向循环链表头文件C语言
weixin_33316051的博客
05-19 245
这个东西,是在写斐波那契堆的时候发现的.觉得这东西很好,很好用,很方便.呵呵.所以啊,昨天给实现了,凑代码吗?不高级,实现的细节问题也不多.呵呵,不多说了,贴出来吧.明天会休息呢,所以来调兵了,玩了会球,感觉不错呢./*DoubleCircularLinkedList .h -- 双向循环链表头文件*/#include #include /*明显常量定义*/#define FALSE (0)#de...
循环双链表及C语言实现
Jeaten
07-27 892
本文介绍循环双链表及C语言实现 目录循环双链表循环双链表的操作插入头节点插入尾节点插入指定位置插入删除头节点删除尾节点删除指定位置删除遍历查找循环双链表的C语言实现 循环双链表 循环双链表 循环双链表的操作 插入 头节点插入 尾节点插入 指定位置插入 删除 头节点删除 尾节点删除 指定位置删除 遍历 查找 循环双链表的C语言实现 ...
C语言：循环双链表的创建，插入，删除
wjb214149306的博客
08-05 661
/* 双向循环链表的创建，插入，删除 */ # include # include //节点类型 typedef struct node { int data; struct node * pNext; struct node * pPrior; }NODE, *PNODE; PNODE creat_list(); //建立链表 void traverse(PNODE pHea
双向循环链表的C语言实现
weixin_46582567的博客
11-05 741
在工作中的项目有用到双链表，尤其是跟着别人写双链表代码的思路，自己去看总觉得没那么顺，感觉以后也会经常用到，所以索性自己写一个出来，细节由自己去把握，终于是理解了这一块，以下是实现双链表的所有源码： #include <stdio.h> #include <malloc.h> typedef struct List { struct List *pre; struct List *next; int data; }List_t; typedef struct HeadNo
链表-双向循环链表【C语言】
weixin_45423515的博客
05-15 2065
双向循环链表是最优链表，能补齐单链表的缺点，是个结构复杂，操作简单的链表。其插入和删除节点的时间复杂度是O(1)。 双向链表： 和单链表不同的是双向链表有两个指针，一个指向下一个节点，一个指向上一个节点 typedef int LTDataType; typedef struct ListNode { LTDataType _data; struct ListNode* _next; struct ListNode* _prev; }ListNode; ...
【C语言数据结构】双向循环链表
W1024201的博客
03-08 6881
目录 前言 一、双向循环链表 循环结构 1.双向循环链表头文件及函数声明 2.初始化 1.结点构造 2.初始化函数 3.结点申请 4.数据插入 1.按位置插入 2.尾插 3.头插 5.查找 6.数据删除 1.按位置删除 2.按值删除 3.尾删 4.头删 7.清空与销毁 1.清空 2.销毁 8.双向循环链表源文件及整体函数实现 总结 前言 这次我们将学习双向循环链表，首先了解双向链表和循环链表的定义和讲解。 双向链表也叫双链...
数据结构——双链表【c语言版】
clear-ninghongkang的博客
11-19 1260
在单链表中，只存在一个指向后继的指针域，由此，从某个结点出发只能向后寻查其他结点。若要寻查结点的前驱，必须从表头出发，这样非常的耗时，利用双链表就可以很好的解决这个问题。 对于双链表，采用类似于单链表的类型声明，其结点类型DLinkList的声明如下： typedef int ElemType; typedef struct Node { ElemType data;//存储线性表的元素值（1个） struct Node *next;//存储后继元素节点的地址 ...
纯C语言实现双循环链表
u25th_engineer的博客
08-03 783
/*编译环境：VC6.0*/ /* Name: 纯C语言实现双循环链表 Copyright: All right Reserved Author:刁肥宅 Date: 03/08/18 17:12 Description: 整合书上的代码 */ /*StdAfx.h*/ // stdafx.h : include file for standard system includ...
C语言实现双向循环链表插入操作
在C语言中，双向循环链表是一种数据结构，它允许节点在链表的前后两个方向上进行遍历。这种链表的每个节点包含一个指向前一个节点（prior）和一个指向后一个节点（next）的指针。本资源主要讲解如何创建、显示以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值