双向循环链表讲解及实现

最新推荐文章于 2023-05-13 12:11:24 发布
最新推荐文章于 2023-05-13 12:11:24 发布
阅读量1.2w 收藏 106
点赞数 38
分类专栏： 数据结构 文章标签： c语言 双向循环链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DR5200/article/details/115529330
版权

文章目录

一.带头双向循环链表

带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个链表虽然结构复杂，但是使用代码实现以后会发现能带来很多优势.

二.实现

Lish.h中部分声明

typedef int LTDataType;
typedef struct ListNode
{
	struct ListNode* prev;
	struct ListNode* next;
	LTDataType data;
}ListNode;

prev为结点中的指向前一个结点的指针 , next 为指针中的指向后一个结点的指针 , data为结点中的数据

(1).动态申请一个结点

动态申请一个大小为sizeof(ListNode)的结点

// 动态申请一个结点
ListNode*BuyListNode(LTDataType x)
{
	ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));
	if(newNode == NULL)
	{
		printf("分配内存失败\n");
		exit(-1);
	}
	newNode->prev = newNode->next = NULL;
	newNode->data = x;
	return newNode;
}

(2).创建头结点进行初始化

因为为带头的双向循环链表,因此初始化头结点时，头结点的prev,next指针都指向自已

// 创建头结点进行初始化
ListNode* ListInit()
{
	ListNode* plist = BuyListNode(0); // 头结点中的数据初始化为 0
	plist->prev = plist->next = plist;
	return plist;
}

(3).尾插

通过头结点的prev指针可以找到尾结点tail，tail->next指向待插入的结点，待插入结点的prev指针指向tail，头结点的prev指针指向待插入结点，待插入结点的next指向头结点

// 尾插
void ListPushBack(ListNode* plist,LTDataType x)
{
	assert(plist);
	ListNode* newNode = BuyListNode(x);
	ListNode* tail = plist->prev;
	tail->next = newNode;
	newNode->prev = tail;
	newNode->next = plist;
	plist->prev = newNode;
}

(4).尾删

通过头结点的prev指针找到尾结点tail,通过tail的prev指针找到 tailPrev结点

要使tailPrev成为尾结点,将tailPrev结点和plist头结点连接到一起

// 尾删
void ListPopBack(ListNode* plist)
{
	assert(plist);
	assert(plist->next != plist);
	ListNode* tail = plist->prev;
	ListNode* tailPrev = tail->prev;
	tailPrev->next = plist;
	plsit->prev = tailPrev;
	free(tail);
	tail = NULL;
}

(5).头插

动态申请一个结点newNode,通过plist->next找到当前的第一个结点(first)，newNode结点要插入到plist头结点和first结点之间

// 头插
void ListPushFront(ListNode* plist,LTDataType x)
{
	assert(plist);
	ListNode* newNode = BuyListNode(x);
	ListNode* first = plist->next;
	plist->next = newNode;
	newNode->prev = plist;
	newNode->next = first;
	first->prev = newNode;
}

(6).头删

通过plist->next找到第一个结点(first),first->next找到第二个结点(second),将plist头结点和second结点连接到一起,释放掉第一个结点(first)

// 头删
void ListPopFront(ListNode* plist)
{
	assert(plist);
	assert(plist->next != plist);
	ListNode* first = plist->next;
	ListNode* second = first->next;
	plist->next = second;
	second->prev = plist;
	free(first);
	first = NULL;
}

(7).查找元素

遍历一次链表，终止条件为 cur != plist ,因为 cur = plist 说明已经循环了一遍

// 查找
ListNode* ListFind(ListNode* plist, LTDataType x)
{
	assert(plist);
	ListNode* cur = plist->next;
	while (cur != plist)
	{
		if (cur->data == x)
			return cur;
		cur = cur->next;
	}
	return NULL;
}

(8).在pos位置之前进行插入

动态申请一个结点 ,找到pos位置的前一个结点(posPrev),将pos,posPrev,newNode结点连接到一起

// 在pos位置前插入
void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);
	ListNode* newNode = BuyListNode(x);
	ListNode* posPrev = pos->prev;
	posPrev->next = newNode;
	newNode->prev = posPrev;
	newNode->next = pos;
	pos->prev = newNode;
}

(9).删除pos位置的结点

找到pos的前一个结点(posPrev)和后一个结点(posNext),将posPrev,posNext结点连接到一起,删除掉pos结点

// 删除pos位置的结点
void ListErase(ListNode* pos)
{
	assert(pos);
	ListNode* PosPrev = pos->prev;
	ListNode* PosNext = pos->next;
	PosPrev->next = PosNext;
	PosNext->prev = PosPrev;
	free(pos);
	pos = NULL;
}

(10).打印数据

遍历一次链表，终止条件为 cur != plist ,因为 cur = plist 说明已经循环了一遍

// 打印
void Listprint(ListNode* plist)
{
	assert(plist);
	ListNode* cur = plist->next;
	while (cur != plist)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

三.代码实现

List.h文件

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int LTDataType;
typedef struct ListNode
{
	struct ListNode* prev;
	struct ListNode* next;
	LTDataType data;
}ListNode;
// 初始化创建头结点
ListNode* ListInit();
// 动态申请一个结点
ListNode* BuyListNode(LTDataType x);
// 打印
void Listprint(ListNode* plist);
// 尾插
void ListPushBack(ListNode* plist, LTDataType x);
// 尾删
void ListPopBack(ListNode* plist);
// 头插
void ListPushFront(ListNode* plist, LTDataType x);
// 头删
void ListPopFront(ListNode* plist);
// 查找
ListNode* ListFind(ListNode* plist, LTDataType x);
// 在pos前插入
void ListInsert(ListNode* pos, LTDataType x);
// 删除pos位置的结点
void ListErase(ListNode* pos);

Lish.c文件

#include"List.h"
// 初始化创建头结点
ListNode* ListInit()
{
	ListNode* phead = BuyListNode(0);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}
// 动态申请一个结点
ListNode* BuyListNode(LTDataType x)
{
	ListNode* NewNode = (ListNode*)malloc(sizeof(ListNode));
	if (NewNode == NULL)
	{
		printf("分配内存失败\n");
		exit(-1);
	}
	NewNode->prev = NewNode->next = NULL;
	NewNode->data = x;
	return NewNode;
}
// 打印
void Listprint(ListNode* plist)
{
	assert(plist);
	ListNode* cur = plist->next;
	while (cur != plist)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}
// 尾插
void ListPushBack(ListNode* plist, LTDataType x)
{
	assert(plist);
	ListNode* NewNode = BuyListNode(x);
	ListNode* tail = plist->prev;
	tail->next = NewNode;
	NewNode->prev = tail;
	plist->prev = NewNode;
	NewNode->next = plist;
}
// 尾删
void ListPopBack(ListNode* plist)
{
	assert(plist);
	assert(plist->next != plist);
	ListNode* tail = plist->prev;
	ListNode* tail_prev = tail->prev;
	tail_prev->next = plist;
	plist->prev = tail_prev;
	free(tail);
	tail = NULL;
}
// 头插
void ListPushFront(ListNode* plist, LTDataType x)
{
	assert(plist);
	ListNode* NewNode = BuyListNode(x);
	ListNode* first = plist->next;
	plist->next = NewNode;
	NewNode->prev = plist;
	NewNode->next = first;
	first->prev = NewNode;
}
// 头删
void ListPopFront(ListNode* plist)
{
	assert(plist);
	assert(plist->next != plist);
	ListNode* first = plist->next;
	ListNode* second = first->next;
	plist->next = second;
	second->prev = plist;
	free(first);
	first = NULL;
}
// 查找
ListNode* ListFind(ListNode* plist, LTDataType x)
{
	assert(plist);
	ListNode* cur = plist->next;
	while (cur != plist)
	{
		if (cur->data == x)
			return cur;
		cur = cur->next;
	}
	return NULL;
}
// 在pos位置前插入
void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);
	ListNode* NewNode = BuyListNode(x);
	ListNode* PosPrev = pos->prev;
	PosPrev->next = NewNode;
	NewNode->prev = PosPrev;
	NewNode->next = pos;
	pos->prev = NewNode;
}
// 删除pos位置的结点
void ListErase(ListNode* pos)
{
	assert(pos);
	ListNode* PosPrev = pos->prev;
	ListNode* PosNext = pos->next;
	PosPrev->next = PosNext;
	PosNext->prev = PosPrev;
	free(pos);
	pos = NULL;
}

TestLish.c文件

#include"List.h"
void TestList01()
{
	ListNode* plist = ListInit();
	ListPushBack(plist, 1);
	ListPushBack(plist, 2);
	ListPushBack(plist, 3);
	ListPushBack(plist, 4);
	Listprint(plist);

	ListPopBack(plist);
	ListPopBack(plist);
	ListPopBack(plist);
	ListPopBack(plist);
	// ListPopBack(plist);
	Listprint(plist);

	ListPushFront(plist, 1);
	ListPushFront(plist, 2);
	ListPushFront(plist, 3);
	ListPushFront(plist, 4);
	Listprint(plist);

	ListPopFront(plist);
	ListPopFront(plist);
	ListPopFront(plist);
	ListPopFront(plist);
	// ListPopFront(plist);
	Listprint(plist);
}
void TestList02()
{
	ListNode* plist = ListInit();
	ListPushBack(plist, 1);
	ListPushBack(plist, 2);
	ListPushBack(plist, 3);
	ListPushBack(plist, 4);

	ListNode* pos = ListFind(plist, 3);
	ListInsert(pos, 30);
	Listprint(plist);
	ListErase(pos);
	Listprint(plist);

}
int main()
{
	TestList01();
	TestList02();
}
DR5200
关注
  • 38
    点赞
  • 踩
  • 106
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
双向循环链表(线性表 栈 队列)
weixin_55742319的博客
01-16 1124
双向循环链表
数据结构篇三：双向循环链表
忘忧.
05-01 1634
;前面我们学习了单链表的实现，我们发现它在进行从后往前查找的时候有很大的不便，为了解决这个问题，双向链表油然而生。它可以很好的解决单链表无法从后往前查找的困难。
数据结构初级:链表-双向带头循环链表(C语言)
m0_70088853的博客
05-13 563
链表-双向带头循环链表(C语言)
数据结构之链表详解(2)——双向链表
weixin_69283129的博客
08-29 9035
C语言版万字详解：数据结构之链表详解(2)——双向链表的结构和功能实现
【数据结构】--双向链表
m0_74044018的博客
04-15 933
1、主要讲述了双向循环链表的实现细节 2、再述了顺序表和链表的优缺点
实现循环双链表各种基本运算的算法
xiezhi123456的博客
01-12 2446
#include &lt;stdio.h&gt; #include &lt;malloc.h&gt; #include &lt;stdbool.h&gt; typedef int ElemType; typedef struct DNode {     ElemType data;//数据域     struct DNode *prior;//指向前驱结点     struct DNode *n...
Python双向循环链表实现方法分析
09-20
【Python双向循环链表实现方法分析】 Python中的双向循环链表是一种特殊的数据结构，它具有两个指针，分别指向当前节点的前一个节点（prev...通过上述详细讲解，相信读者已经对Python中的双向循环链表有了深入的理解。
双向循环链表
04-15
对于数据结构的学习，严蔚敏版的《数据结构》是一本经典教材，书中详细讲解了各种数据结构的原理和实现，包括双向循环链表。`circle list.dsp`、`circle list.dsw`、`circle list.ncb`、`circle list.opt`、`circle ...
实现循环链表及双向链表3
09-10
至于提供的"实现循环链表及双向链表3.pdf"文件，它很可能是对这两种链表实现的详细步骤、代码示例或相关问题的解答。通过阅读这份文档，你可以深入理解这两种数据结构的内部工作机制，并学习如何在实际编程中应用...
详解Linux内核之双向循环链表
10-30
本文详解了内核中面向对象的list结构的原理，以及如何以list为内嵌对象来构造自己的链表结构，如何从内嵌list对象获得自定义的对象指针；探讨了各种宏或者函数的详细使用方法及怎样以通用list结构来操作自定义对象。
双向链表的14个基本操作函数C语言
最新发布
03-02
本篇文章将深入讲解双向链表及其14个基本操作函数的C语言实现。 双向链表与单链表不同，每个节点不仅包含数据，还包含两个指针，一个指向其前一个节点（prev），另一个指向其后一个节点（next）。这种设计使得在...
【数据结构-C】双向循环链表基本操作及图解分析
qq_52763385的博客
02-04 4361
目录 ????双向链表介绍 ????双向链表的基本操作及图解分析 ????1.双向链表创建新的结点 ????2.双向链表初始化 ????3.双向链表的尾插 ????4.双向链表的头插 ????5.双向链表的头删 ????6.双向链表的尾删 ????7.查找某个结点并返回该节点地址 ????8.在某结点前插入一个新的结点 ????9.删除某个结点 ????10.销毁双向链表 总结 ????双向链表介绍 双向链表的结点：指针域1+数据域+指针域2 ????指针域1：指向该结点
【无标题】双向链表的反转（c++）
mahu666的博客
02-23 1004
#include<iostream> #include<cstdlib> using namespace std; typedef struct Node { int date; struct Node* pre; struct Node* next; struct Node* last; }node; node* creat(int n) { node* head = (node*)malloc(sizeof(node)); cin...
双向循环链表的实现详解
旧时佑忆的空间
05-09 2403
双向循环链表直接体现为 双向和循环，一般的单链表只有节点数据data和next指向地址(应该也是引用的意思)，而在此需要增加前面部分的pre指向地址，同时还需要循环 循环则在定义节点时可以解决，如下所示 即假想只有一个节点的时候，不论是上一个节点的指向还是下一个节点的指向都是自己。 双向可以假想三个节点，实际上就是3个节点之间完成pre和next的指向替换，如下图所示 ...
C语言中双向链表和双向循环链表详解
学到的就要教人 赚到的就要给人
05-21 6339
双向链表和双向循环链表和单向链表相比，多了一个前驱结点。如果他为空，那么next和prior都指向自己。而对于双循环链表，只需要最后一个元素的next指向head-&gt;next，head-&gt;next的prior指向最后一个节点即可。插入操作新节点s插入链表，s-&gt;next给p结点，s-&gt;prior给p-&gt;prior，然后，p-&gt;prior-&gt;next指向s，...
C语言中单向循环链表与双向循环链表详解
qq_41835250的博客
07-26 5181
每日一句 It’s gonna be ok. 一切都会好的。 内容概要 单向循环链表 首先来看看图示： 图展示的是一个单向循环链表，他跟以上的单向链表对比只是多了一个指向头结点的 指针，因此，他们的算法几乎是一样的。 第一，设计节点。 单向循环链表的节点跟单向链表完全一致。 第二，初始化空链表。 跟单向链表类似，我们既可以初始化一个带有头结点的空循环链表，也可以不要头结点： 这边把两个步骤放在一起了 linklist init_list(void) // 带有头结点的单循环链表 { linklis
Java双向链表时间复杂度_链表是什么？有多少种链表？时间复杂度是？
weixin_33093437的博客
02-26 2756
链表(Linked list)是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而顺序表相应的时间复杂度分别是O(logn)和O(1)。使用链表结构可以克服数组链表需要...
双向循环链表的表示和实现（C语言）
mu66mu的博客
11-09 461
#include&lt;stdio.h&gt; #include&lt;malloc.h&gt; //双向循环链表的表示和实现，带头结点 typedef int ElemType; typedef struct node{ struct node *next; struct node *prior; ElemType data; }dlink; //创建循环链表 dlink *creat...
双向循环链表的简单应用
qq_44194231的博客
07-11 421
使用双向循环链表储存A～Z，并根据输入的值进行打印顺序的调整。例如输入3，打印D～Z～C，输入-3打印X～A～W #include <stdio.h> #include <stdlib.h> typedef struct node { char data; struct node * next; struct node * piror; }*linklist; linklist Create_Circle(void) { linklist Headnode; linkl
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; } ``` 在这个例子中，我们使用了一个结构体来存储每个节点的数据和指向前一个和后一个节点的指针。我们还定义了一些操作函数，如创建新节点、在链表头部和尾部插入新节点、删除节点和显示链表等。在主函数中，我们创建了一个双向循环链表并进行了一些操作，最后输出链表的内容。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值