【数据结构】线性表——带头双向循环链表

已于 2023-05-10 17:28:24 修改
阅读量981 收藏 30
点赞数 35
分类专栏： 数据结构理解与实现 文章标签： 链表 数据结构 c语言
于 2023-05-10 17:26:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_65596720/article/details/130605636
版权

文章目录

带头双向循环链表

  • 带头双向循环链表的优点

1.支持任意位置时间复杂度为O(1)的插入和删除。

2.按照需求申请释放空间，无需担心空间不够用，无需担心浪费。

3.带头可以省去链表为空时的判断，可以使代码更加简约

  • 带头双向循环链表的缺点

1.不可以进行下标随机访问。

2.缓存利用率低

带头双向循环链表是线性表的一种，带头双向循环链表是链式存储的线性表，不同于顺序表，链表在内存空间中不连续。

  • 带头：带头就是带哨兵位，可以省链表为空时进行的判断。

  • 双向：由结构体内的next指针下一条数据进行链接，由prev对前一条数据进行链接🧐。

  • 循环：以循环方式进行链接，头的（前一个）prev是尾，尾的next（后一个）是头。

PS:需要源码直接通过目录跳转到最后

带头双向循环链表主体结构

默认大小与扩容大小还有类型都可以是任意大小或类型

typedef int DListDataType;		//数据类型

typedef struct ListNode
{
	DListDataType data;	
	struct ListNode* prev;		//指针指向前一个结点
	struct ListNode* next;		//指针指向后一个结点
}LTNode;

在这里插入图片描述

带头双向循环链表操作函数介绍

  1. LTNode* InitLTNode(); //链表初始化
  2. void ListInsert(LTNode* pos, DListDataType x); //任意位置插入
  3. void ListPushBack(LTNode* phead, DListDataType x); //尾插
  4. void ListPushFront(LTNode* phead, DListDataType x); //头插
  5. void print(LTNode* phead); //输出链表
  6. void ListErase(LTNode* pos); //任意位置删除
  7. void ListPopBack(LTNode* phead); //尾删
  8. void ListPopFront(LTNode* phead); //头删
  9. LTNode* LTModify(LTNode* phead, DListDataType x); //修改指定结点
  10. LTNode* LTFind(LTNode* phead, DListDataType x); //查找指定结点
  11. void LTDestory(LTNode* phead); //销毁链表

为了代码方便阅读，将带头双向循环链表操作函数全部放在LinkedList.c文件中，将头文件放在LinkedList.h，测试文件test.c 😮

带头双向循环链表操作函数实现

为了方便调试，建议每写完1-2个函数就进行测试，初始化之后，首先实现print函数可以方便我们进行调试。

带头双向循环链表的初始化函数：

LTNode* Phead = InitLTNode();	//初始化哨兵位

LTNode* BuyNewNode(DListDataType x)		//开辟一个新结点
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("malloc");
		return NULL;
	}
	newnode->next = NULL;
	newnode->prev = NULL;
	newnode->data = x;
	return newnode;
}

LTNode* InitLTNode()
{
	LTNode* phead = BuyNewNode(-1);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}

必须先进行初始化哨兵位，将哨兵位指向自己形成循环

打印函数

先写出打印函数，方便进行调试

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

带头双向循环链表插入函数：

指定结点后插入和查找函数

两个函数可以配合使用，使用LTFind查找到需要插入的位置，然后使用ListInsert进行更改

LTNode* LTFind(LTNode* phead, DListDataType x)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

LTNode* BuyNewNode(DListDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("malloc");
		return NULL;
	}
	newnode->next = NULL;
	newnode->prev = NULL;
	newnode->data = x;
	return newnode;
}

void ListInsert(LTNode* pos,DListDataType x)
{
	assert(pos);
	LTNode* newnode = BuyNewNode(x);
	LTNode* prev = pos->prev;

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

在这里插入图片描述

头插

头插将新结点插入到哨兵位后面的结点

这里面有一种简单的写法，就是直接复用ListInsert，将哨兵位后面的结点传过去，也是头插的效果

void ListPushFront(LTNode* phead, DListDataType x)
{
	assert(phead);
    //第一种方法
	//ListInsert(phead->next,x);
    //第二种方法
	LTNode* newnode = BuyNewNode(x);
	LTNode* secound = phead->next;
	newnode->next = secound;
	secound->prev = newnode;
	phead->next = newnode;
	newnode->prev = phead;
}

尾插

从最后一个结点后面插入新结点

尾插也可以复用ListInsert函数

  • 尾插也会用到申请新结点的函数，这里不重复了
void ListPushBack(LTNode* phead, DListDataType x)
{
	assert(phead);
    //第一种办法
	//ListInsert(phead,x);
    //第二种办法
	LTNode* newnode = BuyNewNode(x);
	LTNode* tail = phead->prev;
	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;
}

带头双向循环链表删除函数

指定结点删除

删除指定结点，配合STFInd使用，将指定节点前一个结点的next连接到指定结点后一个结点，再将指定结点后面结点的prev连接到指定指定结点前一个结点。

void ListErase(LTNode* pos)
{
	assert(pos);
	LTNode* prev = pos->prev;
	LTNode* next = pos->next;
	prev->next = next;
	next->prev = prev;
    free(pos);
}

头删

记得进行断言，当只有一个哨兵位时与头结点为空都无法进行删除

可以对STErase进行复用

void ListPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead != phead->next);
    //第一种方法
	//ListErase(phead->next);
    //第二种
	LTNode* secound = phead->next;
	phead->next = secound->next;
	secound->next->prev = phead;
	free(secound);
}

尾删

void ListPopBack(LTNode* phead)
{
	assert(phead);
	assert(phead != phead->next);
    //第一种方法
    //ListErase(phead->prev);
    //第二种方法
	LTNode* tail = phead->prev;
	phead->prev = tail->prev;
	tail->prev->next = phead;
	free(tail);
}

带头双向循环链表修改函数

配合LTFind函数使用

LTNode* LTFind(LTNode* phead, DListDataType x)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

LTNode* LTModify(LTNode* phead, DListDataType x)
{
	LTNode* pos = LTFind(phead, x);
	int y;
	scanf("%d", &y);
	pos->data = y;
}

销毁带头双向循环链表

将每个结点依次释放。最后将哨兵位释放。

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

源代码文件

🌞🌞为了使代码更有阅读性，我们不建议把所有函数写在一个文件里，所以这里分成三个文件，模块化管理

test.c

测试文件

#include "DList.h"

void test1()
{
	LTNode* Phead = InitLTNode();
	ListPushBack(Phead, 666);
	ListPushBack(Phead, 777);
	ListPushBack(Phead, 9999);
	ListPushBack(Phead, 888);
	print(Phead);
	ListPopBack(Phead);
	print(Phead);
	ListPopFront(Phead);
	print(Phead);
	ListPopFront(Phead);
	ListPopFront(Phead);
	print(Phead);
	ListPushFront(Phead,111);
	print(Phead);
	ListPushFront(Phead, 112);
	print(Phead);
	LTDestory(Phead);
	Phead = NULL;

}

int main()
{
	test1();
}

DList.c

i将所有函数封装在此文件下

#include "DList.h"


LTNode* BuyNewNode(DListDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("malloc");
		return NULL;
	}
	newnode->next = NULL;
	newnode->prev = NULL;
	newnode->data = x;
	return newnode;
}
LTNode* InitLTNode()
{
	LTNode* phead = BuyNewNode(-1);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}

void ListInsert(LTNode* pos,DListDataType x)
{
	assert(pos);
	LTNode* newnode = BuyNewNode(x);
	LTNode* prev = pos->prev;

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

void ListPushBack(LTNode* phead, DListDataType x)
{
	//ListInsert(phead,x);
	assert(phead);
	LTNode* newnode = BuyNewNode(x);
	LTNode* tail = phead->prev;
	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;
}

void ListPushFront(LTNode* phead, DListDataType x)
{
	//ListInsert(phead->next,x);
	assert(phead);
	LTNode* newnode = BuyNewNode(x);
	LTNode* secound = phead->next;
	newnode->next = secound;
	secound->prev = newnode;
	phead->next = newnode;
	newnode->prev = phead;
}

void ListErase(LTNode* pos)
{
	assert(pos);
	LTNode* prev = pos->prev;
	LTNode* next = pos->next;
	prev->next = next;
	next->prev = prev;
	free(pos);
}

void ListPopBack(LTNode* phead)
{
	//ListErase(phead->prev);
	assert(phead);
	assert(phead != phead->next);
	LTNode* tail = phead->prev;
	phead->prev = tail->prev;
	tail->prev->next = phead;
	free(tail);
}

void ListPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead != phead->next);
	//ListErase(phead->next);
	LTNode* secound = phead->next;
	phead->next = secound->next;
	secound->next->prev = phead;
	free(secound);
}

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

LTNode* LTFind(LTNode* phead, DListDataType x)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

LTNode* LTModify(LTNode* phead, DListDataType x)
{
	LTNode* pos = LTFind(phead, x);
	int y;
	scanf("%d", &y);
	pos->data = y;
}

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

DLlist.h

将主程序所需要的函数全部在头文件中声明，增加代码阅读性

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <malloc.h>
#include <assert.h>

typedef int DListDataType;

typedef struct ListNode
{
	DListDataType data;
	struct ListNode* prev;
	struct ListNode* next;
}LTNode;

LTNode* InitLTNode();
void ListInsert(LTNode* pos, DListDataType x);
void ListPushBack(LTNode* phead, DListDataType x);
void ListPushFront(LTNode* phead, DListDataType x);
void print(LTNode* phead);
void ListErase(LTNode* pos);
void ListPopBack(LTNode* phead);
void ListPopFront(LTNode* phead);
LTNode* LTModify(LTNode* phead, DListDataType x);
LTNode* LTFind(LTNode* phead, DListDataType x);
void LTDestory(LTNode* phead);

撒花

这就是实现带头双向循环链表的全部内容了，创作不易，还请各位小伙伴多多点赞👍关注收藏⭐，以后也会更新各种关于c语言，数据结构的博客，撒花！

悲伤的猪大肠9
关注
  • 35
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 31
    评论
专栏目录
设双链表表示的线性表L=（a1,a2,....,an），试写一时间复杂度为O（n）的算法，将L改造为L=（a1,a2,,,,an....,a4,a2）。
10-13
设双链表表示的线性表L=（a1,a2,....,an），试写一时间复杂度为O（n）的算法，将L改造为L=（a1,a2,,,,an....,a4,a2）。
数据结构例题7
zzzbiu的博客
11-20 1033
1、设以带头结点的双向循环链表表示的线性表L=(a1，a2，…,an)，试写一算法，将L改造为L=(a1，a3，…，an…，a4，a2)。 void Exchange_DLinkList(DLinkList &L){ DLinkList p,q,tail; int count=0; //count记录数组下标；当数组下标为偶数时，当前结点移动到an后 p=L->next; tail=L->prior; //tail指向表尾结点an wh
线性表之带头双向循环链表
m0_62171658的博客
03-06 1265
初学者必备：线性表之带头双向循环链表接口实现和一些链表必备思想
设以带头结点的双向循环链表表示的线性表L= (a1,a2,…,an),试写一时间复杂度O(n)的算法，将L改造为 (a1,a3,…,an,…,a4,a2)。
热门推荐
TysonSir的博客
03-27 1万+
/* 将L中的元素，按如下规则插入新表，并返回新表。 （1,2）->(1,3,2)->(1,3,4,2)->(1,3,5,4,2)->(1,3,5,6,4,2)->... */ DuLinkList Transform(DuLinkList L);
设双链表表示的线性表L=（a1,a2,……an）,试写一时间复杂吨为O(n)的算法，将L改造为L=（a1,a3……an……,a4,a2）
11-29
设双链表表示的线性表L=（a1,a2,……an）,试写一时间复杂度为O(n)的算法，将L改造为L=（a1,a3……an……,a4,a2）
数据结构c版（1）-线性表之双向带头循环链表代码
最新发布
11-19
双向带头循环链表
数据结构 线性表双向循环链表的表示
11-13
配合严蔚敏老师教材伪代码,尽量保存原来的代码，包含小部分修改。
数据结构学习--线性表及其应用--链表
06-25
本程序的主要目的在于帮助同学熟练掌握线性表的基本操作在链式存储结构上的...通过本实验， 对链表基本操作及其组合应用的演练，加深对链表存储方法及其基本操作的理解，为以后进 一步学习更复杂的数据结构打下基础。
数据结构线性表的C语言代码
06-27
适合学习数据结构的同学
数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx
11-04
代码包含顺序表和单链表的基本操作（增删改查等，详见注释），并展示了两个具体使用例子，包括对基本操作的验证和合并两个有序线性表为一个有序表。代码均已通过Dev-C++5.4.0，为了防止误修改，文档已限制编辑，密码...
将双向循环链表L=(a1,a2,...,an)改造成L=(a1,a3,...,an,...,a4,a2)
积极奋斗的蜗牛
04-25 5912
设以带头结点的双向循环链表表示的线性 表L=(a1,a2,...,an)。试写一时间复杂度为O(n)的 算法，将L改造为L=(a1,a3,...,an,...,a4,a2)。 实现下列函数： void ReverseEven(BiLinkList &L); 双向循环链表类型定义如下： typedef struct BiNode {     ElemType      
【C++数据结构学习笔记---线性表】带头结点的双向循环链表
EnCaL
03-14 1218
【C++数据结构学习笔记---线性表】带头结点的双向循环链表 一个简单的实现例子，只用到了插入函数以及输出函数，初始化26个英文字母。 插入算法的思路：（insert）本算法为结点后插入 1、声明一结点p指向头结点，初始化i从0开始。 2、遍历链表，让指针p向后移动，直至移动到要插入元素的结点，即向后移动k次。 4、让指针q指向p的右边一个结点。 5、在系统中新建一个结点s。 接
数据结构-线性表之带头结点的双向循环链表
快乐江湖的博客
01-26 1078
文章目录前言实现（1）结构定义（2）基本函数（3）操作实现测试代码 前言 链表的类型有很多种（根据带头或不带头，循环或非循环等等），但是我们重点研究的只有两种，一种结构非常简单是无头单向非循环链表，有关它的操作见 数据结构-线性表之单链表 这种结果在开发中基本不会使用，因为因为结构简单往往意味着操作复杂，比如在求职中OJ题，有关链表的基本都用的是这种结构，关于这些OJ题感兴趣的见 链表经典题 另一种则是链表中结构最为复杂的——带头结点的双向循环链表 这种结构看起来确实是很复杂的，但是它的操作很简单
线性表和带头结点的双向循环链表
WhiskyCocktail的博客
11-29 459
带头节点的双链表的操作： #define _CRT_SECURE_NO_WARNINGS 1 #pragma once #include #include #include using namespace std; //2. 以C++的方式实现双向循环链表 typedef int DataType; struct Node { struct Node* _pNext; struct N
上机3rd作业-设以带头结点的双向循环链表表示的线性表L= (a1,a2,…,an),试写一时间复杂度O(n)的算法，将L改造为 (a1,a3,…,an,…,a4,a2)。
会变强的
10-11 3860
void DoubleLink::op() { cout &lt;&lt; "进行操作……" &lt;&lt; endl; Node *p1, *p2, *p4; p1 = phead-&gt;pre;//初始化为an，指向当前最后一个元素 if (count % 2 == 0) p2 = p1-&gt;pre-&gt;pre; else p2 = p1-&gt;pre; do...
线性表 - 带头结点的循环单链表
weixin_30485291的博客
09-12 183
List.h /******************************************************************** purpose: 带头结点的循环单链表 author: xianyun1230 QQ: 836663997 e-mail: [email protected] ...
高级线性表——静态链表
05-19
静态链表是一种使用数组来实现链表的数据结构。它的本质是利用数组来描述链表中结点之间的关系，数组中的每个元素存储着链表中一个结点的数据和指向下一个结点的指针，而指针则用数组下标来表示。 静态链表的实现...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值