带头双向循环链表的代码实现

已于 2023-04-16 12:41:33 修改
阅读量3.7k 收藏 1
点赞数 3
分类专栏： # 数据结构与算法 文章标签： 链表 数据结构
于 2022-10-12 20:49:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29678157/article/details/127290421
版权

带头双向循环链表的实现

文章目录

1.带头双向循环链表的功能API架构

带头双向循环链表的功能API架构：

//打印结点
void ListPrint(LTNode* phead);

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

//创建结点
LTNode* BuyLTNode(LTDataType x);

//尾插结点
void ListPushBack(LTNode* phead, LTDataType x);

//尾删结点
void ListPopBack(LTNode* phead);

//头插结点
void ListPushFront(LTNode* phead, LTDataType x);

//头删结点
void ListPopFront(LTNode* phead);

//查找数据
LTNode* ListFind(LTNode* phead, LTDataType x);

// 在pos之前插入
void ListInsert(LTNode* pos, LTDataType x);

// 删除pos位置的节点
void ListErase(LTNode* pos);

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

2.带头双向循环链表的功能API代码实现

0.带头双向循环链表的链表结构：

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

1.创建结点:

LTNode* BuyLTNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}

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

2.打印结点:

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

3.初始化结点：

LTNode* ListInit()
{
	LTNode* phead = BuyLTNode(0);
	phead->next = phead;
	phead->prev = phead;

	return phead;
}

4.插入节点：

void ListInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	/*LTNode* newnode = BuyLTNode(x);
	pos->prev->next = newnode;
	newnode->prev = pos->prev;

	pos->prev = newnode;
	newnode->next = pos;*/

	LTNode* newnode = BuyLTNode(x);
	LTNode* posPrev = pos->prev;

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

5.删除结点：

void ListErase(LTNode* pos)
{
	assert(pos);

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

	free(pos);
	pos = NULL;

	prev->next = next;
	next->prev = prev;
}

6.头插结点：

void ListPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	ListInsert(phead, x);
}

7.头删结点：

void ListPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);

	ListErase(phead->next);
}

8.尾插结点：

void ListPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);

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

	//tail->next = newnode;
	//newnode->prev = tail;

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

	ListInsert(phead, x);
}

9.尾删结点：

void ListPopBack(LTNode* phead)
{
	assert(phead);
	// 链表为空
	assert(phead->next != phead);

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

	free(tail);
	tail = NULL;

	tailPrev->next = phead;
	phead->prev = tailPrev;*/

	ListErase(phead->prev);
}

10.查找数据：

LTNode* ListFind(LTNode* phead, LTDataType x)
{
	assert(phead);

	LTNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
		{
			printf("找到了目标结点\n\n");
			return cur;
		}

		cur = cur->next;
	}

	return NULL;
}

11.销毁结点：

void ListDestory(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		LTNode* next = cur->next;
		//ListErase(cur);
		free(cur);
		cur = next;
	}

	free(phead);
	//phead = NULL;
}

3.带头双向循环链表的功能API效果展示

请添加图片描述

4.带头双向循环链表的功能API源代码

List.h 头文件

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

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

//打印结点
void ListPrint(LTNode* phead);

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

//创建结点
LTNode* BuyLTNode(LTDataType x);

//尾插结点
void ListPushBack(LTNode* phead, LTDataType x);

//尾删结点
void ListPopBack(LTNode* phead);

//头插结点
void ListPushFront(LTNode* phead, LTDataType x);

//头删结点
void ListPopFront(LTNode* phead);

//查找数据
LTNode* ListFind(LTNode* phead, LTDataType x);

// 在pos之前插入
void ListInsert(LTNode* pos, LTDataType x);

// 删除pos位置的节点
void ListErase(LTNode* pos);

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

List.c 源文件

#include"List.h"

LTNode* BuyLTNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}

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

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

//void ListInit(LTNode** pphead)
//{
//	assert(pphead);
//	*pphead = BuyLTNode(0);
//	(*pphead)->next = *pphead;
//	(*pphead)->prev = *pphead;
//}

LTNode* ListInit()
{
	LTNode* phead = BuyLTNode(0);
	phead->next = phead;
	phead->prev = phead;

	return phead;
}

void ListPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);

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

	//tail->next = newnode;
	//newnode->prev = tail;

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

	ListInsert(phead, x);
}

void ListPopBack(LTNode* phead)
{
	assert(phead);
	// 链表为空
	assert(phead->next != phead);

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

	free(tail);
	tail = NULL;

	tailPrev->next = phead;
	phead->prev = tailPrev;*/

	ListErase(phead->prev);
}

void ListPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);

	ListErase(phead->next);
}

void ListPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	ListInsert(phead, x);
}

LTNode* ListFind(LTNode* phead, LTDataType x)
{
	assert(phead);

	LTNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
		{
			printf("找到了目标结点\n\n");
			return cur;
		}

		cur = cur->next;
	}

	return NULL;
}

void ListInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	/*LTNode* newnode = BuyLTNode(x);
	pos->prev->next = newnode;
	newnode->prev = pos->prev;

	pos->prev = newnode;
	newnode->next = pos;*/

	LTNode* newnode = BuyLTNode(x);
	LTNode* posPrev = pos->prev;

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

// 驼峰法
// 函数和类型所有单词首字母大写
// 变量：第一个单词小写后续单词首字母大写
void ListErase(LTNode* pos)
{
	assert(pos);

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

	free(pos);
	pos = NULL;

	prev->next = next;
	next->prev = prev;
}

void ListDestory(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		LTNode* next = cur->next;
		//ListErase(cur);
		free(cur);
		cur = next;
	}

	free(phead);
	//phead = NULL;
}

main.c 主函数源文件

#define _CRT_SECURE_NO_WARNINGS
#include "List.h"

void TestList0()
{
	//LTNode* pList = NULL;
	//ListInit(&pList);
	LTNode* pList = ListInit();
	ListPushBack(pList, 1);
	ListPushBack(pList, 2);
	ListPushBack(pList, 3);
	ListPushBack(pList, 4);
	ListPushBack(pList, 5);
	ListPushBack(pList, 6);
	ListPrint(pList);

	ListPopBack(pList);
	ListPopBack(pList);
	ListPopBack(pList);
	ListPopBack(pList);
	ListPopBack(pList);
	ListPopBack(pList);
	//ListPopBack(pList);
	ListPrint(pList);
}

void TestList1()
{
	//LTNode* pList = NULL;
	//ListInit(&pList);
	LTNode* pList = ListInit();
	ListPushBack(pList, 1);
	ListPushBack(pList, 2);
	ListPushBack(pList, 3);
	ListPushBack(pList, 4);
	ListPushBack(pList, 5);
	ListPushBack(pList, 6);
	ListPrint(pList);

	LTNode* pos = ListFind(pList, 3);
	if (pos)
	{
		ListInsert(pos, 30);
	}
	ListPrint(pList);

}

int main()
{
	printf("测试尾插尾删:\n");
	TestList0();
	printf("测试头插 头删 查找:\n");
	TestList1();

	return 0;
}
「已注销」
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
带头结点的双向循环链表
07-17
本项目以C++语言实现了带头结点的双向循环链表，这将有助于我们深入理解这一概念。 首先，双向循环链表与单链表的主要区别在于每个节点不仅包含数据，还包含两个指针：一个指向前一个节点，另一个指向后一个节点。...
带头结点的双向循环链表数据结构
01-08
总的来说，无论是C++还是Java实现，带头结点的双向循环链表都需要考虑链表的初始化、插入、删除、查找等基本操作，同时为了方便遍历，还需要实现相应的迭代器机制。这样的数据结构在处理需要双向访问数据的场景时...
带头双向循环链表的实现
南猿北者博客
11-08 663
对于链表来说，不只有单链表这一个品种；链表有很多种形态按方向分：单向、双向按带不带头：带头、不带头按循环：循环、不循环1、单向或则双向：2、带头或者不带头：组合排列一下的话，链表一共有8种形态！！！今天我们就来学习一下结构最复杂的带头双向循环链表！！！；虽然名字听上去比较复杂，但是实现起来比单链表（全名：不带头、不循环、单向链表）更加简单，也不需要过多考虑特殊情况；两种链表的比较：（上面是单链表，下面是带头双向循环链表）
线性表之带头双向循环链表
m0_62171658的博客
03-06 1329
初学者必备：线性表之带头双向循环链表接口实现和一些链表必备思想
【数据结构】带头双向循环链表的实现
m0_63198468的博客
01-05 1531
本文详细讲述了带头双向循环链表的各种接口，比如：初始化，尾插，尾删，头插，头删，打印，查找，随机插入，随机删除，以及销毁链表等接口，里面还附有图片能够更好的理解，内容通俗易懂。
数据结构初阶--带头双向循环链表
weixin_36194037的博客
07-26 663
循环单链表虽然能够实现从任一结点出发沿着链能找到其前驱结点，但时间耗费是O(n)。如果希望从表中快速确定某一个结点的前驱，另一个解决方法就是在单链表的每个结点里再增加一个指向其前驱的指针域prior。这样形成的链表中就有两条方向不同的链，称之为双(向)链表。与单链表类似，双链表也可增加头结点使双链表的某些运算变得方便。同时双向链表也可以有循环表，称为双向循环链表。由于在双向链表中既有前向链又有后向链，寻找任一结点的直接前驱结点与直接后继结点都变得非常方便了。//定义}LTNode;
数据结构-带头双向循环链表
m0_61433144的博客
07-18 1461
链表的种类非常丰富，有带头结点的或不带头结点的，有单向的或双向的，有循环的或非循环的，这样组合起来有2*2*2=8种链表结构。头结点与头指针的概念：不管带不带头结点，头指针都始终指向链表的第一个结点，而头结点是带头链表中第一个结点，该结点通常不存储数据。 引入头结点可以带来两个优点：1.由于第一个数据结点的位置被存储在头结点的指针域中，因此在链表的第一个位置上的操作和在链表其他位置上的操作一致，无须进行特殊处理。2.无论链表是否为空，其头指针都指向头结点，因此空表与非空表的处理也得到统一。........
数据结构-带头双向循环链表的基本实现（C语言，简单易懂，含全部代码）
阿龙的博客
04-26 2215
【数据结构基础入门】带头双向循环链表的概念、结构和接口实现
【数据结构】双向链表（带头双向循环链表）——超详细代码
qq_59702185的博客
08-15 1794
在上一篇文章我们已经介绍了链表的分类，链表的种类非常多，分为带头还是不带头、单向的还是多向的、单向还是双向循环……上一节我们学习了不带头单向的不循环的链表，这一节，我们主要实现带头双向循环的链表。如果我们把这两种结构的链表掌握的话，那么所有类型的链表我们都可以自己实现了带头双向链表有一个数据域和两个指针域。指针域一个是前驱指针，指向前一个节点，一个是后继指针，指向后一个节点。//前驱节点 struct ListNode * next;//后继节点 LTDataType data;//数据域 };...
带头双向循环链表（C语言实现）
xiaoming1999的博客
03-26 1499
带头双向循环链表概念及结构 概念：带头双向循环链表结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了。 带头双向循环链表的实现 List.h代码实现 #pragma once #include <stdio.h> #include <stdlib.h> #include <assert.h> typedef int LTDataTyp
【数据结构初阶】链表（下）——带头双向循环链表的实现
m0_70811813的博客
11-07 357
带头双向循环链表的实现、无头单向非循环链表和带头双向循环链表的对比、链表和顺序表的对比
Linux操作系统中通用双向循环链表的实现分析.pdf
09-06
在Linux内核源代码中，双向循环链表的实现充分体现了软件设计的思想和编程技巧。 在Linux内核源代码中，双向循环链表的应用非常广泛，如进程管理、内存管理、文件系统管理等等。例如，在进程管理中，Linux内核使用...
循环链表和双向链表.ppt
09-20
循环链表和双向链表是两种特殊类型的线性链表，它们在数据结构中扮演着重要角色，尤其在处理线性关系的数据时。下面将详细讨论这些概念。 首先，我们来看带头结点的链表。在普通链表的基础上，带头结点的链表会在...
数据结构c版（1）-线性表之双向带头循环链表代码
11-19
在本篇文章中，我们将深入探讨一个特定的数据结构——双向带头循环链表，它是线性表的一种实现方式。在C语言中，这种数据结构尤其常见，因为C语言提供底层内存管理和指针操作的能力，使得我们能够直接构建复杂的链式...
c语言（7.23）
最新发布
fhgfyrsg的博客
07-23 399
【代码】c语言（7.23）
数据结构---二叉树
weixin_47808575的博客
07-22 333
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
重生之“我打数据结构，真的假的？”--3.栈和队列
2301_80374809的博客
07-21 764
栈：一种特殊的线性表，其只允许在进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守LIFO（Last In First Out）的原则。
【数据结构-前缀和】力扣2550.统计范围内的元音字符串数
sjsjs11的博客
07-22 511
计算前缀和数组的时间是 O(n)，然后计算 q 个查询的答案，计算每个查询的答案的时间是 O(1)，因此时间复杂度是 O(n+q)。输入：words = [“aba”,“bcb”,“ece”,“aa”,“e”], queries = [[0,2],[1,4],[1,1]]输入：words = [“a”,“e”,“i”], queries = [[0,2],[0,1],[2,2]]查询 [1,4] 结果为 3（字符串 “ece”、“aa”、“e”）。返回结果 [2,3,0]。输出：[3,2,1]
java实现带头双向循环链表(附完整源码)
06-08
该代码实现了带头双向循环链表的数据结构，支持在链表末尾添加元素、在指定位置插入元素、删除指定位置的元素、获取指定位置的元素、获取链表长度等操作。在算法实现中，通过一个Node类来表示链表中的节点，包含数据...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

「已注销」

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

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

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

打赏作者

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

抵扣说明：

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

余额充值