双向循环链表的讲解及实现（图解+代码/C语言）

最新推荐文章于 2024-04-19 19:29:36 发布
最新推荐文章于 2024-04-19 19:29:36 发布
阅读量3.7k 收藏 55
点赞数 8
分类专栏： 数据结构和算法 文章标签： 链表 c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62306969/article/details/128527335
版权

本次为大家分享的是双向循环链表的增删查改等系列操作。

目录

一、图解双向循环链表结构

二、分步实现

（1）创建并初始化

（2）链表元素打印

（3）头插和尾插

（4）判断链表为空

（5）头删和尾删

（6）查找特定元素

（7）删除特定元素

（8）特定元素前插入

（9）链表销毁

三、优化及整体代码

一、图解双向循环链表结构

对于单向链表来说，每一个结点由数据块和一个指针域构成，只需要指针域记录下一个结点的位置即可。而双向链表则需要两个指针，对应“双向”，其结点具体结构和结点之间的连接方式如下。

二、分步实现

下面直接逐个上代码，给大家分块演示如何实现一个双向带头循环的链表。

（1）创建并初始化

首先我们需要声明结构体的结构，对于链表的初始化，我们只需要动态申请一个结点作为头结点，让这个哨兵结点头尾相连即可。

​​​​​​​

// 双链表 // Double Link List  // DLL

typedef int DLLData
typedef struct DLLNode
{
	DLLData data;
	struct ListNode* next;
	struct ListNode* prev;
}ListNode;


// 链表哨兵结点的创建
ListNode* ListCreate()
{
	ListNode* guard = (ListNode*)malloc(sizeof(ListNode));
	guard->next = guard->prev = guard;
	return guard;
}

（2）链表元素打印

链表的打印相对简单，我们只需要打印出其中的数据即可，为了表示是双向带头循环链表，不同结点之间的数据我们用“<=>”连接表示双向，用phead放在两端表示带头循环。

// 双向链表打印
void ListPrint(ListNode* phead)
{
	assert(phead);
	ListNode* tmp = phead->next;
	printf("phead<=>");
	while (tmp != phead)
	{
		printf("%d<=>", tmp->data);
		tmp = tmp->next;
	}
	printf("phead\n");
}

（3）头插和尾插

相比与之前学的单向链表，双向循环链表的头插和尾插则简单了许多，对照下面的图。我们传入函数的是哨兵结点phead, phead->next便是头结点，即在phead之后插入结点就是头插；同理，由于链表是循环的，因此在phead之前插入就是尾插。

// 双向链表头插
void ListPushFront(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListNode* new_node = (ListNode*)malloc(sizeof(ListNode));
	new_node->data = x;
	new_node->next = phead->next;
	phead->next->prev = new_node;
	phead->next = new_node;
	new_node->prev = phead;
}


// 双向链表尾插
void ListPushBack(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListNode* new_node = (ListNode*)malloc(sizeof(ListNode));
	new_node->data = x;
	phead->prev->next = new_node;
	new_node->prev = phead->prev;
	phead->prev = new_node;
	new_node->next = phead;
}

（4）判断链表为空

完成了头插尾插，接下来就是头删和尾删了。但是在删除之前我们应该先检查一下我们的链表之中是否还存在结点，当没有结点的时候我们就无法继续删除了。所以我们需要检查一下链表是否为空，为空就是除哨兵节点外没有有效节点了，只有这哨兵结点循环，因此具体实现如下。

// 检查链表为空
bool CheckVoid(ListNode* rhs)
{
	assert(rhs);
	return rhs->next == rhs;
}

（5）头删和尾删

类比之前的头插和尾插，我们很轻松就可以找到头结点和尾结点，那么头删和尾删也就解决了。

// 双向链表头删
void ListPopFront(ListNode* phead)
{
	assert(phead);
	assert(!CheckVoid(phead));
	ListNode* new_front = phead->next->next;
	free(phead->next);
	phead->next = new_front;
	new_front->prev = phead;
}

// 双向链表尾删
void ListPopBack(ListNode* phead)
{
	assert(phead);
	assert(!CheckVoid(phead));
	ListNode* new_tail = phead->prev->prev;
	free(phead->prev);
	phead->prev = new_tail;
	new_tail->next = phead;
}

（6）查找特定元素

和单链表一样我们只需要遍历整个链表即可，但是需要注意的是我们的链表有哨兵结点，而且是循环链表，因此我们需要从phead->next开始遍历，同时当我们遍历遇到phead时，说明已经找完了整个链表都没有对应元素，要在此设置退出值。

// 双向链表查找
ListNode* ListFind(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListNode* tmp = phead->next;
	while (tmp != phead)
	{
		if (tmp->data == x)
			return tmp;
		tmp = tmp->next;
	}
	return NULL;
}

（7）删除特定元素

我们删除元素是基于查找函数完成的，首先通过查找函数找到对应结点，向删除函数传入该结点，由于我们是双向链表，因此只需要将找到的结点pos的前后结点连接并释放pos结点即可。

// 双向链表删除pos位置的节点
void ListErase(ListNode* pos)
{
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;
	free(pos);
}

（8）特定元素前插入

在此选择的是在特定元素pos之前插入，想改成之后插入也十分简单，同样是和查找函数共同使用，找到之后传入pos结点和数据值即可。

// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x)
{
	ListNode* front = pos->prev;
	ListNode* new_node = BuyNewnode(x);
	front->next = new_node;
	new_node->next = pos;
	pos->prev = new_node;
	new_node->prev = front;
}

（9）链表销毁

链表销毁只需要遍历链表逐个释放即可，可以先释放其他节点然后跳出循环释放哨兵结点，也可以将phead->next设置为NULL，成为一个伪单链表，然后循环释放所有结点。此处使用后者实现。

// 双向链表销毁
void ListDestroy(ListNode* phead)
{
	assert(phead);
	ListNode* tmp = phead->next, *node = phead->next;
	phead->next = NULL;
	while (tmp)
	{
		node = tmp->next;
		free(tmp);
		tmp = node;
	}
}

三、优化及整体代码

当我们完成了插入函数的在之后，对于头插和尾插，直接调用函数即可，头插是在front前插入，尾插是在phead前插入。（函数声明和结构体声明等放在头文件中即可）

#include"Double ListNode.h"

// 创建返回链表的头结点.
ListNode* ListCreate()
{
	ListNode* guard = (ListNode*)malloc(sizeof(ListNode));
	guard->next = guard->prev = guard;
	return guard;
}

// 创建一个新的结点
ListNode* BuyNewnode(LTDataType x)
{
	ListNode* new_node = (ListNode*)malloc(sizeof(ListNode));
	new_node->data = x;
	return new_node;
}

// 双向链表销毁
void ListDestroy(ListNode* phead)
{
	assert(phead);
	ListNode* tmp = phead->next, *node = phead->next;
	phead->next = NULL;
	while (tmp)
	{
		node = tmp->next;
		free(tmp);
		tmp = node;
	}
}

// 双向链表打印
void ListPrint(ListNode* phead)
{
	assert(phead);
	ListNode* tmp = phead->next;
	printf("phead<=>");
	while (tmp != phead)
	{
		printf("%d<=>", tmp->data);
		tmp = tmp->next;
	}
	printf("phead\n");
}

// 双向链表尾插
void ListPushBack(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListInsert(phead, x);
}

// 双向链表尾删
void ListPopBack(ListNode* phead)
{
	assert(phead);
	assert(!CheckVoid(phead));
	ListErase(phead->prev);
}

// 双向链表头插
void ListPushFront(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListInsert(phead->next, x);
}

// 双向链表头删
void ListPopFront(ListNode* phead)
{
	assert(phead);
	assert(!CheckVoid(phead));
	ListErase(phead->next);
}

// 双向链表查找
ListNode* ListFind(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListNode* tmp = phead->next;
	while (tmp != phead)
	{
		if (tmp->data == x)
			return tmp;
		tmp = tmp->next;
	}
	return NULL;
}

// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x)
{
	ListNode* front = pos->prev;
	ListNode* new_node = BuyNewnode(x);
	front->next = new_node;
	new_node->next = pos;
	pos->prev = new_node;
	new_node->prev = front;
}

// 双向链表删除pos位置的节点
void ListErase(ListNode* pos)
{
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;
	free(pos);
}

// 检查链表为空
bool CheckVoid(ListNode* rhs)
{
	assert(rhs);
	return rhs->next == rhs;
}

是小黄呀~
关注
  • 8
    点赞
  • 踩
  • 55
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构8: 双向链表(双向循环链表)的建立及C语言实现
weixin_30951389的博客
05-12 314
之前接触到的链表都只有一个指针，指向直接后继，整个链表只能单方向从表头访问到表尾，这种结构的链表统称为“单向链表”或“单链表”。 如果算法中需要频繁地找某结点的前趋结点，单链表的解决方式是遍历整个链表，增加算法的时间复杂度，影响整体效率。为了快速便捷地解决这类问题，在单向链表的基础上，给各个结点额外配备一个指针变量，用于指向每个结点的直接前趋元素。这样的链表被称为“双向链表”或者“双链表”。 ...
双向循环链表操作的实现
m0_53676388的博客
01-24 2034
对双向循环列表进行如下操作： 1.建立一个空表。 2.在第i个位置插入新的元素x。 3.删除第i个位置上的元素。 4.取第i个位置上的元素。 5.返回元素x第一次出现在双向循环链表中的位置号。 6.求双向循环链表的长度，即元素个数。 7.输出双向循环链表中所有的元素值。 8.实现双向循环链表的就地逆置。
C语言—双向链表模拟实现（全代码！！）
最新发布
unlockjy的博客
04-19 534
在之前我们了解过了单链表的相关知识，我们知道单链表是不带头单向不循环链表，本章给大家介绍的就是双链表，双链表就是带头双向循环链表,当我们学习过单链表的知识，来实现双链表就比较容易了，接下来就让我们一起来了解一下吧！在这里我们需要定义：存放的数据 指向下一个节点的指针 指向前一个节点的指针接下来就让我们来实现一下吧！本章主要介绍了双向链表的增删查改功能的实现，希望对大家学习链表有帮助，在前几章也有会单链表的实现已经经典的约瑟夫环问题，有兴趣的友友可以支持一下，大佬互三！！！
双向循环链表(图文讲解)
deroy
02-25 2362
文章目录双向循环链表结构体初始化函数添加数据头插删除数据显示函数示例程序一(简易版本)：运行结果：示例程序二 双向循环链表 结构体 typedef struct node { int data; struct node* pre; //指向前驱 struct node* next; //指向后继 }NODE; 双链表是链表的一种，由节点组成，每个数据结点中都有两个指针，分别指向直接后继和直接前驱。 初始化函数 NODE * Init() { NODE* head = (NODE*)mall
循环双向链表
qq_49567286的博客
06-01 863
初识循环双向链表
数据结构（五）——双链表与循环链表
流逝
08-03 1394
数据结构（五) —— 双链表和循环链表
【数据结构】双向链表的遍历、添加、修改和删除
dengmsjava的博客
05-12 2486
双向链表的遍历、添加、修改和删除 （1）单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。 （2）单向链表不能自我删除，需要靠辅助节点，而双向链表，则可以自我删除。
【数据结构-C】双向循环链表基本操作及图解分析
qq_52763385的博客
02-04 4383
目录 ????双向链表介绍 ????双向链表的基本操作及图解分析 ????1.双向链表创建新的结点 ????2.双向链表初始化 ????3.双向链表的尾插 ????4.双向链表的头插 ????5.双向链表的头删 ????6.双向链表的尾删 ????7.查找某个结点并返回该节点地址 ????8.在某结点前插入一个新的结点 ????9.删除某个结点 ????10.销毁双向链表 总结 ????双向链表介绍 双向链表的结点：指针域1+数据域+指针域2 ????指针域1：指向该结点
【数据结构】--双向链表
m0_74044018的博客
04-15 941
1、主要讲述了双向循环链表的实现细节 2、再述了顺序表和链表的优缺点
双向循环链表-C语言实现.doc
09-21
这篇文档主要介绍的是如何在C语言中实现双向循环链表的操作。双向循环链表是一种特殊的数据结构，每个节点不仅包含数据，还包含指向左邻节点和右邻节点的指针，形成一个首尾相连的环状结构。 首先，定义了一个名为`...
链表-使用C语言实现非循环双向链表-带头结点+尾结点.zip
03-13
本篇将详细介绍如何使用C语言来实现一个非循环双向链表，包括带头结点和尾结点的链表。 首先，让我们定义链表节点的数据结构。在非循环双向链表中，每个节点包含两个指针，分别指向它的前一个节点和后一个节点。...
C语言中双向链表和双向循环链表详解
08-30
本文主要介绍了C语言中双向链表和双向循环链表的实现与操作，包括双向链表和双向循环链表的定义、初始化、插入操作、删除操作等。 一、双向链表和双向循环链表的定义 在C语言中，双向链表是一种数据结构，具有前驱...
C语言数据结构之双向循环链表的实例
08-30
本实例展示了C语言中双向循环链表的实现，包括链表的定义、链表的基本操作、链表的遍历和搜索等。通过本实例，我们可以了解C语言中链表的实现和应用。 KNOWLEDGE POINTS: 1.C语言中链表的定义和实现 2.双向循环...
java双向循环链表的实现代码
09-05
}/*** 获取双向循环链表的第一个节点* @return 链表头节点*/public BothwayLoopLinked getFirst(){if (linkedId == null) return null;BothwayLoopLinked first = this;while (first.prev != first) first = first....
【数据结构】双向链表实现
m0_73367097的博客
03-26 1634
双向链表的定义与实现
循环双链表与双循环链表差别_实施循环双链表| C程序
cumtb2009的博客
07-05 730
循环双链表与双循环链表差别Solution: 解： Input: The data of each node 输入：每个节点的数据 Output: The circular doubly linked list 输出：圆形双向链表 Data structure used: A circular doubly linked list where each node contains a ...
创建循环双链表
tkp2014的专栏
07-03 671
#include #include typedef int ItemValue; typedef struct DoubleLinkedList { ItemValue value; struct DoubleLinkedList *pre; struct DoubleLinkedList *next; } DoubleList, *pDoubleList; DoubleList
数据结构：双向循环链表的实现（附有详细图解）
qq_44851228的博客
07-25 9577
双向循环链表的实现 （1）动态申请节点 在这里插入代码片
头疼的算法与数据结构——双向循环链表
sum_TW的博客
03-12 6125
一：双向循环链表的简介 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 双链表的结构定义如下： struct node{ int data;//数据域 struct node* next;//后继 struct n
c语言实现双向循环链表
03-27
双向循环链表是一种常用的数据结构之一，可以在链表中进行快速的插入、删除和查找操作。以下是一种简单的C语言实现双向循环链表的代码： ``` #include <stdio.h> #include <stdlib.h> struct node { int data; struct node *prev; struct node *next; }; struct node *createNode(int data) { struct node *newNode = (struct node*)malloc(sizeof(struct node)); newNode->data = data; newNode->prev = NULL; newNode->next = NULL; return newNode; } void insertAtBegin(struct node **head, int data) { struct node *newNode = createNode(data); if (*head == NULL) { *head = newNode; (*head)->next = *head; (*head)->prev = *head; } else { struct node *last = (*head)->prev; newNode->next = *head; newNode->prev = last; last->next = newNode; (*head)->prev = newNode; *head = newNode; } } void insertAtEnd(struct node **head, int data) { struct node *newNode = createNode(data); if (*head == NULL) { *head = newNode; (*head)->next = *head; (*head)->prev = *head; } else { struct node *last = (*head)->prev; newNode->prev = last; newNode->next = *head; last->next = newNode; (*head)->prev = newNode; } } void deleteNode(struct node **head, int data) { if (*head == NULL) { printf("List is empty.\n"); return; } struct node *cur = *head; struct node *prev = NULL; while (cur->data != data && cur->next != *head) { prev = cur; cur = cur->next; } if (cur->data != data) { printf("%d not found in list.\n", data); return; } if (cur == *head && cur->next == *head) { *head = NULL; free(cur); return; } if (cur == *head) { *head = cur->next; } struct node *next = cur->next; prev->next = next; next->prev = prev; free(cur); } void displayList(struct node *head) { if (head == NULL) { printf("List is empty.\n"); return; } printf("List: "); struct node *cur = head; do { printf("%d ", cur->data); cur = cur->next; } while (cur != head); printf("\n"); } int main() { struct node *head = NULL; insertAtBegin(&head, 10); insertAtBegin(&head, 20); insertAtEnd(&head, 30); insertAtEnd(&head, 40); displayList(head); deleteNode(&head, 20); deleteNode(&head, 50); displayList(head); return 0; } ``` 在这个例子中，我们使用了一个结构体来存储每个节点的数据和指向前一个和后一个节点的指针。我们还定义了一些操作函数，如创建新节点、在链表头部和尾部插入新节点、删除节点和显示链表等。在主函数中，我们创建了一个双向循环链表并进行了一些操作，最后输出链表的内容。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值