数据结构——带头双向循环链表

｛Hello World}2023-09-08 22:00

数据结构------带头双向循环链表

一、带头双向循环链表的定义

带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势。
带头双向循环链表包括一个带有哨兵位的头节点，该节点既可以作为链表的第一个节点，也可以作为链表的最后一个节点.
这种链表的特点是每个节点都有两个指针，一个指向前一个节点，一个指向后一个节点，这样就可以实现双向遍历。
同时，链表的最后一个节点的后继指针指向头节点，形成了循环的结构。这样，我们可以在任意一个节点上进行前后移动，插入和删除操作，而不需要像单链表那样遍历整个链表去找到前一个节点。
需要注意的是，带头双向循环链表为空并不意味着没有一个节点，而是只有一个带哨兵位的头节点，所以在使用之前需要对链表进行初始化。

二、带头双向循环链表的实现

2.1初始化创建带头双向循环链表的节点

c 复制代码 
typedef struct ListNode
{
	Listdatatype data;
	struct ListNode* next;
	struct ListNode* prev;
}LTNode;

在创建带头双向循环链表的节点中比之前单链表节点的创建多了一个struct ListNode* prev;结构体指针，目的在与存储前一个节点的地址，便于将整个链表连在一起。

2.2申请新节点

c 复制代码 
//创建新节点
LTNode* BuyLTNode(Listdatatype x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	return newnode;
}

动态申请内存结点，函数返回的是一个指针类型，用malloc开辟一个LTNode大小的空间，并用node指向这个空间，再判断是否为空，如为空就perror，显示错误信息。反之则把需要存储的数据x存到newnode指向的空间里面，并且把newnode->next,newnode->prev置为空。

2.3节点的初始化

c 复制代码 
LTNode* LTInit()
{
	LTNode* phead = BuyLTNode(-1);
	phead->next = phead;
	phead->prev = phead;

	return phead;
}

通过动态内存申请节点，申请了一个头节点。并且将它的phead->next ，phead->prev 都置为phead,得到如下图的头节点。

2.4带头双向循环链表的尾插

c 复制代码 
void LTPushBack(LTNode* phead, Listdatatype x)
{
	assert(phead);
	LTNode* tail = phead->prev;
	LTNode* newnode = BuyLTNode(x);

	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;
}

尾插节点的方法：首先通过内存申请一个节点， 然后改变四个指针的指向，便可以完成带头双向循环链表的尾插。

2.5带头双向循环链表的头插

c 复制代码 
void LTFrontBack(LTNode* phead, Listdatatype x)
{
	assert(phead);
	LTNode* newnode = BuyLTNode(x);
	newnode->next = phead->next;
	phead->next->prev = newnode;
	phead->next = newnode;
	newnode->prev = phead;
}


2.6判空函数

c 复制代码 
bool LTEmpty(LTNode* phead)
{
	assert(phead);

	return phead->next == phead;
}

2.7带头双向循环链表的打印函数

c 复制代码 
//打印
void LTPrint(LTNode* phead)
{
	LTNode* cur = phead->next;
	printf("guard<->");
	while (cur != phead)
	{
		printf("%d<->", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

2.8带头双向循环链表的尾删

c 复制代码 
//尾删
void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(! LTEmpty(phead));
	LTNode* tail = phead->prev;
	LTNode* tailprev = tail->prev;
	//改变指针的指向
	free(tail);
	tailprev->next = phead;
	phead->prev = tailprev;
}

2.9带头双向循环链表的头删

c 复制代码 
void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));
	LTNode* first = phead->next;
	LTNode* firstnext = first->next;
	free(first);
	phead->next = firstnext;
	firstnext->prev = phead;
}

2.11带头双向循环链表的在pos之前插入

c 复制代码 
void LTInsert(LTNode* pos, Listdatatype x)
{
	assert(pos);
	LTNode* newnode = BuyLTNode(x);
	LTNode* posprev = pos->prev;
	posprev->next = newnode;
	newnode->prev = posprev;
	newnode->next = pos;
	pos->prev = newnode;
}

2.12带头双向循环链表的在pos位置删除

c 复制代码 
void LTErase(LTNode* pos)
{
	assert(pos);
	LTNode* posprev = pos->prev;
	LTNode* posnext = pos->next;
	posprev->next = posnext;
	posnext->prev = posprev;
	free(pos);
}

2.14带头双向循环链表的销毁

c 复制代码 
//销毁
LTNode* LTDestory(LTNode* phead)
{
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		LTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);
}

三、完整代码

3.1LIst.h

c 复制代码 
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
typedef int  Listdatatype;
typedef struct ListNode
{
	Listdatatype data;
	struct ListNode* next;
	struct ListNode* prev;
}LTNode;

//初始化
LTNode* LTInit();

//尾插
void LTPushBack(LTNode* phead, Listdatatype x);

//尾删
void LTPopBack(LTNode* phead);

//头插
void LTFrontBack(LTNode* phead, Listdatatype x);

//头删
void LTPopFront(LTNode* phead);

//打印
void LTPrint(LTNode* phead);

//判空
bool LTEmpty(LTNode* phead);

//在pos之前插入
void LTInsert(LTNode* pos, Listdatatype x);

//在pos之前删除
void LTErase(LTNode* pos);

//寻找
LTNode* LTFind(LTNode* phead, Listdatatype x);

//销毁
LTNode* LTDestory(LTNode* phead);

3.2List.c

c 复制代码 
#define _CRT_SECURE_NO_WARNINGS 1
#include"List.h"
//创建新节点
LTNode* BuyLTNode(Listdatatype x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	return newnode;
}


LTNode* LTInit()
{
	LTNode* phead = BuyLTNode(-1);
	phead->next = phead;
	phead->prev = phead;

	return phead;
}
//尾插
void LTPushBack(LTNode* phead, Listdatatype x)
{
	assert(phead);
	LTNode* tail = phead->prev;
	LTNode* newnode = BuyLTNode(x);

	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;
}


//头插
void LTFrontBack(LTNode* phead, Listdatatype x)
{
	assert(phead);
	LTNode* newnode = BuyLTNode(x);
	newnode->next = phead->next;
	phead->next->prev = newnode;
	phead->next = newnode;
	newnode->prev = phead;
}

//判空
bool LTEmpty(LTNode* phead)
{
	assert(phead);

	return phead->next == phead;
}

//打印
void LTPrint(LTNode* phead)
{
	LTNode* cur = phead->next;
	printf("guard<->");
	while (cur != phead)
	{
		printf("%d<->", cur->data);
		cur = cur->next;
	}
	printf("\n");
}


//尾删
void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(! LTEmpty(phead));
	LTNode* tail = phead->prev;
	LTNode* tailprev = tail->prev;
	//改变指针的指向
	free(tail);
	tailprev->next = phead;
	phead->prev = tailprev;
}


//头删
void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));
	LTNode* first = phead->next;
	LTNode* firstnext = first->next;
	free(first);
	phead->next = firstnext;
	firstnext->prev = phead;
}


//寻找
LTNode* LTFind(LTNode* phead, Listdatatype x)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}



//在pos之前插入
void LTInsert(LTNode* pos, Listdatatype x)
{
	assert(pos);
	LTNode* newnode = BuyLTNode(x);
	LTNode* posprev = pos->prev;
	posprev->next = newnode;
	newnode->prev = posprev;
	newnode->next = pos;
	pos->prev = newnode;
}

在pos之前删除
//void LTErase(LTNode* pos)
//{
//	assert(pos);
//	LTNode* posprev = pos->prev;
//	free(posprev);
//	posprev->prev->next = pos;
//	pos->prev = posprev->prev;
//	
//}


//在pos位置删除
void LTErase(LTNode* pos)
{
	assert(pos);
	LTNode* posprev = pos->prev;
	LTNode* posnext = pos->next;
	posprev->next = posnext;
	posnext->prev = posprev;
	free(pos);
}

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

3.3test.c

c 复制代码 
#define _CRT_SECURE_NO_WARNINGS 1
#include"List.h"
//void test1()
//{
//	LTNode* plist = LTInit();
//	LTPushBack(plist, 1);
//	LTPushBack(plist, 2);
//	LTPushBack(plist, 3);
//	LTPushBack(plist, 4);
//	LTPrint(plist);
//	LTPopBack(plist);
//	LTPrint(plist);

//}
void test2()
{
	LTNode* plist = LTInit();
	LTFrontBack(plist, 1);
	LTFrontBack(plist, 2);
	LTFrontBack(plist, 3);
	LTFrontBack(plist, 4);
	LTPrint(plist);
	LTErase(3);
	LTPrint(plist);
}
int main()
{
	//test1();
	test2();
	return 0;
}
相关推荐
秋夫人30 分钟前
B+树（B+TREE）索引
数据结构·算法
代码雕刻家1 小时前
数据结构-3.1.栈的基本概念
c语言·开发语言·数据结构
AlexMercer10121 小时前
【C++】二、数据类型 （同C）
c语言·开发语言·数据结构·c++·笔记·算法
^^为欢几何^^3 小时前
lodash中_.difference如何过滤数组
javascript·数据结构·算法
ahauedu4 小时前
案例分析-Stream List 中取出值最大的前 5 个和最小的 5 个值
数据结构·list
X同学的开始6 小时前
数据结构之二叉树遍历
数据结构
AIAdvocate9 小时前
Pandas_数据结构详解
数据结构·python·pandas
jiao000019 小时前
数据结构——队列
c语言·数据结构·算法
kaneki_lh10 小时前
数据结构 - 栈
数据结构
铁匠匠匠10 小时前
从零开始学数据结构系列之第六章《排序简介》
c语言·数据结构·经验分享·笔记·学习·开源·课程设计
热门推荐
01RAG 实践- Ollama+RagFlow 部署本地知识库02组基轨迹建模 GBTM的介绍与实现（Stata 或 R）032024年高教社杯数学建模国赛C题超详细解题思路分析04苍穹外卖面试总结05yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07Coze扣子平台完整体验和实践（附国内和国际版对比）08CCF-CSP认证考试 202406-3 文本分词 100分题解09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10借助 LocatorJS ，快速定位本地代码