数据结构——双向循环链表的结构与实现(C语言)

最新推荐文章于 2023-11-28 21:54:27 发布
置顶 最新推荐文章于 2023-11-28 21:54:27 发布
阅读量2.5k 收藏 21
点赞数 5
分类专栏： 数据结构 文章标签： 数据结构 链表 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40076022/article/details/112526801
版权

C语言实现带头双向循环链表

一、双向链表的结构与实现

1.1 带头双向循环链表

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

在这里插入图片描述

1.2 带头双向循环链表的实现

// 带头+双向+循环链表增删查改实现
typedef int LTDataType;
typedef struct ListNode
{
	LTDataType _data;			
	struct ListNode* _next;	
	struct ListNode* _prev;
}ListNode;

二、双向链表的接口实现

2.1 创建双向链表

创建头节点，申请空间，newNode->_next = newNode->_prev = newNode;
在这里插入图片描述

ListNode* BuyNode(LTDataType x)
{
	ListNode* newNode = (ListNode *)malloc(sizeof(ListNode));
	newNode->_data = x;
	newNode->_next = newNode->_prev = NULL;
	return newNode;

}

// 创建返回链表的头结点.
ListNode* ListCreate()
{
	ListNode* Head = BuyNode(0);
	Head->_next = Head->_prev = Head;
	return Head;
}

2.2 双向链表销毁

//双向链表的清除，保留头节点
void ListClear(ListNode* pHead)
{
	assert(pHead);

	ListNode* cur = pHead->_next;
	//遍历每个节点并释放
	while (cur != pHead)
	{
		ListNode* next = cur->_next;
		free(cur);
		cur = next;
	}
	pHead->_next = pHead->_prev = pHead;
}

// 双向链表销毁
void ListDestory(ListNode** ppHead)
{
	assert(*ppHead);
	ListClear(*ppHead);
	free(*ppHead);
	*ppHead = NULL;
}

2.3 双向链表在pos的前面进行插入

在这里插入图片描述

// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);

	ListNode* prev = pos->_prev;	//pos的前一个结点
	ListNode* newNode = BuyNode(x);
	newNode->_prev = prev;	//1.
	prev->_next = newNode;	//2.
	pos->_prev = newNode;	//3.
	newNode->_next = pos;	//4.


}

2.4 双向链表删除pos位置的节点

在这里插入图片描述

// 双向链表删除pos位置的节点
void ListErase(ListNode* pos)
{
	assert(pos);

	ListNode* prev = pos->_prev;	//pos的前一个结点
	ListNode* next = pos->_next;	//pos的后一个节点
	
	free(pos);
	prev->_next = next;	//1.
	next->_prev = prev;	//2.

}

2.5 双向链表打印

// 双向链表打印
void ListPrint(ListNode* pHead)
{
	assert(pHead);

	ListNode* cur = pHead->_next;
	
	遍历每个节点并打印
	while (cur != pHead)
	{
		ListNode* next = cur->_next;	//next指向下一个节点
		printf("%d ", cur->_data);	//打印当前节点
		cur = next;		//cur指向下一个节点
	}
	printf("\n");

}

2.5 双向链表尾插

在这里插入图片描述
尾插其实就是在头节点的前面插入节点，因此直接调用前面写好的接口，也可以自己逐步实现

// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x)
{
	assert(pHead);

	ListInsert(pHead, x);

	//ListNode* tail = pHead->_prev;	//找到尾节点
	//ListNode* newNode = BuyNode(x);	//创建一个新节点
	//tail->_next = newNode;	//1.
	//newNode->_prev = tail;	//2.
	//newNode->_next = pHead;	//3.
	//pHead->_prev = newNode;	//4.
}

2.6 双向链表尾删

尾删就是删除双向链表的最后一个结点，删除的位置也就是头节点的前一个结点

// 双向链表尾删
void ListPopBack(ListNode* pHead)
{
	assert(pHead);

	ListErase(pHead->_prev);

	//ListNode* tail = pHead->_prev;	//找到尾节点
	//if (tail == pHead)	//只有头节点说明双向链表为空，直接返回
	//{
	//	return;
	//}
	//ListNode* prev = tail->_prev;	//尾节点的前一个节点，即新的尾节点
	//free(tail);		//释放尾节点
	//prev->_next = pHead;	//1.新的尾节点next指向head
	//pHead->_prev = prev;	//2.head的prev指向新的尾节点
}

2.7 双向链表头插

头插是在头节点的后面插入

// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x)
{
	assert(pHead);

	ListInsert(pHead->_next, x);


}

2.8 双向链表头删

头删是删除头结点后面的元素

// 双向链表头删
void ListPopFront(ListNode* pHead)
{
	assert(pHead);
	
	ListErase(pHead->_next);


}

2.9 双向链表查找

// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x)
{
	assert(pHead);

	ListNode* cur = pHead->_next;
	while (cur != pHead)
	{
		ListNode* next = cur->_next;
		if (cur->_data == x)
		{
			return cur;
		}
		cur = next;
	}
	return NULL;
}

三、代码清单

3.1 List.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<windows.h>

// 带头+双向+循环链表增删查改实现
typedef int LTDataType;
typedef struct ListNode
{
	LTDataType _data;			
	struct ListNode* _next;	
	struct ListNode* _prev;
}ListNode;

// 创建返回链表的头结点.
ListNode* ListCreate();
// 双向链表销毁
void ListClear(ListNode* pHead);
void ListDestory(ListNode** ppHead);
// 双向链表打印
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 ListInsert(ListNode* pos, LTDataType x);
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos);

3.2 List.c

#include "List.h"


ListNode* BuyNode(LTDataType x)
{
	ListNode* newNode = (ListNode *)malloc(sizeof(ListNode));
	newNode->_data = x;
	newNode->_next = newNode->_prev = NULL;
	return newNode;

}

// 创建返回链表的头结点.
ListNode* ListCreate()
{
	ListNode* Head = BuyNode(0);
	Head->_next = Head->_prev = Head;
	return Head;
}


//双向链表的清除，保留头节点
void ListClear(ListNode* pHead)
{
	assert(pHead);

	ListNode* cur = pHead->_next;
	//遍历每个节点并释放
	while (cur != pHead)
	{
		ListNode* next = cur->_next;
		free(cur);
		cur = next;
	}
	pHead->_next = pHead->_prev = pHead;
}

// 双向链表销毁
void ListDestory(ListNode** ppHead)
{
	assert(*ppHead);
	ListClear(*ppHead);
	free(*ppHead);
	*ppHead = NULL;
}

// 双向链表打印
void ListPrint(ListNode* pHead)
{
	assert(pHead);

	ListNode* cur = pHead->_next;
	
	遍历每个节点并打印
	while (cur != pHead)
	{
		ListNode* next = cur->_next;	//next指向下一个节点
		printf("%d ", cur->_data);	//打印当前节点
		cur = next;		//cur指向下一个节点
	}
	printf("\n");

}
// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x)
{
	assert(pHead);

	ListInsert(pHead, x);

	//ListNode* tail = pHead->_prev;	//找到尾节点
	//ListNode* newNode = BuyNode(x);	//创建一个新节点
	//tail->_next = newNode;	//1.
	//newNode->_prev = tail;	//2.
	//newNode->_next = pHead;	//3.
	//pHead->_prev = newNode;	//4.
}
// 双向链表尾删
void ListPopBack(ListNode* pHead)
{
	assert(pHead);

	ListErase(pHead->_prev);

	//ListNode* tail = pHead->_prev;	//找到尾节点
	//if (tail == pHead)	//只有头节点说明双向链表为空，直接返回
	//{
	//	return;
	//}
	//ListNode* prev = tail->_prev;	//尾节点的前一个节点，即新的尾节点
	//free(tail);		//释放尾节点
	//prev->_next = pHead;	//1.新的尾节点next指向head
	//pHead->_prev = prev;	//2.head的prev指向新的尾节点
}
// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x)
{
	assert(pHead);

	ListInsert(pHead->_next, x);


}
// 双向链表头删
void ListPopFront(ListNode* pHead)
{
	assert(pHead);
	
	ListErase(pHead->_next);


}

// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x)
{
	assert(pHead);

	ListNode* cur = pHead->_next;
	while (cur != pHead)
	{
		ListNode* next = cur->_next;
		if (cur->_data == x)
		{
			return cur;
		}
		cur = next;
	}
	return NULL;
}
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);

	ListNode* prev = pos->_prev;	//pos的前一个结点
	ListNode* newNode = BuyNode(x);
	newNode->_prev = prev;	//1.
	prev->_next = newNode;	//2.
	pos->_prev = newNode;	//3.
	newNode->_next = pos;	//4.


}
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos)
{
	assert(pos);

	ListNode* prev = pos->_prev;	//pos的前一个结点
	ListNode* next = pos->_next;	//pos的后一个节点
	
	free(pos);
	prev->_next = next;	//1.
	next->_prev = prev;	//2.

}

3.3 test.c

#include"List.h"

void TestList()
{
	ListNode *p;
	p = ListCreate();
	ListPushFront(p, 5);
	ListPushFront(p, 4);
	ListPushFront(p, 3);
	ListPushFront(p, 2);
	ListPushFront(p, 1);
	ListPrint(p);

	ListPopFront(p);
	ListPopFront(p);
	ListPopFront(p);
	ListPopFront(p);
	ListPopFront(p);
	ListPrint(p);

	ListPushBack(p, 1);
	ListPushBack(p, 2);
	ListPushBack(p, 3);
	ListPushBack(p, 4);
	ListPushBack(p, 5);
	ListPrint(p);

	ListPopBack(p);
	ListPopBack(p);
	ListPopBack(p);
	ListPopBack(p);
	ListPopBack(p);
	ListPrint(p);


	//ListDestory(&p);

	ListPushFront(p, 5);
	ListPushFront(p, 4);
	ListPushFront(p, 3);
	ListPushFront(p, 2);
	ListPushFront(p, 1);
	ListPrint(p);

	ListNode* pos = ListFind(p, 3);
	pos->_data = 30;
	ListPrint(p);

	ListInsert(pos, 33);
	ListPrint(p);
	ListErase(pos);
	ListPrint(p);

	ListDestory(&p);
}

int main()
{
	TestList();
	system("pause");
	return 0;
}

四、测试结果

在这里插入图片描述

五颗粒粒
关注
  • 5
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
通讯录的制作（数据结构c语言 代码+报告）
04-04
通讯录的制作：用《数据结构》中的双向链表作数据结构，结合C语言基本知识。编写一个通讯录管理系统。以把所学数据结构知识应用到实际软件开发中去。 2、功能需求分析 本系统应完成一下几方面的功能： 1)输入信息...
Golang 双链表（Doubly Linked List）
miao0916的博客
06-16 954
双向链表的每个数据节点包含三个元素：数据、前驱节点的指针、后继节点的指针。头部节点 单向循环链表和单向链表相似，每个数据节点包含数据和后继节点的指针，区别在于最后一个节点的后继节点指针为链表的头部节点，形成一个环。 双向链表的每个数据节点包含三个元素：数据、前驱节点的指针、后继节点的指针。头部节点的前驱指针为NULL, 尾部节点的后继指针为NULL 2.2.2 尾部追加数据 2.2.4 index查找节点数据 2.2.5 从任意位置插入 2.2.6 从头部
golang 实现单向链表（lru）、双向链表、双向循环链表
最新发布
拥的博客
11-28 690
golang 实现链表
Golang 实现双向链表
XPiedPiperX的博客
12-17 272
Golang 代码： /* 数据结构 双向链表 */ package main import "fmt" // 定义一个双向链表 type DoubleNode struct { no int // 排名 name string // 名字 nickname string // 外号 pre *DoubleNode // 前一个节点 next *DoubleNode // 下一个节点 } // 给双向链表加入一
golang 实现双向链表
phpduang的博客
08-30 172
package main //链表节点 type doublLinkeNode struct { data interface{} //节点存在的数据 pre *doublLinkeNode //指向上一个节点的指针 next *doublLinkeNode //指向下一个节点的指针 } //链表数据结构（两个指针 一个指向头节点、一个指向尾节点 便于可以从两边获取数据） type doubleLink struct { head *doublLinkeNode //指向头结点 .
Golang 双向链表
baobaoxiannv的博客
02-09 719
模拟的 java LinkedList，目前只实现了 add()，稍晚会更新添加其他功能 type LinkedList struct { len int head *LinkedNode tail *LinkedNode } type LinkedNode struct { data int next *LinkedNode pre *LinkedNode } func NewLinkedList() *LinkedList { return &LinkedList{ l
严蔚敏 数据结构(C语言版) 代码 23490 书中算法
04-21
1.3　抽象数据类型的表示与实现　7 1.4　算法和算法分析　11 1.4.1　算法的定义及特性　11 1.4.2　评价算法优劣的基本标准　11 1.4.3　算法的时间复杂度　12 1.4.4　算法的空间复杂度　14 1.5　小结　15 习题　16 第...
数据结构c语言版——
09-24
线性表的存储表示（顺序表示、单向链表、循环链表、双向链表） 特殊的线性表：栈、队列、串 二叉树的定义、性质、存储结构、遍历算法 图的定义、术语、存储结构 静态查找表、二叉排序树、哈希函数的构造及冲突...
谭浩强C语言程序设计，C++程序设计，严蔚敏数据结构，高一凡数据结构算法分析与实现.rar
06-13
*5.6 C＋＋处理字符串的方法——字符串类与字符串变量 5.6.1 字符串变量的定义和引用 5.6.2 字符串变量的运算 5.6.3 字符串数组 5.6.4 字符串运算举例 习题 第6章 指针 6.1 指针的概念 6.2 变量与指针 6.2.1 定义...
数据结构—使用C语言（第4版）【朱战立-电子教案】
02-24
循环双向链表 静态链表 设计举例 【第3章】 堆栈和队列 堆栈 堆栈应用 队列 队列应用 优先级队列 【第4章】 串 串的基本概念和C语言的串函数 串的存储结构 动态数组实现的顺序串 串的模式匹配算法——BF算法 【第...
双向链表（golang实现）
weixin_44079228的博客
04-09 477
个人github（包括golang学习笔记、源码）：https://github.com/fangguizhen/Notes/blob/master/Golang%E7%9F%A5%E8%AF%86%E7%82%B9.md //单向链表的缺点分析 //1、单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找 //2、单向链表不能自我删除，需要靠辅助节点，而双向链表可以自我删除。 ...
Golang 官方实现的双向链表
叶青
08-13 1万+
概述 在go语言中，官方已经替我们实现了一个双向链表，可以用来存储、查找我们的数据，数据类型支持任意类型，其中节点的定义如下： // Element is an element of a linked list. type Element struct { // Next and previous pointers in the doubly-linked list of elements. // To simplify the implementation, internally a list
Golang数据结构-双向链表
qq_43498850的博客
04-01 244
文章目录一、Golang数据结构-双向链表1.基本介绍二、使用步骤1.使用一个结构体管理双向链表2.添加链表数据(方法一)2.添加链表数据(方法二)3.显示链表的所有结点信息4.逆向显示链表的所有结点信息5.双向链表删除一个结点[方法一: 此方法定位要删除的结点是 temp.next 并非直接定位到要删除的结点]6.双向链表删除一个结点[方法二:此方法直接定位要删除的结点为temp]7.双向链表的修改 [方法一:将要修改的结点定位到temp.next]8.双向链表的修改 [方法二:将要修改的结点定位到t..
Go 双向链表
无风的雨
06-01 926
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点，相对于单链表来讲：往前往后遍历都很方便。 相对于单向链表优势： 可以双向遍历 ​ 插入删除不需要移动元素外，可以原地插入删除效率更高，当然这也是以牺牲存储空间为代价。 插入数据 删除数据 Go cont...
数据结构-链表结构-双向链表
qq_44715376的博客
08-01 3024
双向链表
循环双链表详解（C语言版）
热门推荐
qq_44075108的博客
10-22 1万+
之前学习的双链表结构，可以实现从表中任一结点出发找到链表中的其他结点，但是该结构如果要从头结点开始查找尾结点，那么就需要通过遍历查找尾结点，这种情况下双链表的效率较低，为了解决这个缺点，将其改进为循环双链表，以此来提高查找效率。
数据结构——双向循环链表
qq_67611811的博客
08-28 1873
双向循环链表，在原单链表的基础上多了一个指向上一个结点的前驱指针prev，这样前后结点就不仅仅有了单向的从头至尾的指向顺序，也可以从后指向前，从末结点指向头结点。双向带头循环链表结构} DGR;加入前驱指针后，不管是对于链表数据的尾插尾删，或是头插头删，其时间复杂度都为O(1)，大大简化了链表遍历过程，而可以直接在链表首尾增减数据，因为一个链表的末节点可由头结点的前驱指针直接访问而不需要遍历至尾。为了简化文本描述，本章双向循环带头链表均简称为双向链表。...
golang实现双链表
skh2015java的博客
01-31 694
package main import ( "fmt" "time" ) type Element interface {} var header *entry //链表表头 var size int //链表长度 type entry struct { previous *entry next *entry element Element } func ne
go语言实现--双向循环链表
米兰的小铁匠1943的博客
05-27 1093
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 代码如下： package doubleLinkedList import ( &quot;errors&quot; &quot;fmt&quot; ) type ElemType interface{}...
C语言数据结构双向循环链表
09-27
在C语言中，实现双向循环链表需要定义一个链表节点结构体，其中包含指向前驱节点和后继节点的指针，以及存储数据的成员。以下是一个示例的C语言代码来初始化一个双向循环链表： ``` typedef int LTDataType; ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值