用C语言实现《带头双向循环链表》超详细

已于 2023-02-27 10:40:46 修改
阅读量143 收藏
点赞数
分类专栏： 数据结构初阶(C语言) 文章标签： 链表 数据结构
于 2023-02-26 12:03:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58950498/article/details/129223354
版权
本文详细介绍了如何在C语言中创建和操作带头双向循环链表，包括结构体定义、动态内存分配、链表初始化、尾插、尾删、头插、头删、查找、在指定位置插入和删除、判断链表是否为空、计算链表大小以及销毁链表的方法。示例代码展示了每个操作的实现细节。
摘要由CSDN通过智能技术生成

文章目录

带头双向循环链表

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

首先创建三个文件
test.c主函数，测试我们链表的功能
ListNode.c，编写链表的函数
ListNode.h，编写函数的头文件

提示：以下是本篇文章正文内容，下面案例可供参考

(1)创建一个带头双向循环链表的结构体

typedef int LTDataType;

//创建链表的结构体
typedef struct ListNode
{
	LTDataType data;
	struct ListNode* prev;
	struct ListNode* next;
}LTNode;

(2)动态开辟节点

//动态开辟单链表的节点
LTNode* BuyListNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

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

(3)链表的初始化

初始化带头的双向循环链表，我们要将next指向自己（头），prev也指向自己（头）。

//链表的初始化
LTNode* ListInit()
{
	LTNode* head = BuyListNode(-1);
	head->prev = head;
	head->next = head;
	return head;
}

(4)链表的尾插

在这里插入图片描述

//链表的尾插
void ListPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);
	创建一个节点
	//LTNode* newnode = BuyListNode(x);
	//phead->prev->next = newnode;
	//newnode->prev = phead->prev;
	//newnode->next = phead;
	//phead->prev = newnode;

	//复用
	ListPosInsert(phead, x);
}

(5)链表的尾删

//链表的尾删
void ListPopBack(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);

	//LTNode* tail = phead->prev;	 //找旧尾
	//LTNode* tailprev = tail->prev; //找新尾

	链接新的尾
	//tailprev->next = phead;
	//phead->prev = tailprev;
	//
	释放以前的尾
	//free(tail);
	ListPosErase(phead->prev);
}

(6)链表的头插

//链表的头插-是指在头节点的下一个插入
void ListPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	创建一个节点
	//LTNode* newnode = BuyListNode(x);

	保存好下一个节点
	//LTNode* first = phead->next;
	//phead->next = newnode;
	//newnode->prev = phead;
	//newnode->next = first;
	//first->prev = newnode;

	ListPosInsert(phead->next, x);
}

(7)链表的头删

//链表的头删-是指在头节点的下一个插入
void ListPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);  //防止只有一个头指针

	//LTNode* first = phead->next;
	//LTNode* second = first->next;

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

(8)链表的查找

//链表的查找
LTNode* ListFind(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* cur = phead->next;

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

(9)在pos位置插入

比如有1 2 3 ，在2位置插入意思是，将2位置以及后面的数往后挪，新的数字占用2的位置

//链表的pos位置插入
void ListPosInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* newnode = BuyListNode(x);
	LTNode* prev = pos->prev;

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

(10)删除pos处

//链表的pos位置删除
void ListPosErase(LTNode* pos)
{
	assert(pos);

	LTNode* prev = pos->prev;
	LTNode* next = pos->next;

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

(11)判断链表是否为空

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

(12)计算链表的大小

//计算链表大小
size_t ListSize(LTNode* phead)
{
	size_t size = 0;
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		size++;
		cur = cur->next;
	}
	return size;
}

(13)销毁链表

//链表的销毁
void ListDeatroy(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);

	LTNode* cur = phead->next;

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

(14)链表的打印

//链表的打印
void ListPrint(LTNode* phead)
{
	assert(phead);

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

全部源码

ListNode.h

#pragma once


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


typedef int LTDataType;

//创建链表的结构体
typedef struct ListNode
{
	LTDataType data;
	struct ListNode* prev;
	struct ListNode* next;
}LTNode;


//动态开辟单链表的节点
LTNode* BuyListNode(LTDataType x);

//链表的初始化
LTNode* ListInit();


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

//链表的尾删
void ListPopBack(LTNode* phead);

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

//链表的头删-是指在头节点的下一个插入
void ListPopFront(LTNode* phead);

//链表的打印
void ListPrint(LTNode* phead);

//链表的销毁
void ListDeatroy(LTNode* phead);

//链表的查找
LTNode* ListFind(LTNode* phead, LTDataType x);

//链表的pos位置插入
void ListPosInsert(LTNode* pos, LTDataType x);

//链表的pos位置删除
void ListPosErase(LTNode* pos);

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

//计算链表大小
size_t ListSize(LTNode* phead);

ListNode.c

#define _CRT_SECURE_NO_WARNINGS 1

#include "Dlist.h"


//动态开辟单链表的节点
LTNode* BuyListNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

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

//链表的初始化
LTNode* ListInit()
{
	LTNode* head = BuyListNode(-1);
	head->prev = head;
	head->next = head;
	return head;
}


//链表的尾插
void ListPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);
	创建一个节点
	//LTNode* newnode = BuyListNode(x);
	//phead->prev->next = newnode;
	//newnode->prev = phead->prev;
	//newnode->next = phead;
	//phead->prev = newnode;

	//复用
	ListPosInsert(phead, x);
}

//链表的尾删
void ListPopBack(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);

	//LTNode* tail = phead->prev;	 //找旧尾
	//LTNode* tailprev = tail->prev; //找新尾

	链接新的尾
	//tailprev->next = phead;
	//phead->prev = tailprev;
	//
	释放以前的尾
	//free(tail);
	ListPosErase(phead->prev);
}


//链表的头插-是指在头节点的下一个插入
void ListPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	创建一个节点
	//LTNode* newnode = BuyListNode(x);

	保存好下一个节点
	//LTNode* first = phead->next;
	//phead->next = newnode;
	//newnode->prev = phead;
	//newnode->next = first;
	//first->prev = newnode;

	ListPosInsert(phead->next, x);
}


//链表的头删-是指在头节点的下一个插入
void ListPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);  //防止只有一个头指针

	//LTNode* first = phead->next;
	//LTNode* second = first->next;

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


//链表的打印
void ListPrint(LTNode* phead)
{
	assert(phead);

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

//链表的销毁
void ListDeatroy(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);

	LTNode* cur = phead->next;

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


//链表的查找
LTNode* ListFind(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位置插入
void ListPosInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* newnode = BuyListNode(x);
	LTNode* prev = pos->prev;

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

//链表的pos位置删除
void ListPosErase(LTNode* pos)
{
	assert(pos);

	LTNode* prev = pos->prev;
	LTNode* next = pos->next;

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

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

//计算链表大小
size_t ListSize(LTNode* phead)
{
	size_t size = 0;
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		size++;
		cur = cur->next;
	}
	return size;
}

Test.c

#define _CRT_SECURE_NO_WARNINGS 1

#include "Dlist.h"


//演示尾插尾删
void test1()
{
	LTNode*  plist = ListInit();
	//尾插
	ListPushBack(plist, 1);
	ListPushBack(plist, 2);
	ListPushBack(plist, 3);
	ListPrint(plist);

	//尾删
	ListPopBack(plist);
	ListPopBack(plist);

	//打印
	ListPrint(plist);

	ListDeatroy(plist);
}

//演示头插头删
void test2()
{
	LTNode* plist = ListInit();
	//头插
	ListPushFront(plist, 1);
	ListPushFront(plist, 2);
	ListPushFront(plist, 3);
	ListPrint(plist);

	//头删
	ListPopFront(plist);
	ListPopFront(plist);

	//打印
	ListPrint(plist);

	ListDeatroy(plist);
}


//演示查找元素和修改
void test3()
{
	LTNode* plist = ListInit();
	//尾插
	ListPushBack(plist, 1);
	ListPushBack(plist, 2);
	ListPushBack(plist, 3);
	printf("size=%d\n", ListSize(plist));
	//打印
	ListPrint(plist);

	LTNode* pos = ListFind(plist, 5);
	if (pos != NULL)
	{
		//ListPosInsert(pos, 50);
		ListPosErase(pos);
		ListPrint(plist);
	}
	else
	{
		printf("没有这个数\n");
	}

	ListDeatroy(plist);
}
int main()
{
	test3();
	return 0;
}
#Sunshine boy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现带头双向循环链表(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
04-24 59
C语言实现带头双向循环链表(附完整源码)
C++操作单链表ListNode
weixin_38075257的博客
02-25 2万+
C++操作单链表ListNode 通过C++进行单链表的创建、打印以及利用栈实现逆序打印。 单链表的创建和打印 #include &amp;amp;lt;iostream&amp;amp;gt; using namespace std; //定义结构体 struct ListNode{ int val; ListNode* next; }; class operateList { public: /*创建单链表*/ ...
C语言 单链表的创建、遍历、释放
m0_74803157的博客
01-06 3255
【代码】C语言 单链表的创建、遍历、释放。
一文解决用C语言实现一个链表（全都是细节）
胡坚涛的博客
01-06 1749
链表是指数据使用一个一个的结点连接起来的数据结构，这样的数据结构中不像顺序表一样，顺序表中不同的数据在内存中的存储空间是相邻的，链表中的相邻结点在内存中的存储位置是没有任何关系的，每一个链表都是由许多的结点组成的，而一个链表，我们需要一个对应的头指针来管理这个链表，也就是说，如果我们拥有一个链表的头指针，那么我们就可以拿到这个链表中的所有的结点，在此基础上，如果我们还学会对链表中的结点进行一些常见的操作（增删查改），那么我们就可以熟练使用链表来解决现实中的问题了
数据结构+带头结点双向循环链表+(C语言)
weixin_49312527的博客
11-27 755
针对带头的双向循环链表的基本功能展开讲解: 目录 1.结构体定义 a. typedef int LTDataType; typedef struct ListNode { LTDataType _data; struct ListNode* _next; struct ListNode* _prev; }ListNode;
c++ listnode 赋值_C++操作单链表ListNode
weixin_35677043的博客
01-26 1858
C++操作单链表ListNode通过C++进行单链表的创建、打印以及利用栈实现逆序打印。单链表的创建和打印#include using namespace std;//定义结构体struct ListNode{int val;ListNode* next;};class operateList{public:/*创建单链表*/void createList(ListNode *head){int ...
链表-使用C语言实现非循环双向链表-带头结点+尾结点.zip
最新发布
03-13
本篇将详细介绍如何使用C语言来实现一个非循环双向链表，包括带头结点和尾结点的链表。 首先，让我们定义链表节点的数据结构。在非循环双向链表中，每个节点包含两个指针，分别指向它的前一个节点和后一个节点。...
【C语言】带头双向循环链表（list）详解（定义、增、删、查、改）
杨同学的博客
08-02 3208
带头双向循环链表，有一个数据域和两个指针域，一个是前驱指针，指向其前一个节点；一个是后继指针，指向其后一个节点//定义双向链表的节点typedefintDLTDateType;//定义数据类型typedefstructDLT_Node{...
C语言实现带头结点尾结点的双向非循环链表的基本操作
10-09
以上代码实现了带头结点和尾结点的双向非循环链表的基本操作，包括创建、插入、删除、遍历和销毁链表。这样的链表设计能够方便地进行双向遍历，对于需要频繁在链表中间插入和删除节点的应用场景尤其有用。在C语言中...
C语言：带头双向循环链表的实现
weixin_50711484的博客
09-02 311
带头节点的双向循环链表，链表界的扛把子，一篇文章将其拿下！
关于ListNode的理解
lxzGood的博客
03-01 4825
关于ListNode的理解 关于ListNode，首先是在力扣上刷题所遇到的一个算法题出现了相关的Java知识点。我首先在百度上面查询了ListNode的用法，按照百度的方法自己定义发现IDEA会报错： Cannot resolve symbol 'ListNode' 报错提示无法导入合适的类库。在之后的查询中明白，java中常用的数据结构单链表LIstNode，java并没有提供该数据结构的类库。自己在使用前需要人为的加入定义该类库，其结构定义如下： class ListNode{ int va
带头循环双向链表的c语言构建
qq_61932634的博客
11-18 381
C语言构建带头循环双向链表，体验不一样的感觉。
NC50 链表中的节点每k个一组翻转
lzyhhhhh的博客
08-25 459
一、题目： 描述 将给出的链表中的节点每k\ kk 个一组翻转，返回翻转后的链表 如果链表中的节点数不是k\ kk 的倍数，将最后剩下的节点保持原样 你不能更改节点中的值，只能更改节点本身。 要求空间复杂度 O(1)\ O(1)O(1) 例如： 给定的链表是1→2→3→4→51\to2\to3\to4\to51→2→3→4→5 对于 k=2\ k = 2k=2, 你应该返回 2→1→4→3→52\to 1\to 4\to 3\to 52→1→4→3→5 对于 k=3\ k = ...
[ 链表OJ题 7 ] 链表的回文结构
CSDN博客
03-20 763
目录 题目来源： 实现代码： 思路分析： 题目来源： 链表的回文结构_牛客题霸_牛客网 (nowcoder.com) 题目描述： 实现代码： struct ListNode* reverseList(struct ListNode* head){ if(!head) return NULL; struct ListNode* n1,* n2,* n3; n1=NULL; n2=head; n3 = n2->next; while(n2)..
链表ListNode详细解释
热门推荐
不二青衣的博客
06-06 3万+
ListNode 刷LeetCode碰到一个简单链表题，题目已经定义了链表节点ListNode，作者很菜，好多忘了，把ListNode又查了一下 struct ListNode { int val; //定义val变量值，存储节点值 struct ListNode *next; //定义next指针，指向下一个节点，维持节点连接 } · 在节点ListNode定义中，定义为节点为结构变量。 · 节点存储了两个变量：value 和 next。value 是这个节点的
C语言实现单链表
ljx_5489464的博客
03-15 2064
1、用于存放声明的头文件#define _CRT_SECURE_NO_WARNINGS #pragma once #include <stdio.h> #include <assert.h> #include <malloc.h>typedef int DataType;typedef struct SListNode { DataType data;
C++建立链表
aiyun1242的博客
10-25 697
自己保存一下，建立链表的程序，省的以后每次建立链表的时候，还需要重新在写。 通过下面的代码，建立的链表节点数为10，每个节点保存的数为其下标即：0-9 这里要注意一点，在void createList(ListNode* &pHead)的时候，用的是指针引用，因为在main中head并没有开辟空间，如果在createList中为pHead开辟空间的时候，main中的head依...
C语言设计带头结点静态双向循环链表
04-22
对于带头结点的静态双向循环链表，插入操作分为两种情况： 1. 在表头插入：新节点的后继指针指向原头节点，原头节点的前驱指针指向新节点，新节点的前驱指针指向头结点，头结点的后继指针指向新结点。 2. 在表尾...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值