数据结构入门指南：带头双向循环链表

最新推荐文章于 2024-05-20 22:31:31 发布
最新推荐文章于 2024-05-20 22:31:31 发布
阅读量5.1k 收藏 61
点赞数 72
分类专栏： 数据结构入门指南 文章标签： 链表 数据结构 经验分享 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2202_75605090/article/details/132105235
版权

前言

        链表一共有8种结构，但最常用的就是无头单向链表、和带头双向循环链表。单链表的结构存在着很多的缺陷，但它是许多数据结构的子结构，在刷题中经常见到，而带头双向循环链表弥补了单链表所有的缺陷，可以说是一个完美结构，虽然相对于单链表来说结构更复杂，但它的特性使它的实现逻辑较为简单，今天我就向大家一一介绍。

1.结构与优势

结构：

优势：

  1. 可以实现快速的插入和删除操作：由于链表的特性，插入和删除节点的时间复杂度为O(1)，不需要像数组一样需要移动其他元素。
  2. 可以实现快速的遍历操作：双向链表可以通过前向或后向的指针进行遍历，而不需要像单向链表那样只能从头节点开始遍历。
  3. 可以实现双向遍历：双向链表可以通过前向和后向的指针进行双向遍历，可以方便地从任意一个节点开始向前或向后遍历。
  4. 可以实现循环遍历：由于链表的循环性质，可以通过不断移动指针进行循环遍历，不需要额外的循环条件判断。
  5. 可以实现更多高级功能：带头双向循环链表可以实现更多高级功能，如反转链表、查找倒数第k个节点等。

总结，带头双向循环链表具有灵活性和高效性，适用于需要频繁插入、删除和遍历操作的场景。

2.链表实现      

 2.1 定义链表

        步入正题，带头双向循环链表，首先它是双向的，什么是双向呢？在单链表定义时会有指向下一个节点的指针，而双向链表有两个指针，一个指向下一个节点，一个指向上一个节点，可以实现前后双向遍历。

typedef struct ListNode
{
	int data;
	struct ListNode* next;//指向下一个节点的指针
	struct ListNode* prev;//指向上一个节点的指针
}LN;

 2.2 创建头节点

         和无头单向链表不同，带头双向循环链表它有头节点，所以在开始执行各操作之前，我们先创建一个头节点并初始化。

        创建头节点需要新建一个节点，在其他插入接口中也需要新建节点，那我们就封装一个创建新节点的函数，最后返回新建节点的地址。

LN* BuyListNode(Datatype x)
{
	LN* newnode = (LN*)malloc(sizeof(LN));
	if (newnode == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	return newnode;
}

         和无头单链表不同，这里带有头节点，就需要对头节点进行初始化一下，虽然在创建节点时就已经对节点进行了初始化，但头节点的初始化与新建节点初始化需求不同，所有这里需要单独进行初始化初始化节点时可以使用双指针，也可以直接返回头节点地址。

LN* InItNode()
{
	LN* phead = BuyListNode(-1);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}

         头节点进行初始化时，只需将两个指针指向自己，然后返回头节点的地址即可。

 2.3 尾插

        建好头节点后要怎么链接节点呢？我们先写一个尾插来体验一下它的便捷。在单链表中想要进行尾插，还需要遍历一遍链表找到尾节点，而带头双向循环链表就不需要，可以通过头节点直接找到尾节点：tail  =  phead -> prev ;头节点的前一个节点就是尾节点。

我们新建一个节点：

         要想插入就需要把尾节点的next改为新节点的地址，新节点的prev改为尾节点tail的地址

        再把新节点的next改为头节点的地址，把头节点的prev改位新节点的地址。

 

 整体逻辑就是这样，具体代码如下：

void PushBack(LN* phead, Datatype x)
{
	assert(phead);
	LN* tail = phead->prev;
	LN* newnode = BuyListNode(x);

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

2.4 输出链表

        为了便于后续的测试，我们先写一个函数用于输出链表数据。输出函数很简单。

void PrintList(LN* phead)
{
	assert(phead);
	LN* cur = phead->next;//有效节点不包含头节点
	printf("phead <->");
	while (cur != phead)
	{
		printf(" %d <->", cur->data);
		cur = cur->next;
	}
}

         这里需要注意的是遍历链表时的循环条件，由于它是循环链表，所有结束条件有所变化。其次是输出数据时不需要输出头节点的数据，头节点的下一个节点才是有效数据。

我们可以来测试一下：

void test1()
{
	LN* plist = InItNode();
	PushBack(plist, 1);
	PushBack(plist, 2);
	PushBack(plist, 3);
	PushBack(plist, 4);
	PushBack(plist, 5);
	PrintList(plist);
}

int main()
{
	test1();
	return 0;
}

 输出效果如下：

 2.5 尾删

        基本逻辑理解后，可以先自主尝试写一下尾删。思路也是非常的简单，但要注意的是，有效节点为0的情况。把尾节点的前一个节点next改为头节点地址，头节点的prev改为尾节点的前一个节点，最后释放掉尾节点的空间。

void PopBack(LN* phead)
{
	assert(phead);
	assert(phead->next != phead);
	LN* tail = phead->prev;
	LN* tailprev = tail->prev;

	tailprev->next = phead;
	phead->prev = tailprev;
	free(tail);
}

2.6 头插

        接下来我们进行头插操作，我们使用的是带头的形式，所有这里进行头插时，不像单链表那样需要使用二级指针，我们需要改的是头节点中的内容，所有使用一级指针就可以解决。

         此外头插时一定要注意操作的次序，避免后续操作有误。例如：

        如果不提前保存第一个节点的地址， 就会导致新节点链接后续节点时找节点麻烦或出现错误。

 正确的顺序如下图：

 代码实现：

void PushFront(LN* phead,Datatype x)
{
	assert(phead);
	LN* newnode = BuyListNode(x);
	newnode->next = phead->next;
	phead->next->prev = newnode;

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

}

         当然新手不建议这样写，这样写很容易把人搞晕，我们可以先保存第一个节点的地址，这样就不会搞错。代码如下：

void PushFront(LN* phead,Datatype x)
{
	assert(phead);
	LN* newnode = BuyListNode(x);
	LN* first = phead->next;

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

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

}

2.7头删

        这里头删也是非常简单，为了避免出错，我们可以额外创建两个指针，记录第一个节点和第二个节点，逻辑较为简单，就不再画逻辑图，代码如下：

void PopFront(LN* phead)
{
	assert(phead);
	assert(phead->next != phead);

	LN* first = phead->next;
	LN* second = first->next;

	free(first);

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

}

需要额外注意链表为空的情况。

2.8 节点个数

        统计节点个数很简单，和输出链表数据一样遍历一下链表统计链表个数代码如下：

int Listsize(LN* phead)
{
	assert(phead);
	int sz = 0;
	LN* cur = phead->next;
	while (cur != phead)
	{
		sz++;
		cur = cur->next;
	}
	return sz;
}

         有人可能会想：用头节点统计不也可以吗？还不用额外的去写一个函数。初始时把头节点的data初始化为0，每次插入data++。这种方式严格来说是不可以的，我们在写链表时每个节点不一定存储的是整形，也可能是字符型，虽然也能计数，但如果节点是1000呢？数据就溢出了，所以不建议那样写。

 2.9 查找

        查找也比较简单，不再多说，代码如下：

LN* ListFind(LN* phead, Datatype x)
{
	assert(phead);
	LN* cur = phead->next;
	while (cur!=phead)
	{
		if (cur->data == x)
			return cur;
		cur = cur->next;
	}
	return NULL;
}

 2.10 位置插入

         带头双向循环链表在位置插入时没有像单链表那样有位置前插入，位置后插入。这里的位置插入都是位置前插入，由于它是循环双向的链表，不像单链表那样不可以向前遍历，双向循环链表可以任意插入，所以位置后插入也并没有什么意义，就统一默认位置前插入。

        位置插入操作和上述的插入操作很类似，推荐额外创建一个指针保存节点信息，就可以避免操作时次序不当造成程序错误，代码如下：

void ListInsert(LN* pos, Datatype x)
{
	assert(pos);
	LN* newnode = BuyListNode(x);
	LN* posprev = pos->prev;

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

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

}

2.11 位置删除

        位置删除也一样很简单，我们多创建两个指针变量存储节点信息，就可以有效避免次序不当导致程序错误的问题。代码如下：

void PosErase(LN* pos)
{
	assert(pos);
	LN* posprev = pos->prev;
	LN* posnext = pos->next;

	free(pos);

	posprev->next = posnext;
	posnext->prev = posprev;
}

 2.12 销毁链表

        在链表使用完以后就要销毁，销毁也比较简单，代码如下：

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

         这样还需要注意的一点，在销毁链表的这个函数里虽然销毁了头节点，但是在头节点创建之初使用了结构体指针，在后续操作中都是通过这个指针将链表传递给函数，所以最后在调用销毁链表函数之后要将指向头节点的指针置为NULL，避免出现野指针。当然这里也可以使用二级指针在函数里将这个指针置为NULL。

 3. 源码

List.c

#include"List.h"
LN* BuyListNode(Datatype x)
{
	LN* newnode = (LN*)malloc(sizeof(LN));
	if (newnode == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	return newnode;
}
LN* InItNode()
{
	LN* phead = BuyListNode(-1);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}
void PrintList(LN* phead)
{
	assert(phead);
	LN* cur = phead->next;
	printf("phead <->");
	while (cur != phead)
	{
		printf(" %d <->", cur->data);
		cur = cur->next;
	}
	printf("\n");
}
void PushBack(LN* phead, Datatype x)
{
	assert(phead);
	LN* tail = phead->prev;
	LN* newnode = BuyListNode(x);

	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;
}
void PopBack(LN* phead)
{
	assert(phead);
	assert(phead->next != phead);
	LN* tail = phead->prev;
	LN* tailprev = tail->prev;

	tailprev->next = phead;
	phead->prev = tailprev;
	free(tail);
}
void PushFront(LN* phead,Datatype x)
{
	assert(phead);
	/*LN* newnode = BuyListNode(x);
	newnode->next = phead->next;
	phead->next->prev = newnode;

	newnode->prev = phead;
	phead->next = newnode;*/
	LN* newnode = BuyListNode(x);
	LN* first = phead->next;
	phead->next = newnode;
	newnode->prev = phead;

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

}
void PopFront(LN* phead)
{
	assert(phead);
	assert(phead->next != phead);

	LN* first = phead->next;
	LN* second = first->next;

	free(first);

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

}
int Listsize(LN* phead)
{
	assert(phead);
	int sz = 0;
	LN* cur = phead->next;
	while (cur != phead)
	{
		sz++;
		cur = cur->next;
	}
	return sz;
}
LN* ListFind(LN* phead, Datatype x)
{
	assert(phead);
	LN* cur = phead->next;
	while (cur!=phead)
	{
		if (cur->data == x)
			return cur;
		cur = cur->next;
	}
	return NULL;
}
void ListInsert(LN* pos, Datatype x)
{
	assert(pos);
	LN* newnode = BuyListNode(x);
	LN* posprev = pos->prev;

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

	newnode->prev = posprev;
	posprev->next = newnode;
}
void PosErase(LN* pos)
{
	assert(pos);
	LN* posprev = pos->prev;
	LN* posnext = pos->next;

	free(pos);

	posprev->next = posnext;
	posnext->prev = posprev;
}
void DestoryList(LN* phead)
{
	assert(phead);
	LN* cur = phead->next;
	while (cur != phead)
	{
		LN* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);
}

 List.h

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

typedef int Datatype;
typedef struct ListNode
{
	int data;
	struct ListNode* next;
	struct ListNode* prev;
}LN;

LN* BuyListNode(Datatype x);
LN* InItNode();
void PrintList(LN* phead);
void PushBack(LN* phead,Datatype x);
void PopBack(LN* phead);
void PushFront(LN* phead, Datatype x);
void PopFront(LN* phead);
LN* ListFind(LN* phead, Datatype x);
int Listsize(LN* phead);
void ListInsert(LN* pos, Datatype x);
void PosErase(LN* pos);
void DestoryList(LN* phead);

 test.c

#include"List.h"
void test1()
{
	LN* plist = InItNode();
	PushBack(plist, 1);
	PushBack(plist, 2);
	PushBack(plist, 3);
	PushBack(plist, 4);
	PushBack(plist, 5);
	PushFront(plist, 0);
	PopBack(plist);
	ListInsert(plist, 10);
	LN* pos = ListFind(plist, 10);

	ListInsert(pos, 11);

	PosErase(pos);
	PrintList(plist);
	DestoryList(plist);
	plist = NULL;
}
void test2()
{
	LN* plist = InItNode();
	PushBack(plist, 1);
	PushBack(plist, 2);
	PushBack(plist, 3);
	PushBack(plist, 4);
	PushBack(plist, 5);
	//PushFront(plist, 0);

	PopFront(plist);
	PrintList(plist);
}

int main()
{
	test1();
	return 0;
}

 

总结

        带头双向循环链表作为一种数据结构，在解决问题时展现了其独特的优势。通过快速的插入和删除操作，以及灵活的双向遍历和循环遍历能力，它为我们提供了一种高效、灵活的数据组织方式。在实际应用中，我们可以充分发挥带头双向循环链表的特性，优化算法设计，提高程序的效率和可维护性。通过深入学习和掌握带头双向循环链表，我们可以更好地解决实际问题，提升自己的编程能力。希望本文能够帮助读者对带头双向循环链表有更深入的理解，并在实践中得到应用。最后，感谢阅读！

清水加冰
关注
  • 72
    点赞
  • 踩
  • 61
    收藏
    觉得还不错? 一键收藏
  • 112
    评论
专栏目录
C语言数据结构之双向循环链表的实例
08-30
主要介绍了C语言数据结构之双向循环链表的实例的相关资料,需要的朋友可以参考下
数据结构入门指南：链表（新手避坑指南）
2202_75605090的博客
07-30 5801
前边我们学习了顺序表，顺序表是数据结构中最简单的一种线性数据结构，今天我们来学习链表，难度相较于顺序表会大幅增加，非常考验大家对结构体、指针的理解。但是也不要害怕，我会一一向大家解答疑惑，本期的内容先给初学者预预热，主要介绍在刚开始实现链表时注意的点以及逻辑基础，下期会将功能接口具体实现。}SLNode;定义链表这里就迎来了第一个坑，上述的这种形式很常见，对于初学者来说这里就有一个坑，这个链表定义的是否正确呢？这种方式是不正确的，为什么？
算法 64式 9、链表算法整理
qingyuanluofeng的专栏
07-31 498
1算法思想 单链表 1.1含义 线性表:具有相同数据类型的n个数据元素的有限序列 单链表:线性表的链式存储，通过一组任意的存储单元来存储线性表中的元素。 链表结点:包含数据域存放数据元素，next指针域存放后继结点的地址 类型描述如下: typedef struct LNode{ ElemType data; //数据域 struct L...
C++ list
weixin_39713646的博客
12-03 1073
“article_content clearfix csdn-tracking-statistics” data-pid=“blog” data-mod=popu_307 data-dsm = “post” &amp;amp;gt; 版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/u013006553/article/details/78158717...
Java面试宝典Beta5.0
cillent_boy的专栏
02-15 4099
pdf下载地址：Java面试宝典 第一章内容介绍 20 第二章JavaSE基础 21 一、Java面向对象 21 1. 面向对象都有哪些特性以及你对这些特性的理解 21 2. 访问权限修饰符public、private、protected, 以及不写（默认）时的区别(2017-11-12) 22 3. 如何理解clone对象 22 二、JavaSE语法（2017-11-12-wl） ...
《代码大全2》读书笔记
在路上
07-18 1300
第7章 高质量的子程序 7.1 创建子程序的正当理由 降低/隔离复杂度，隐藏实现细节，引入中间的、易懂的抽象 避免代码重复，支持子类化 提高可移植性，限制变化所带来的影响 简化复杂的逻辑判断，改善性能 7.2 在子程序层上设计 功能的内聚性：只做了一件事并把它做得很好，操作与名称相符 顺序上的内聚性：包含需按特定顺序执行的操作，它们共享数据且只有全部执行完功能才完整 通信上的内聚性：不同操作...
带头结点的双向循环链表数据结构
01-08
用C++和Java实现带头节点的双向循环链表，要继承linearList类，并实现它的所有功能，另外，必须实现双向迭代器。 实现带头节点的双向循环链表，要具有以下的功能： 判断表是否为空，如果为空则返回true，不空返回...
带头结点的双向循环链表
07-17
C++实现的带头结点的双向循环链表， 数据结构课设.。
python实现数据结构中双向循环链表操作的示例
12-16
看此博客之前建议先看看B站的视频python数据结构与算法系列课程，该课程中未实现双向循环链表的操作，所以我按照该视频的链表思路实现了双向循环链表的操作，欢迎大家阅读与交流，如有侵权，请联系博主！ 下面附上...
二叉树专题（有关二叉树的相关学习）
aaa114514aaaa的博客
05-14 1591
有关二叉树的学习，目前已经学习了大概2/5的样子，后面更加有难度的，比如搜索平衡二叉树，红黑树等知识，将在C++学习。
数据结构之树与二叉树
最新发布
paradiso989的博客
05-20 743
本文介绍了数据结构中树与二叉树的基础概念以及实现方式
【数据结构/C语言】深入理解 双向链表
2302_78391795的博客
05-20 735
双向链表是一种常见的数据结构，与单向链表类似，但它允许我们从两个方向遍历链表：向前和向后。每个节点包含三个部分：一个数据元素和两个指针，一个指向链表中的前一个节点，另一个指向链表中的下一个节点。 一般情况下，我们所说的双向链表指的是带头节点，双向，循环链表，以下若无特殊说明，均代表此含义。
【数据结构】单链表逆置（详解）————四种方法
lzh20040919的博客
05-17 407
逆置就是把最后一个数据提到最前面，倒数第二个放到第二个……依次类推，直到第一个到最后一个。由于链表没有下标，所以不能借助下标来实行数据的逆置，要靠空间的转移来完成链表的逆置，这里采用没有头节点的链表来实现逆置。
数据结构之链表
qq_63448996的博客
05-19 459
2.然后，从第二个节点开始，依次将每个节点插入到头节点之后。这样，原来的第二个节点就变成了新的头节点，原来的第三个节点就变成了新的第二个节点，
数据结构：五种查找算法
weixin_45880844的博客
05-20 386
二分查找是在有序数组中查找特定元素的一种非常高效的算法。它通过比较数组中间的元素来工作，如果中间元素不是要找的元素，则根据该元素与目标值的大小关系，决定是在左半部分还是在右半部分继续查找。插值查找是二分查找的一种改进，它利用数据分布的特性来减少搜索范围。斐波那契查找是基于斐波那契数列的查找算法，它将查找区间分成不确定的两部分，类似于二分查找。线性查找是通过遍历数组中的每个元素来查找特定值的方法。它是最简单的查找算法之一。哈希查找通常不是通过比较元素本身来查找，而是通过使用哈希表的键值来快速定位元素。
Python学习———— 数据结构--序列
2302_80888286的博客
05-20 603
Python学习———— 数据结构--序列
【数据结构】二叉树(Binary Tree)
炸掉地球的博客
05-11 147
二叉树是一种特殊的树，每个结点最多只能有两个子结点，即二叉树不存在度大于2的结点。 二叉树可以分为三个部分：根、左子树、右子树，每颗子树又可以划分为这三个部分，一直递归到叶子结点，叶子结点是其本身的根结点。 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树。
【数据结构】2024.5.17
white__ice的博客
05-17 298
其中siz记录每个节点下子孙节点的个数，判断使用这一次优惠券能带来的最大收益，每次决策前将两组的最小值取出比较，还有用bitset，真的非常好用。依照题意对值大于k的节点进行查找。即时向红黑树中添加新元素实现查询。通过遍历排序后的问题对答案求解。这里我们使用pb_ds大显身手。整体就是非常纯粹简单的分块，所以我们对问题排序，优化程序。分别是折前价格和折后价格。由此判断是否选择使用。以上是一个错误做法，（原题hack数据）用del堆维护收益，题中并没有要求在线，
数据结构-双向循环链表
10-23
双向循环链表是一种链式存储结构，它的每个节点都有两个指针，一个指向前驱节点，一个指向后继节点。与单向链表不同的是，双向循环链表的尾节点的后继节点指向头节点，头节点的前驱节点指向尾节点，形成一个环形结构。这种结构的好处是可以方便地在链表中进行前后遍历，而不需要像单向链表那样记录前驱节点。在双向循环链表中，插入和删除操作比较灵活，可以在任意位置进行操作。 双向循环链表的节点结构包含三个部分：数据域、前驱指针和后继指针。其中，前驱指针指向前一个节点，后继指针指向后一个节点。在双向循环链表中，头节点的前驱指针指向尾节点，尾节点的后继指针指向头节点。 双向循环链表的插入操作包括在链表头插入、在链表尾插入和在链表中间插入三种情况。删除操作也包括在链表头删除、在链表尾删除和在链表中间删除三种情况。在进行插入和删除操作时，需要注意指针的指向关系，以保证链表的正确性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值