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

最新推荐文章于 2024-09-11 02:02:22 发布
最新推荐文章于 2024-09-11 02:02:22 发布
阅读量353 收藏 2
点赞数 1
分类专栏： 数据结构（C语言实现） 文章标签： 数据结构 链表 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43570634/article/details/131729655
版权

链表的分类

如下
在这里插入图片描述
根据上述的三种组合，一共分为8类

实现带有哨兵位的双向的循环链表

定义节点的结构

typedef int LTDataType;

typedef struct ListNode
{
	struct ListNode* next;
	struct ListNode* prev;

	LTDataType data;
}LTNode;

初始化单个节点

LTNode* BuyListNode(LTDataType x)
{
	LTNode* newnode=(LTNode*)malloc(sizeof(LTNode));
	if (newnode==NULL)
	{
		perror("malloc fail");
	}

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

	return newnode;
}

初始化带有哨兵位的双向循环链表

作用：使链表在无数据的情况下就具有循环的特点

LTNode* LTInit()
{
	LTNode* phead = BuyListNode(-1);

	phead->next = phead;
	phead->prev = phead;

	return phead;
}

打印链表

哨兵位phead一定不能为空，否则无法连接下面的节点

void LTPrint(LTNode* phead)
{
	assert(phead);

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

	printf("\n");
}

销毁链表

void LPDestroy(LTNode* phead)
{
	assert(phead);

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

	free(phead);

}

尾插

需要三个节点即可布置好顺序
顺序为：tail newnode phead
在这里插入图片描述

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

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

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

}

尾删

增加一个函数用于判断除哨兵位以外是否有其它的节点
bool类型只有两个取值：true和false
需要三个节点，顺序为：tailprev，tail，phead
在这里插入图片描述

bool LTEmpty(LTNode* phead)
{
	assert(phead);
	return phead->next == phead;
}

void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));

	LTNode* tail = phead->prev;
	LTNode* tailprev = tail->prev;

	tailprev->next = phead;
	phead->prev = tailprev;

	free(tail);
}

头插

需要三个节点即可布置好顺序
顺序为：phead newnode first

在这里插入图片描述

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

	LTNode* newnode = BuyListNode(x);
	LTNode* first = phead->next;

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

头删

增加一个函数用于判断除哨兵位以外是否有其它的节点
bool类型只有两个取值：true和false
需要三个节点，顺序为：phead，tail，tailnex
在这里插入图片描述

void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));

	LTNode* tail = phead->next;
	LTNode* tailnex = tail->next;

	phead->next = tailnex;
	tailnex->prev = phead;

	free(tail);
}

find函数

从哨兵位的下一个节点开始遍历，直至找到该元素或者遍历到哨兵位结束

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

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

	return NULL;
}

在任意位置之前插入

任意位置之前的插入需要搭配find函数来使用，需要三个节点，顺序为：posprev，newnode，pos
可以使用它来进行头插和尾插，分别可以表示为LTInsert(phead->next, x) LTInsert(phead, x)
在这里插入图片描述

void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);

	LTNode* newnode= BuyListNode(x);
	LTNode* posprev = pos->prev;

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

在这里插入图片描述

任意位置的删除

道理同任意位置的插入
在这里插入图片描述

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

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

	posprev->next = posnex;
	posnex->prev = posprev;

	free(pos);
}

结果如下：
在这里插入图片描述

全部代码

list.h

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

typedef int LTDataType;

typedef struct ListNode
{
	struct ListNode* next;
	struct ListNode* prev;

	LTDataType data;
}LTNode;

//创建单个的节点
LTNode* BuyListNode(LTDataType x);
//初始化
LTNode* LTInit();
//
void LTPrint(LTNode* phead);
void LPDestroy(LTNode* phead);

//尾插
void LTPushBack(LTNode* phead, LTDataType x);
//尾删
void LTPopBack(LTNode* phead);

//头插
void LTPushFront(LTNode* phead, LTDataType x);
//头删
void LTPopFront(LTNode* phead);

LTNode* LTFind(LTNode* phead, LTDataType x);

//任意位置之前的插入
void LTInsert(LTNode* pos, LTDataType x);
//任意位置的删除
void LTErase(LTNode* pos);

list.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "list.h"

LTNode* BuyListNode(LTDataType x)
{
	LTNode* newnode=(LTNode*)malloc(sizeof(LTNode));
	if (newnode==NULL)
	{
		perror("malloc fail");
	}

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

	return newnode;
}

LTNode* LTInit()
{
	LTNode* phead = BuyListNode(-1);

	phead->next = phead;
	phead->prev = phead;

	return phead;
}

void LTPrint(LTNode* phead)
{
	assert(phead);

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

	printf("\n");
}

void LPDestroy(LTNode* phead)
{
	assert(phead);

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

	free(phead);

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

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

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

}

bool LTEmpty(LTNode* phead)
{
	assert(phead);
	return phead->next == phead;
}

void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));

	LTNode* tail = phead->prev;
	LTNode* tailprev = tail->prev;

	tailprev->next = phead;
	phead->prev = tailprev;

	free(tail);
}

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

	LTNode* newnode = BuyListNode(x);
	LTNode* first = phead->next;

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

void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));

	LTNode* tail = phead->next;
	LTNode* tailnex = tail->next;

	phead->next = tailnex;
	tailnex->prev = phead;

	free(tail);
}

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

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

	return NULL;
}

void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);

	LTNode* newnode= BuyListNode(x);
	LTNode* posprev = pos->prev;

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

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

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

	posprev->next = posnex;
	posnex->prev = posprev;

	free(pos);
}

test.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);
	LTPopBack(plist);
	LTPrint(plist);
}

void Test2()
{
	LTNode* plist = LTInit();
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);
	LTPushFront(plist, 100);
	LTPushFront(plist, 200);
	LTPushFront(plist,300);
	LTPrint(plist);
	LTPopFront(plist);
	LTPrint(plist);

}
void Test3()
{
	LTNode* plist = LTInit();
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTNode* pos=LTFind(plist, 3);
	if (pos==NULL)
	{
		perror("pos NULL");
	}
	LTInsert(pos, 100);
	LTPrint(plist);
	LTErase(pos);
	LTPrint(plist);
}
int main()
{
	//Test1();
	//Test2();
	Test3();
	return 0;
}

链表和顺序表的区别

在这里插入图片描述

局部性原理：加载指定的数据，可能会把与其物理内存之后的数据加载上去。
根据局部性原理，顺序表在载入缓存中时，可能会把与之相邻的数据一同载入，但是，链表的地址并不是相邻的，在载入相应的链表的时候不会把相邻的链表载入缓存。
因此顺序表的缓存利用率比较高。

登 风
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】带头双向循环链表
m0_55065718的博客
05-13 243
带头双向循环链表的基础知识点更新啦~
数据结构 之 带头循环双链表
edc370的博客
04-05 673
在数据结构中我们经常会接触到链表，链表也分好多种，带头结点和不带头结点、循环和不循环、单向链表和双向链表而在众多不同结构的链表中 带头循环双链表可以说是一种最优的链表结构相比于单链表只能访问当前结点的后续结点的局限性，双链表既可以访问前面结点也可以访问后面结点其次循环的情况下相比于非循环的链表在访问尾节点时，非循环的链表余姚遍历整个链表才能访问尾节点，而循环链表由于它的循环特性，不用遍历链表，头结...
数据结构-带头双向循环链表
m0_61433144的博客
07-18 1499
链表的种类非常丰富，有带头结点的或不带头结点的，有单向的或双向的，有循环的或非循环的，这样组合起来有2*2*2=8种链表结构。头结点与头指针的概念：不管带不带头结点，头指针都始终指向链表的第一个结点，而头结点是带头链表中第一个结点，该结点通常不存储数据。 引入头结点可以带来两个优点：1.由于第一个数据结点的位置被存储在头结点的指针域中，因此在链表的第一个位置上的操作和在链表其他位置上的操作一致，无须进行特殊处理。2.无论链表是否为空，其头指针都指向头结点，因此空表与非空表的处理也得到统一。........
数据结构初阶--带头双向循环链表
weixin_36194037的博客
07-26 1132
循环单链表虽然能够实现从任一结点出发沿着链能找到其前驱结点，但时间耗费是O(n)。如果希望从表中快速确定某一个结点的前驱，另一个解决方法就是在单链表的每个结点里再增加一个指向其前驱的指针域prior。这样形成的链表中就有两条方向不同的链，称之为双(向)链表。与单链表类似，双链表也可增加头结点使双链表的某些运算变得方便。同时双向链表也可以有循环表，称为双向循环链表。由于在双向链表中既有前向链又有后向链，寻找任一结点的直接前驱结点与直接后继结点都变得非常方便了。//定义}LTNode;
数据结构--带头双向循环链表
2302_80919983的博客
09-01 507
带头双向循环链表
数据结构c版（1）-线性表之双向带头循环链表代码
11-19
在本篇文章中，我们将深入探讨一个特定的数据结构——双向带头循环链表，它是线性表的一种实现方式。在C语言中，这种数据结构尤其常见，因为C语言提供底层内存管理和指针操作的能力，使得我们能够直接构建复杂的链式...
数据结构6----带头双向循环链表的实现
cainiaochufa2021的博客
04-08 3252
1.介绍了链表分为哪几类，每一类有哪种特点。 2.实现了双向带头循环链表。 3.在文章最后对比了链表和顺序表的优缺点。
带头结点的双向循环链表数据结构
01-08
【带头结点的双向循环链表数据结构】 在数据结构中，双向循环链表是一种特殊类型的数据结构，它允许从两个方向遍历链表。在本案例中，我们需要使用C++和Java分别实现这种数据结构，并确保它们符合指定的要求。 在...
数据结构--栈的双向带头循环链表实现
qq_35297945的博客
01-10 734
1 链表实现栈的示意图 使用双向带头循环链表来表示栈，表头和表尾均可表示为栈顶，这里以表头为栈顶为例。 进行入栈操作（头插）： 进行出栈操作（头删）： 2 链表实现栈 2.1 头文件及其定义 #include<stdio.h> #include<stdlib.h> typedef int STDataType; typedef struct LstkNode { STDataType data; struct ListNode* prev; struct ListNod
数据结构----双向链表（循环和非循环）
weixin_41521306的博客
03-16 1189
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点，一般分为带头结点双向链表，和不带头结点（带头指针）双向链表（多用做循环双向链表）。 1.带头结点的双向链表（有两个指针域，一个指向它的前驱，一个指向它的后继） （1）、双向链表的存储结构 双向链表和单链表的区别在于...
22_图论中的高级数据结构
最新发布
刘炫320的博客
09-11 501
菜鸟：听起来不错，能先讲讲邻接表吗？老鸟：好的。邻接表是一种更为内存友好的图表示方法。相比邻接矩阵，邻接表的空间复杂度是O(V + E)，其中V是顶点数，E是边数。在邻接表中，每个顶点都会有一个列表，列表中存储与该顶点相邻的所有顶点。# 邻接表的表示方法graph = {菜鸟：这个看起来更直观一些，查询一个顶点的邻居也很方便。老鸟：是的，而且插入和删除操作也相对简单。让我们继续深入一些，看看如何使用邻接表进行图的遍历。老鸟：今天我们讨论了邻接表、DFS、BFS、以及Dijkstra算法。
浙大数据结构：树的定义与操作
qq_74924951的博客
09-08 329
【代码】浙大数据结构：树的定义与操作。
[数据结构]红黑树之插入操作(RBTree)
SUICIDEKILL的博客
09-05 1091
只着重介绍插入操作的实现。
数据结构之红黑树的 “奥秘“
robin_suli的博客
09-09 912
红黑树在经常进行增删的结构中性能比 AVL树更优，而且红黑树实现比较简单，所以实际运用中红黑树更多。红黑树不追求绝对平衡，其只需保 证最长路径不超过最短路径的2倍(相对平衡)每个结点上增加一个存储位表示结点的颜色。红黑树和AVL树都是高效的平衡二叉树。没有一条路径会比其他路径长出俩倍。先grandParent右旋。围绕红黑树上面的几条性质。
《数据结构（C语言版）第二版》第八章-排序（8.3-交换排序、8.4-选择排序）
qq_44883214的博客
09-06 407
【算法特点】(1) 稳定排序。(2) 可用于链式存储结构。(3) 移动记录次数较多，算法平均时间性能比直接插入排序差。当初始记录无序，n较大时， 此算法不宜采用。26。
数据结构之抽象数据类型（c语言版）
z171347的博客
09-05 367
下面以复数为例给出完整的抽象数据类型的定义。
数据结构——顺序表的实现和注释浅解
hedhjd的博客
09-05 342
【代码】数据结构——顺序表的实现和注释浅解。
数据结构—内核链表
LEE_C17的博客
09-05 529
内核链表是一种在操作系统内核中广泛使用的数据结构，特别是在Linux内核中。它主要用于高效地管理和遍历内核中的对象，如进程、设备、文件等。每个链表节点都包含指向前一个节点和后一个节点的指针，这使得从任何节点出发都可以方便地遍历整个链表。内核链表的设计使其能够通用于不同类型的内核对象。通过在结构体中包含一个指向链表节点的指针（如struct list_head类型），任何结构体都可以轻松地加入到链表中，而无需修改链表本身的结构。
一天一道算法题day02
m0_74004434的博客
09-06 1204
对于 mm 个数组对 (c[i],b)(c[i],b)，即 (c[1],b),(c[2],b),…,(c[m],b)(c[1],b),(c[2],b),…,(c[m],b) ，根据前面的问题要求，分别计算出它们的答案，最后，你要给出所有答案的总和。注意，数组 c[i]c[i] 是从 aa 数组转化而来的。现在，你需要找到最小的操作次数，使得对于所有的 1≤i≤k1≤i≤k ，都有 ai<biai​<bi​。对于每个测试样例，第一行包含两个整数 n,m，表示数组 a,b的大小，以及元素 a1值的上限。
数据结构讲解：循环链表与双向链表操作
在数据结构与算法的学习中，循环链表和双向链表是两种重要的链式存储结构，它们扩展了单链表的功能，为数据操作提供了更多的便利。 5.1 带头结点的链表 带头结点的链表是在线性链表的第一个元素前增加一个特殊的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值