数据结构_带头结点的双向循环链表

已于 2022-08-09 17:09:49 修改
阅读量2.3k 收藏 14
点赞数 3
分类专栏： 数据结构 文章标签： 数据结构 链表 算法
于 2022-08-09 17:04:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43853178/article/details/126249825
版权

这篇博客整理带头结点的双向循环链表。带头结点的双向循环链表在进行操作的时候是要比单链表更方便的，比如说在尾删的时候，不需要遍历整个链表，头结点的上一个结点就是尾结点。凡是涉及到寻找尾结点的操作，都会比单链表方便很多。

文章目录

带头结点的双向循环链表实现

介绍

在这里插入图片描述
如上图所示，相比于单链表多了头结点head，每个结点里面有两个指针，分别指向前一个结点和后一个结点。

结构体

typedef int SLDataType;

typedef struct DListNode
{
	struct DListNode* prev; // 指向前一个结点的指针
	struct DListNode* next; // 指向后一个结点的指针
	SLDataType data;        // 结点中的数据
}DListNode;

接口函数实现

（1）创建结点

// 创建一个结点(没有指向，只有值)
DListNode* BuyListNode(SLDataType x)
{
	DListNode* node = (DListNode*)malloc(sizeof(DListNode));

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

	return node;
}

（2）初始化

// 创建返回链表的头结点
DListNode* ListCreate()
{
	DListNode* head = BuyListNode(0);
	head->next = head;
	head->prev = head;

	return head;
}

和单链表不同的是，带头结点的双向循环链表需要进行初始化，创建一个头结点。初始的时候，头结点的两个指针都是指向自身的。

（3）链表销毁

// 双向链表销毁
void ListDestory(DListNode* phead)
{
	assert(phead);

	DListNode* cur = phead->next;

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

注意：

  1. 由于该链表是循环的，所以当我们遍历的当前结点的地址就是头结点的地址时，说明整个链表已经遍历完了。
  2. 为了避免野指针，我们应该让phead等于NULL。没有写phead==NULL是因为我们传入的是一级指针，即传入的是phead的一份拷贝，就算写了这一句代码也不能真的修改phead，所以就需要自己在外面写这句代码。

（4）打印链表

// 双向链表打印
void ListPrint(DListNode* phead)
{
	assert(phead);

	DListNode* cur = phead->next;

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

（5）尾插

// 双向链表尾插
void ListPushBack(DListNode* phead, SLDataType x)
{
	assert(phead);

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

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

}

这就比单链表要好多了，不需要通过遍历来寻找尾结点。

（6）尾删

// 双向链表尾删
void ListPopBack(DListNode* phead)
{
	assert(phead);

	DListNode* tail = phead->prev;
	if (tail == phead)
	{
		printf("链表已空!\n");
		return;
	}

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

}

（7）头插

// 双向链表头插
void ListPushFront(DListNode* phead, SLDataType x)
{
	assert(phead);

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

}

（8）头删

// 双向链表头删
void ListPopFront(DListNode* phead)
{
	assert(phead);

	if (phead->next == phead)
	{
		printf("链表已空!\n");
		return;
	}

	DListNode* first = phead->next;

	phead->next = first->next;
	first->next->prev = phead;
	free(first);

}

（9）查找

// 双向链表查找
DListNode* ListFind(DListNode* phead, SLDataType x)
{
	assert(phead);

	DListNode* cur = phead->next;

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

	return NULL;
}

（10）在pos位置插入

// 双向链表在pos的前面进行插入
void ListInsert(DListNode* pos, SLDataType x)
{
	assert(pos);

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

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

}

跟单链表相比，这里也省去了遍历的步骤，pos->prev直接就能找到上一个结点。

（11）删除pos位置的节点

// 双向链表删除pos位置的节点
void ListErase(DListNode* pos)
{
	assert(pos);

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

	free(pos);

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

}

完整代码及测试程序

一共三个程序

  1. DList.h头文件
  2. DList.c接口函数实现
  3. Test_DList.c测试程序
#pragma once
#include<stdio.h>
#include<assert.h>
#include<malloc.h>

typedef int SLDataType;

typedef struct DListNode
{
	struct DListNode* prev;
	struct DListNode* next;
	SLDataType data;
}DListNode;

// 创建返回链表的头结点.
DListNode* ListCreate();
// 双向链表销毁
void ListDestory(DListNode* phead);
// 双向链表打印
void ListPrint(DListNode* phead);
// 双向链表尾插
void ListPushBack(DListNode* phead, SLDataType x);
// 双向链表尾删
void ListPopBack(DListNode* phead);
// 双向链表头插
void ListPushFront(DListNode* phead, SLDataType x);
// 双向链表头删
void ListPopFront(DListNode* phead);
// 双向链表查找
DListNode* ListFind(DListNode* phead, SLDataType x);
// 双向链表在pos的前面进行插入
void ListInsert(DListNode* pos, SLDataType x);
// 双向链表删除pos位置的节点
void ListErase(DListNode* pos);

#include "DList.h"

// 创建一个结点(没有指向，只有值)
DListNode* BuyListNode(SLDataType x)
{
	DListNode* node = (DListNode*)malloc(sizeof(DListNode));

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

	return node;
}

// 创建返回链表的头结点
DListNode* ListCreate()
{
	DListNode* head = BuyListNode(0);
	head->next = head;
	head->prev = head;

	return head;
}

// 双向链表销毁
void ListDestory(DListNode* phead)
{
	assert(phead);

	DListNode* cur = phead->next;

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

}

// 双向链表打印
void ListPrint(DListNode* phead)
{
	assert(phead);

	DListNode* cur = phead->next;

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

// 双向链表尾插
void ListPushBack(DListNode* phead, SLDataType x)
{
	assert(phead);

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

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

}

// 双向链表尾删
void ListPopBack(DListNode* phead)
{
	assert(phead);

	DListNode* tail = phead->prev;
	if (tail == phead)
	{
		printf("链表已空!\n");
		return;
	}

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

}

// 双向链表头插
void ListPushFront(DListNode* phead, SLDataType x)
{
	assert(phead);

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

}

// 双向链表头删
void ListPopFront(DListNode* phead)
{
	assert(phead);

	if (phead->next == phead)
	{
		printf("链表已空!\n");
		return;
	}

	DListNode* first = phead->next;

	phead->next = first->next;
	first->next->prev = phead;
	free(first);

}

// 双向链表查找
DListNode* ListFind(DListNode* phead, SLDataType x)
{
	assert(phead);

	DListNode* cur = phead->next;

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

	return NULL;
}

// 双向链表在pos的前面进行插入
void ListInsert(DListNode* pos, SLDataType x)
{
	assert(pos);

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

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

}

// 双向链表删除pos位置的节点
void ListErase(DListNode* pos)
{
	assert(pos);

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

	free(pos);

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

}

#include "DList.h"

void Test()
{
	DListNode* plist = ListCreate();

	ListPushBack(plist, 3);
	ListPushBack(plist, 4);
	ListPushBack(plist, 5);
	printf("尾插3，4，5的结果：");
	ListPrint(plist);


	ListPopBack(plist);
	ListPopBack(plist);
	printf("尾删2次的结果：");
	ListPrint(plist);

	ListPushFront(plist, 2);
	ListPushFront(plist, 1);
	ListPushFront(plist, 0);
	printf("头插2，1，0的结果：");
	ListPrint(plist);


	ListPopFront(plist);
	ListPopFront(plist);
	printf("头删2次的结果：");
	ListPrint(plist);

	DListNode* pos = ListFind(plist, 3);

	ListInsert(pos, 7);
	printf("找到3，在3前面插入7的结果：");
	ListPrint(plist);

	pos = ListFind(plist, 7);
	ListErase(pos);
	printf("找到7，删除7的结果：");
	ListPrint(plist);

	ListDestory(plist);
	plist = NULL;
}

int main()
{
	Test();

	return 0;
}
从头开始的小白
关注
  • 3
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构 之 带头循环双链表
edc370的博客
04-05 659
在数据结构中我们经常会接触到链表，链表也分好多种，带头结点和不带头结点、循环和不循环、单向链表和双向链表而在众多不同结构的链表中 带头循环双链表可以说是一种最优的链表结构相比于单链表只能访问当前结点的后续结点的局限性，双链表既可以访问前面结点也可以访问后面结点其次循环的情况下相比于非循环的链表在访问尾节点时，非循环的链表余姚遍历整个链表才能访问尾节点，而循环链表由于它的循环特性，不用遍历链表，头结...
【数据结构】带头双向循环链表
m0_55065718的博客
05-13 203
带头双向循环链表的基础知识点更新啦~
【数据结构与算法】(6)：带头结点的双向循环链表
更新C/C++，数据结构与算法，计算机视觉，深度学习，目标检测
05-31 2959
带头结点的双向循环链表
数据结构四：线性表之带头结点的单向循环链表的设计
最新发布
weixin_47040031的博客
04-25 1508
单向循环链表的插入，删除算法与单链表基本一致，所不同的是若操作在链表的尾部进行，则判断条件发生变化不同，以让单链表继续保持循环的性质。因此，需要记住循环链表判空和判断是否为尾巴结点的条件！即循环链表中没有NULL指针。涉及遍历操作时，其终止条件就不再是像非循环链表那样判别p或p->next是否为空，而是判别它们是否等于某一指定指针，如头指针或尾指针等。
数据结构——双向循环带头结点链表
weixin_68644350的博客
07-05 2425
双向循环带头结点链表的操作接口的实现
一起学数据结构（4）——带头结点的双向循环链表
2301_76836325的博客
08-25 684
对双向循环链表的结点，虽然也是由数据域和指针域构成，但是，双向循环链表的指针域中，分别存储了上一个结点的地址和下一个结点的地址，为了后续方便表示，将存储上一个结点地址的指针命名为。后，根据上面给出的双向循环的链表结构不难发现：链表的第一个结点并不存储整型元素，只是用于链接下一个结点和最后一个结点。，虽然形式参数是一级指针，并且同样改变了形参的内容，但是最后的返回值返回了形式参数中存储的地址，只需要在外部定义一个指针用于接受函数的返回值即可。与单链表相同，双向链表中的结点需要同时存储多种类型的数据。
数据结构——带头结点双向循环链表
m0_63020222的博客
03-16 7295
带头结点双向循环链表基本操作（c语言版）
带头结点的双向循环链表
07-17
总结来说，带头结点的双向循环链表是一种灵活且实用的数据结构，它在C++中的实现涉及节点定义、链表操作的实现以及封装为类。理解并掌握这一数据结构对于提升编程能力，尤其是处理复杂算法问题具有重要意义。
带头结点的双向循环链表数据结构
01-08
【带头结点的双向循环链表数据结构】 在数据结构中，双向循环链表是一种特殊类型的数据结构，它允许从两个方向遍历链表。在本案例中，我们需要使用C++和Java分别实现这种数据结构，并确保它们符合指定的要求。 在...
数据结构-基本算法-不带头结点的循环链表
05-21
数据结构-基本算法-不带头结点的循环链表(学生时代源码，调试可运行)
数据结构c版（1）-线性表之双向带头循环链表代码
11-19
在本篇文章中，我们将深入探讨一个特定的数据结构——双向带头循环链表，它是线性表的一种实现方式。在C语言中，这种数据结构尤其常见，因为C语言提供底层内存管理和指针操作的能力，使得我们能够直接构建复杂的链式...
链表-使用C语言实现非循环双向链表-带头结点+尾结点.zip
03-13
本篇将详细介绍如何使用C语言来实现一个非循环双向链表，包括带头结点和尾结点的链表。 首先，让我们定义链表节点的数据结构。在非循环双向链表中，每个节点包含两个指针，分别指向它的前一个节点和后一个节点。...
【数据结构】带头双向循环链表的实现
柳阿九的博客
02-09 216
带头双向循环链表简介 带头双向循环链表结构如下： 带头双向链表的特点： 空链表不是没有结点，而是有一个头结点的链表，此时头结点的前后指针都指向自己，且头结点中存储的元素非链表中的有效元素。 带头双向循环链表的头删，是删除头结点的下一个结点，而非head结点。 带头双向循环链表的尾删，无需遍历该链表去寻找最后一个结点，因为头结点指向的前一个节点就是最后一个结点。 带头双向循环链表的定义及功能实现 /////dclist.h #pragma once #include"commen.h" typedef
【数据结构】之 链表 带头双向循环 （C语言）（含完整代码）
weixin_53936115的博客
12-30 1162
1、基本概念： 带头双向循环链表：一个节点有两个指针，一个指向前一个节点（前指针）一个指向下一个节点（后指针）；有一个头结点，该节点不存储如何值，头结点的前指针指向该链表的最后一个节点。最后一个节点的后指针指向头结点。 基本逻辑结构： 2、代码实现 2.1 准备工作： 首先对头文件的引用和创建一个结构体。这个结构体就是链表的节点，一个节点包含数据项和两个指针项，一个指针指向前一个节点的地址，另一个指针指向下一个节点的地址。DLNode* phead=NULL表示创建一个节点的指...
带头双向循环链表
m0_74126249的博客
05-31 203
需要先给大家说明的是，在讲解单链表函数实现的时候，头插头删等等这些需要改变头节点的指针的函数，我们的形参都使用的是二级结构体指针，但是我们带头双向循环链表的所有函数形参使用一级指针即可，因为带哨兵位的头节点中存储了头节点地址，因此想要改变头节点，只需要改变哨兵位头节点这个结构体的成员变量(next)即可，不需要改变外部的plist，因此一级指针就行。思路：和单链表一样，需要遍历整个链表，但关键点就是循环结束的条件，单链表是尾节点的next指向空，而带头双向循环链表特点是尾节点的next是phead。
【数据结构】带头双向循环链表（小白入门必备知识）
weixin_65186652的博客
08-19 2166
c语言数据结构--带头双向循环链表，小白入门必备知识
c++双向循环链表带头结点解决约瑟夫问题
05-12
约瑟夫问题是经典的数学游戏，也称为约瑟夫环，由于其富有趣味性和一定的数学难度而被广泛研究和应用。解决约瑟夫问题的方法有多种，其中一种常用方法是使用双向循环链表带头结点。 双向循环链表是一种特殊的链表，它可以遍历整个链表，即尾节点的下一个结点是头结点，头结点的上一个结点是尾节点，这样形成的链表称为双向循环链表。带头结点的双向循环链表在头结点前面加入一个空结点，使得空结点也能对链表中结点进行操作。 在解决约瑟夫问题时，我们首先需要初始化双向循环链表，然后按照一定规则进行出队操作，直到只剩下最后一个结点为止。假设约瑟夫问题中有n个人围成一圈，从第k个人开始报数，报到第m个人就将其出队，然后从下一个人重新开始报数，求最后留下的人的编号。 具体实现时，我们可以根据输入的n和k创建双向循环链表，并从头结点开始依次插入n个结点，然后设置m的值并从头结点开始不断遍历链表直到只剩下一个结点。在遍历过程中，每经过m个结点就将该结点从链表中删除，并将该结点的下一个结点作为新的起点继续报数。最后剩下的那个结点即为答案。 总之，使用双向循环链表带头结点解决约瑟夫问题可以简化求解过程，提高代码效率和可读性，是一种比较常用的数据结构和算法应用方法。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值