数据结构——循环双链表

最新推荐文章于 2025-02-17 19:29:54 发布
原创 最新推荐文章于 2025-02-17 19:29:54 发布 · 476 阅读 · 7 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构

文章目录

一、循环双链表

基于单链表实现循环双链表；相比于单链表，循环双链表的数据结点有两个指针，分别指向该节点的上一个数据节点（前驱）和下一个数据结点（后继），且头结点或首元结点的前驱指向链表的最后一个数据结点，而最后一个数据结点的后继指向头结点或首元结点。

二、基本操作

1.结点类型描述

typedef struct DNode{
	ElemType data;
	struct DNode* next, * prior;
}DNode,*LinkList;

指针next指向后继结点，prior指向前驱结点

2.初始化

void Initial(LinkList& L) {	//初始化
	L = (DNode*)malloc(sizeof(DNode));
	if (L)
	{
		L->next = L;
		L->prior = L;
		L->data = 0;
		printf("Initialization succeeded!\n");
	}
	else
		printf("Error:Insufficient memory!\n");
}

初始化时头结点的前驱和后继都指向自身。
注：这里用头结点的数据域存储链表长度信息，因此初始化设为0，若无需要可忽略

3.按序查找

DNode* GetElem(LinkList L)	//按序号查找
{
	int i = 0;
	LinkList p = L;
	if (L->next == L->prior)
	{
		printf("Error:Tabular void\n");
		return NULL;
	}
	printf("Please enter the number:");
	scanf_s("%d", &i);
	if ((i <= 0) || (i > L->data))
	{
		printf("Error:lllegal serial number\n");
		return NULL;
	}
	while (i--)
		p = p->next;
	if (p)
		return p;
	printf("Error:error in linked list\n");
	return NULL;
}

若头结点的前驱与后继相等，则说明表空。

4.按值查找

DNode* LocateElem(LinkList L) //按值查找
{
	int value = 0;
	if (L->next == L->prior)
	{
		printf("Error:Tabular void\n");
		return NULL;
	}
	LinkList p = L->next;
	printf("Please enter the value:");
	scanf_s("%d", &value);
	while (p != L)
	{
		if (value == p->data)
		{
			printf("Success!\n");
			return p;
		}
		p = p->next;
	}
	printf("Defeat:target value not found\n");
	return NULL;
}

因为该结构是循环结构，当指针p再次指向头结点时表示链表循环一周。

4.插入

bool Input(LinkList& L)	//插入
{
	int i = 0;
	LinkList n = L;
	LinkList p = (DNode*)malloc(sizeof(DNode));
	if (!p) {
		printf("Error:Insufficient memory!\n");
		return false;
	}
	printf("Please enter the number:");
	scanf_s("%d", &i);
	if ((i <= 0) || (i > L->data+1))
	{
		printf("Error:lllegal serial number\n");
		return false;
	}
	while (i--)
		n = n->next;
	printf("Please enter the value:");
	scanf_s("%d", &(p->data));
	p->next = n;
	p->prior = n->prior;
	n->prior->next = p;
	n->prior = p;
	L->data++;
	return true;
}

示意图：
初始
插入
2、3必须在4的前面

5.删除

bool Delete(LinkList& L)	//删除
{
	int i = 0;
	LinkList n = L;
	printf("Please enter the number:");
	scanf_s("%d", &i);
	if (L->next == L->prior) {
		printf("Error:Tabular void\n");
		return false;
	}
	if ((i <= 0 ) || (i > L->data)) {
		printf("Error:lllegal serial number\n");
		return false;
	}
	while (i--)
		n = n->next;
	n->prior->next = n->next;
	n->next->prior = n->prior;
	free(n);
	L->data--;
	return true;
}

示意图：
初始
删除

三、代码实现

#include "stdio.h"
#include"stdlib.h"	//循环双链表

typedef int ElemType;
typedef struct DNode{
	ElemType data;
	struct DNode* next, * prior;
}DNode,*LinkList;

void Initial(LinkList& L) {	//初始化
	L = (DNode*)malloc(sizeof(DNode));
	if (L)
	{
		L->next = L;
		L->prior = L;
		L->data = 0;
		printf("Initialization succeeded!\n");
	}
	else
		printf("Error:Insufficient memory!\n");
}

DNode* GetElem(LinkList L)	//按序查找
{
	int i = 0;
	LinkList p = L;
	if (L->next == L->prior)
	{
		printf("Error:Tabular void\n");
		return NULL;
	}
	printf("Please enter the number:");
	scanf_s("%d", &i);
	if ((i <= 0) || (i > L->data))
	{
		printf("Error:lllegal serial number\n");
		return NULL;
	}
	while (i--)
		p = p->next;
	if (p)
		return p;
	printf("Error:error in linked list\n");
	return NULL;
}

DNode* LocateElem(LinkList L) //按值查找
{
	int value = 0;
	if (L->next == L->prior)
	{
		printf("Error:Tabular void\n");
		return NULL;
	}
	LinkList p = L->next;
	printf("Please enter the value:");
	scanf_s("%d", &value);
	while (p != L)
	{
		if (value == p->data)
		{
			printf("Success!\n");
			return p;
		}
		p = p->next;
	}
	printf("Defeat:target value not found\n");
	return NULL;
}

bool Input(LinkList& L)	//插入
{
	int i = 0;
	LinkList n = L;
	LinkList p = (DNode*)malloc(sizeof(DNode));
	if (!p) {
		printf("Error:Insufficient memory!\n");
		return false;
	}
	printf("Please enter the number:");
	scanf_s("%d", &i);
	if ((i <= 0) || (i > L->data+1))
	{
		printf("Error:lllegal serial number\n");
		return false;
	}
	while (i--)
		n = n->next;
	printf("Please enter the value:");
	scanf_s("%d", &(p->data));
	p->next = n;
	p->prior = n->prior;
	n->prior->next = p;
	n->prior = p;
	L->data++;
	return true;
}

bool Delete(LinkList& L)	//删除
{
	int i = 0;
	LinkList n = L;
	printf("Please enter the number:");
	scanf_s("%d", &i);
	if (L->next == L->prior) {
		printf("Error:Tabular void\n");
		return false;
	}
	if ((i <= 0 ) || (i > L->data)) {
		printf("Error:lllegal serial number\n");
		return false;
	}
	while (i--)
		n = n->next;
	n->prior->next = n->next;
	n->next->prior = n->prior;
	free(n);
	L->data--;
	return true;
}

bool Output(LinkList& L)	//输出
{
	if (L->next == L->prior)
	{
		printf("Error:Tabular void\n");
		return false;
	}
	int i = 1;
	LinkList p = L->next;
	printf("[Table length]%d\n", L->data);
	while (p != L)
	{
		printf("[%d]%d\n", i++, p->data);
		p = p->next;
	}
	return true;
}

bool Air(LinkList& L)	//清空
{
	if (L->next == L->prior)
	{
		printf("Error:Tabular void\n");
		return false;
	}
	LinkList p = L->next, i = NULL;
	while (p != L)
	{
		i = p;
		p = p->next;
		free(i);
	}
	L->data = 0;
	L->next = L;
	L->prior = L;
	return true;
}

bool Input_Continuously(LinkList& L) {	//连续写入
	int i = 0;
	LinkList n = L,p = NULL;
	printf("Please enter the number of inserts:");
	scanf_s("%d", &i);
	if (i <= 0) {
		printf("Error:lllegal serial number\n");
		return false;
	}
	while (i--)
	{
		p = (DNode*)malloc(sizeof(DNode));
		if (!p) {
			printf("Error:Insufficient memory!\n");
			return false;
		}
		printf("Please enter the value:");
		scanf_s("%d", &(p->data));
		p->next = n;
		p->prior = n->prior;
		n->prior->next = p;
		n->prior = p;
		L->data++;
	}
	return true;
}

int main() {
	LinkList L = NULL;
	bool SWITCH = true;
	DNode* GetElem_value = NULL, * LocateElem_value = NULL;
	bool (*f)(LinkList & L) = NULL;
	int CHOOSE = 0;
	Initial(L);
	do
	{
		printf("Operate:\n1.连续插入\t2.插入\t3.删除\t4.输出\t5.清空\t6.按序查找\t7.按值查找\t8.退出\n");
		scanf_s("%d", &CHOOSE);
		switch (CHOOSE)
		{
		case 1:
			f = Input_Continuously;
			break;
		case 2:
			f = Input;
			break;
		case 3:
			f = Delete;
			break;
		case 4:
			f = Output;
			break;
		case 5:
			f = Air;
			break;
		case 6:
			f = NULL;
			if(GetElem_value = GetElem(L))
				printf("The value is %d\n", GetElem_value->data);
			break;
		case 7:
			f = NULL;
			if(LocateElem_value = LocateElem(L))
				printf("The value is %d\n", LocateElem_value->data);
			break;
		case 8:
			SWITCH = false;
			break;
		default:
			printf("Operate not found\n");
			break;
		}
		if (f)
		{
			if (f(L))
				printf("Successful execution!\n");
			else
				printf("Execution failed!\n");
		}
	} while (SWITCH);
	return 0;
}
数据结构——循环双链表的转置
qq_42242380的博客
07-10 829
我们实现的是一个带头结点的循环双链表，具体方法是设置两个工作指针p、q。p从第一个节点开始从头到尾进行遍历，而q从最后一个结点开始从未到头依次遍历。两个指针同时移动，每移动一次就进行一次数据元素的交换。 核心代码如下： void d() //循环双链表的倒置 { List *p = head->next, *q = head->pr...
数据结构——双向循环链表
qq_67611811的博客
08-28 2422
双向循环链表，在原单链表的基础上多了一个指向上一个结点的前驱指针prev，这样前后结点就不仅仅有了单向的从头至尾的指向顺序，也可以从后指向前，从末结点指向头结点。双向带头循环链表结构} DGR;加入前驱指针后，不管是对于链表数据的尾插尾删，或是头插头删，其时间复杂度都为O(1)，大大简化了链表遍历过程，而可以直接在链表首尾增减数据，因为一个链表的末节点可由头结点的前驱指针直接访问而不需要遍历至尾。为了简化文本描述，本章双向循环带头链表均简称为双向链表。...
循环双链表
09-12
基于C高级的双向循环链表，可以选择头插还是尾插两种插入方式，及增加节点，删除节点
数据结构链表之循环双链表
u010814426的专栏
07-27 442
对于有头结点的双链表L，当L为空时，L->pre == L && L->next == L; 对循环双链表的插入操作，需要考虑到链表为空的特殊情况； 对循环上链表的删除操作，需要考虑到被删除元素为链表中最后一个元素的特殊情况。 具体代码如下： #include #include struct List{ int val; List* pre; List* next; }; Lis
数据结构_循环双链表
FRANK48691的博客
06-13 151
循环双链表基本操作的代码实现
数据结构-循环双链表
lzlyxxn的博客
05-08 1563
循环链表，就是把链表给首尾相连，即尾结点的next指向L头结点，而循环双链表不仅尾结点指向头结点，且头结点的prior指向尾结点，判断为空时，只要看尾结点下一个是否指向头结点，循环链表的操作和链表的操作差别并不大。 循环双链表的创建、插入、删除 #include<iostream> #include<cstdlib> using namespace std; typedef int ElemType; typedef struct CNode{ ElemType data;
数据结构——单向循环链表&双向循环链表
qq_56668869的博客
08-24 3472
数据结构、单向循环链表、程序实现单向循环链表、方法操作示例、双向循环链表、程序实现双向循环链表
数据结构——单向循环链表、双链表、双向循环链表
最新发布
WYF_111501的博客
02-17 1429
m，数到m的人出圈，然后从出圈的下一个人(m+1)开始重复此过程，直到 全部人出圈，于是得到一个出圈人员的新序列。如当n=8，m=4时，若从第一个位置数起，则所得到的新的序列 为4, 8, 5, 2, 1, 3, 7, 6。指针域：存储节点之间的关系，下一个节点的地址，单向循环链表的指针域指向该节点的地址。双向循环链表：尾节点的下一个节点是头节点，头节点的上一个节点是尾节点。1.单向循环链表：尾节点的指针域指向头结点的地址。2.单向循环链表的节点：数据域和指针域。3.双向链表节点的结构体定义。
数据结构——双链表详解（超详细）
effort123_的博客
08-05 1353
哨兵位这个名字看起来是很威武的，其实了解它之后就知道它仅仅就是名字威武点，它才是真正意义上的头结点，哨兵位是不存数据的，它的存在仅仅就是为了说明这个链表是带头的，是用来“放哨的”，小编在讲述单链表的时候曾多次提到了头结点这个名字，那个时候头结点是链表第一个结点，这个叫法是不太规范的，不过为了让读者朋友更好的去理解链表的知识，小编于是就直接头结点来代替链表第一个结点了，不过各位读者朋友一定要清楚。下面紧跟小编的步伐，开启今天的双链表之旅！
数据结构之双向循环链表
未思
02-06 978
算法与数据结构之双向循环链表
数据结构实现循环双链表
cf527085608的专栏
12-05 781
头文件“2_3_3.h”# include# include# includetypedef struct DuLNode{ int data; struct DuLNode *prior; struct DuLNode *next;}*DuLinkList;void CreateList(DuLinkList &L,int n){ //操作一 /
循环链表之双循环链表（C语言版）
weixin_34364135的博客
05-07 454
接着上一篇博文http://12172969.blog.51cto.com/12162969/1918256，把循环链表里的双循环链表的基本操纵按照我个人的理解进行总结一下。依然沿袭过去的风格，进入双循环链表之前，先提另一种结构，双向链表，先有了双向链表再有了双循环链表。这两种结构和单链表一样都有带头结点和不带头结点之分。我们先来看一下这几种结构的结构图:双链表双循环...
第四周 项目4—建设双链表算法库
fj的博客
10-05 383
1.头文件：cdlinklist.h，包含定义双链表数据结构的代码、宏定义、要实现算法的函数的声明； //循环双链表基本运算函数 typedef int ElemType; typedef struct DNode //定义双链表结点类型 { ElemType data; struct DNode *prior; //指向前驱结点 stru
数据结构 双向循环链表
初学者的博客
07-05 1093
双向循环链表
数据结构-双向循环链表
abcnull 的博客
02-15 679
文章目录简介Java 实现 简介 单链表对应着单向循环链表，即原来单链表最后一个结点指向本来为空，现在指向头结点；双向链表对应着双向循环链表，即原来双向链表最后一个结点的后驱结点为空，现在指向头结点，原来双向链表的头结点是没有前驱结点的，现在双向循环链表的头结点的前驱结点指向双向循环链表的尾结点 Java 实现 逻辑思路 逻辑上双向循环链表只不过是在双向链表上多加了循环这个条件，我们在初始化时候使...
数据结构--双向循环链表
RookiChen的博客
05-20 652
上个文章写了循环链表是如何实现的，本文的双向循环链表和循环链表类似，只不过是讲每个节点的prior指向上一个节点，再讲尾结点指向头结点，形成了一个环，双向循环链表的优点就是在查找数据时可以进行双向查找，效率比普通链表要高。 双向循环链表中每个节点定义了两个指针，next（指向下一个）和prior（指向上一个）。 增加：在增加结束前的操作和单链表相同，只是在结尾处要讲头节点的prior指向尾节点，尾节点的next指向头节点。详细代码请看下面的Add函数。 删除：删除时要进行判断删除的节点是否是头结点，详情请.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值