数据结构——循环双链表【c语言版】

最新推荐文章于 2023-11-04 09:23:43 发布
最新推荐文章于 2023-11-04 09:23:43 发布
阅读量701 收藏 3
点赞数 2
分类专栏： 数据结构 文章标签： c语言 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56058578/article/details/121427048
版权

        把双链表改为循环双链表只需要将双链表的尾结点指针由原来的空改为指向头结点，把头结点的prior指针域改为指向尾结点足以，这样就把整个双链表形成了两个环。

如图所示：

 

循环双链表的操作与双链表基本一致，差别在于遍历链表时，判别当前指针p是否指向表尾结点的终止条件不同：

        双链表：p->next != NULL 

        循环双链表：p->next != h

为空条件不同：

        双链表：h->next==NULL && h->prior==NULL 

        循环双链表：h->next==h && h->prior==h 

        对于双链表，采用类似于单链表的类型声明，其结点类型DLinkList的声明如下：

typedef int ElemType;

typedef struct Node
{
	ElemType data;//存储线性表的元素值（1个） 
	struct Node *next;//存储后继元素节点的地址 
	struct Node *prior;//存储前驱元素节点的地址 
}DCLinkList;

        因为双链表的每个结点都有一个指向前驱结点的指针和一个指向后继结点的指针，因此双链表访问一个结点的前、后结点比单链表更方便。

1）初始化双链表

        构造一个空的双链表，空双链表中只存在一个头结点，头结点类型与普通结点一样，data值不用。

DCLinkList *InitList()
{
	DCLinkList *h;
	h=(DCLinkList *)malloc(sizeof(DCLinkList));
	h->next=h;
	h->prior=h;
	return h;
}

2）销毁双链表

        这里调用ListDelete(DLinkList *h,int i,ElemType *e)，删除每个结点并释放，代码如下：

void DestroyList(DCLinkList *h)
{
	int ListDelete(DCLinkList *h,int i,ElemType *e);
	ElemType v;
	
	while(h->next!=h||h->prior!=h)//不空
	{
		//删除第1个元素节点
		ListDelete(h,1,&v); 
	} 
	free(h);
}

3）判断双链表是否为空

        为空条件：h->next == NULL and h->prior == NULL

代码如下：

ListEmpty(DCLinkList *h)
{
	if(h->next==NULL&&h->prior==NULL)
	{
		return 1;
	} 
	else
	{
		return 0;
	}
}

4）求双链表长度

        代码如下：

int ListLength(DCLinkList *h)
{
	DCLinkList *p;
	int len;
	p=h;
	len=0;
	while(p->next!=NULL)
	{
		p=p->next;
		len=len+1;
	} 
	return len;
}

5_1）输出双链表元素

        代码如下：

void DispList(DCLinkList *h)
{
	DCLinkList *p;
	p=h; 
	printf("线性表的元素为：");
	while(p->next!=NULL)
	{
		p=p->next;
		printf("%d ",p->data); 
	} 
	printf("\n");
}

5_2）逆向输出双链表元素

        代码如下：

void DispList1(DCLinkList *h)
{
	DLinkList *p;
	//让p指向最后一个元素节点 
	p=h; 
	while(p->next!=h)
	{
		p=p->next;
	}
	//从最后一个元素逆序输出至第一个元素 
	printf("线性表的元素为：");
	while(p!=h)
	{
		printf("%d ",p->data); 
		p=p->prior;
	} 
	printf("\n");
}

6）取值

        取双链表中第i位置的元素，需要判断参数合法性，这里可以调用求长度ListLength(DLinkList *h)的函数来确定双链表范围，代码如下：

/*
6.取值
 
参数合法：i>=1 && i<=ListLength(h)
若参数合法，进行相关操作，返回1；
否则，提示，返回0  
*/
int GetElem(DCLinkList *h,int i,ElemType *e)
{
	DCLinkList *p;
	int j;
	
	if(i>=1 && i<=ListLength(h))
	{
		p=h;
		for(j=1;j<=i;j++)
		{
			p=p->next;
		} 
		*e=p->data;
		return 1;
	} 
	else
	{
		printf("参数错误！\n");
		return 0;
	}	
}

7）查找

        查找双链表中是否存在某个值e，代码如下：

/*
在线性表中查找是否存在值为e的元素，
若存在，返回该元素的位序
否则，返回0 
*/
int LocateElem(DCLinkList *h,ElemType e)
{
	DCLinkList *p;
	int len;
	p=h;
	len=0;
	while(p->next!=h)
	{
		p=p->next;
		len=len+1;
		if(p->data==e)
		{
			return len;
		}
	} 
	return 0;
}

8）插入元素

        插入元素需要判断插入位置的合法性，双链表中在第i个位置插入元素e与单链表类似，要先找到第i-1个位置（让p指向它），然后在p所指向的结点后面插入新结点，

 插入元素需要改变四个指针域

代码如下：

/* 

参数合法：i>=1 && i<=ListLength(h)+1
若参数合法，进行相关操作，返回1；
否则，提示，返回0  
*/
int ListInsert(DCLinkList *h,int i,ElemType e)
{
	DCLinkList *p,*q;
	int j;
	
	if(i>=1 && i<=ListLength(h)+1)
	{
		//1.构造一个节点q，存储元素e
		q=(DCLinkList *)malloc(sizeof(DCLinkList));
		q->data=e;
		//2.让p指向第i-1个元素节点 
		p=h;
		for(j=1;j<=i-1;j++)
		{
			p=p->next;
		} 
		//3.添加
		q->next=p->next;
		p->next->prior=q;
		p->next=q;
		q->prior=p; 
		return 1;
	}
	else
	{
		printf("参数错误！\n");
		return 0;
	} 
}

9）删除元素

        双链表中在删除第i个位置元素e与单链表类似，要先找到第i-1个位置（让p指向它），然后删除p所指向的结点，

 删除元素需要改变两个指针域

代码如下： 

/*
参数合法：i>=1 && i<=ListLength(h)
若参数合法，进行相关操作，返回1；
否则，提示，返回0  
*/
int ListDelete(DCLinkList *h,int i,ElemType *e)
{
	DCLinkList *p,*q;
	int j;
	
	if(i>=1 && i<=ListLength(h))
	{
		//1.让p指向第i-1个
		p=h;
		for(j=1;j<=i-1;j++)
		{
			p=p->next;
		} 
		//2.让q指向第i个
		q=p->next;
		//3.把要删除的元素值存储到*e中 
		*e=q->data;
		//4.删除
		p->next=q->next;
		q->next->prior=p;
		//5.释放存储空间
		free(q); 
		return 1;
	}
	else
	{
		printf("参数错误！\n");
		return 0;
	} 	
}

最后再附上完整代码：

#include <stdio.h>

typedef int ElemType;

typedef struct Node
{
	ElemType data;//存储线性表的元素值（1个） 
	struct Node *next;//存储后继元素节点的地址 
	struct Node *prior;//存储前驱元素节点的地址 
}DCLinkList;

/*
最后一个节点的后继是头节点；
头节点的前驱是最后一个节点。 

为了方便操作，特别地加了一个头节点进来，类型和普通节点一样
data：不用 
next：存储第1个元素节点的地址
prior：最后一个节点的地址 

执行语句p=p->next;一次，p的指向往后移动一个位置
执行语句p=p->prior;一次，p的指向往前移动一个位置

空：h->next==h && h->prior==h 
最后一个节点：若p->next==h,说明p指向最后一个节点 
*/

/*
1.初始化
构造一个空的线性表 
*/
DCLinkList *InitList()
{
	DCLinkList *h;
	h=(DCLinkList *)malloc(sizeof(DCLinkList));
	h->next=h;
	h->prior=h;
	return h;
}

/*
2.销毁 
*/
void DestroyList(DCLinkList *h)
{
	int ListDelete(DCLinkList *h,int i,ElemType *e);
	ElemType v;
	
	while(h->next!=h||h->prior!=h)//不空
	{
		//删除第1个元素节点
		ListDelete(h,1,&v); 
	} 
	free(h);
} 

/*
3.判断线性表是否为空
若为空，返回1；
否则，返回0 
*/
ListEmpty(DCLinkList *h)
{
	if(h->next==h&&h->prior==h)
	{
		return 1;
	} 
	else
	{
		return 0;
	}
} 

/*
4.求长度 
*/
int ListLength(DCLinkList *h)
{
	DCLinkList *p;
	int len;
	p=h;
	len=0;
	while(p->next!=h)
	{
		p=p->next;
		len=len+1;
	} 
	return len;
} 

/*
5.输出 
*/
void DispList(DCLinkList *h)
{
	DCLinkList *p;
	p=h; 
	printf("线性表的元素为：");
	while(p->next!=h)
	{
		p=p->next;
		printf("%d ",p->data); 
	} 
	printf("\n");
}

/*
5.输出 
*/
void DispList1(DCLinkList *h)
{
	DCLinkList *p;
	//让p指向最后一个元素节点 
	p=h; 
	while(p->next!=h)
	{
		p=p->next;
	}
	//从最后一个元素逆序输出至第一个元素 
	printf("线性表的元素为：");
	while(p!=h)
	{
		printf("%d ",p->data); 
		p=p->prior;
	} 
	printf("\n");
}

/*
6.取值
 
参数合法：i>=1 && i<=ListLength(h)
若参数合法，进行相关操作，返回1；
否则，提示，返回0  
*/
int GetElem(DCLinkList *h,int i,ElemType *e)
{
	DCLinkList *p;
	int j;
	
	if(i>=1 && i<=ListLength(h))
	{
		p=h;
		for(j=1;j<=i;j++)
		{
			p=p->next;
		} 
		*e=p->data;
		return 1;
	} 
	else
	{
		printf("参数错误！\n");
		return 0;
	}	
}

/*
7.查找
在线性表中查找是否存在值为e的元素，
若存在，返回该元素的位序
否则，返回0 
*/
int LocateElem(DCLinkList *h,ElemType e)
{
	DCLinkList *p;
	int len;
	p=h;
	len=0;
	while(p->next!=h)
	{
		p=p->next;
		len=len+1;
		if(p->data==e)
		{
			return len;
		}
	} 
	return 0;
} 

/*
8.添加 

参数合法：i>=1 && i<=ListLength(h)+1
若参数合法，进行相关操作，返回1；
否则，提示，返回0  
*/
int ListInsert(DCLinkList *h,int i,ElemType e)
{
	DCLinkList *p,*q;
	int j;
	
	if(i>=1 && i<=ListLength(h)+1)
	{
		//1.构造一个节点q，存储元素e
		q=(DCLinkList *)malloc(sizeof(DCLinkList));
		q->data=e;
		//2.让p指向第i-1个元素节点 
		p=h;
		for(j=1;j<=i-1;j++)
		{
			p=p->next;
		} 
		//3.添加
		q->next=p->next;
		p->next->prior=q;
		p->next=q;
		q->prior=p; 
		return 1;
	}
	else
	{
		printf("参数错误！\n");
		return 0;
	} 
}

/*
9.删除

参数合法：i>=1 && i<=ListLength(h)
若参数合法，进行相关操作，返回1；
否则，提示，返回0  
*/
int ListDelete(DCLinkList *h,int i,ElemType *e)
{
	DCLinkList *p,*q;
	int j;
	
	if(i>=1 && i<=ListLength(h))
	{
		//1.让p指向第i-1个
		p=h;
		for(j=1;j<=i-1;j++)
		{
			p=p->next;
		} 
		//2.让q指向第i个
		q=p->next;
		//3.把要删除的元素值存储到*e中 
		*e=q->data;
		//4.删除
		p->next=q->next;
		q->next->prior=p;
		//5.释放存储空间
		free(q); 
		return 1;
	}
	else
	{
		printf("参数错误！\n");
		return 0;
	} 	
} 
/*
变量先定义，再赋初值，才能使用 
*/
int main()
{
	/*
	int a;
	int b;
	
	b=a*10;
	printf("%d\n",b);*/
	
	/*
	int *p;
	
	p=(int *)malloc(sizeof(int));
	
	*p = 123;
	
	printf("%d\n",*p);
	
	free(p);
	*/
	return 1;
}

代码是再单链表的基础上修改的，如有错误，请多多指教

书香恋仁心
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法 —— Java 实现（链表）
01-21
数据结构与算法 —— Java 实现（链表）一、单链表1.1 链表的定义1.2 链表添加一个新的节点1.3 判断当前节点是否为最后一个节点 （isLast）1.4 删除下一节点 （removeNext）1.5 显示节点信息（show）1.6 插入一个...
特殊的链表——双向、循环、静态
01-20
数据结构 typedef struct node { int data; struct node *font ; struct node *next; } NODE, *LinkList; 插入 // p 为链中节点 s 为待插入节点 把s 放在p前 s->font = p->font ; // s 的前驱在是 p 的前驱...
【数据结构】线性表 ⑥ ( 双循环链表 | 双循环链表插入操作 | 双循环链表删除操作 | LinkedList 双循环链表源码分析 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
05-21 1671
一、双循环链表插入操作处理 二、双循环链表删除操作处理 三、LinkedList 双循环链表源码分析 1、链表节点 2、LinkedList 链表中收尾元素指针 3、链表插入操作 4、链表向指定位置插入操作 5、获取指定索引的元素 6、删除指定索引的元素
双向链表
kslly的专栏
04-08 775
一、解析 在单链表中，有了next指针，要查找下一节点的时间复杂度为O(1)，如果要查找的是上一节点的话，最坏的时间复杂度是O(n)了，以为每次都要从头开始查找。为了克服这个缺点引入了双链表设计： 双链表（doublelinked list）:是在单链表的每个节点中，在设置一个指向其前驱节点的指针域。双链表有两个指针域，一个指向直接前驱，一个指向直接后继。   /*线性表的双向链表存储结构
数据结构--循环双链表实现、详解
吴声子夜歌的博客
01-15 1891
双链表 双链表的插入和删除操作 在p节点之前插入值为x的节点 在p节点之后插入值为x的节点 双链表的删除操作 双链表节点 package pers.zhang.linearList; /** * @author zhang * @date 2020/1/15 - 11:06 * 双链表节点类 */ public class DLinkNode<T> { ...
数据结构判断链表是否为空：
m0_58687013的博客
06-15 1711
数据结构判断链表是否为空
经典数据结构算法c语言实现代码（大全）
12-11
16进制10进制.txt 32.txt asm.txt Crctable.txt C标志符命名源程序.txt ... 双链表正排序.txt 反出字符.txt 叠代整除.txt 各种排序法.txt 哈夫曼算法.txt 哈慢树.txt 四分砝码.txt 四塔1.txt
c语言数组指定位置插入和删除-玩转C语言链表，单链表双向链表的建立遍历插入删除... 数组和链表.pdf
04-18
链表是一种常见的数据结构，与数组不同的是链表可以根据大小需要进行扩展，并且链表可以动态随机分配空间。链表结构图如下所示： 在链表中，每一个元素包含两个部分：数据部分和指针部分。数据部分用来存放元素所...
通讯录的制作（数据结构c语言 代码+报告）
04-04
通讯录的制作：用《数据结构》中的双向链表作数据结构，结合C语言基本知识。编写一个通讯录管理系统。以把所学数据结构知识应用到实际软件开发中去。 2、功能需求分析 本系统应完成一下几方面的功能： 1)输入信息...
循环双向链表的·插入、删除
qq_42777577的博客
11-28 733
#include"stdio.h" #include"stdlib.h" typedef int Status; typedef int ElemType; typedef struct MyStruct { ElemType data; MyStruct *prior; MyStruct *next; }*dlist,node; /* //获取指定节点地址 //位置不当是返回NULL...
双向循环链表基本操作（初始化，插入，删除，清空，销毁，访问前驱，后继等）
wfdtxz的专栏
11-20 9046
#include "stdio.h" #include #define OK 1 #define ERROR 0 #define OVERFLOW -1 #define TRUE 1 #define FALSE 0 typedef int ElemType; ty
双链表详解(初始化、插入、删除、遍历)(数据结构与算法)
最新发布
AII_IIA的博客
11-04 2220
同时，删除节点后必须确保释放相应的内存空间，以防止内存泄漏问题的发生。11. 双链表相较于单链表需要额外存储指向前一个节点的指针，因此会在空间上占用更多的内存。7. 双链表的每个节点包含三个部分：数据域、指向前一个节点的指针和指向下一个节点的指针。在双链表中删除节点的操作相对比较复杂，因为我们需要维护前驱节点和后继节点之间的指针连接。在双链表中插入节点需要更新前驱节点和后继节点的指针连接，操作相对比较复杂。将 p 结点的next指针，指向q结点的后继结点。程序设计如下：注意修改指针时要注意顺序！
实现循环双链表各种基本操作
weixin_63233998的博客
02-09 295
循环双链表基本操作
[ 数据结构_C实现 ] 双向循环带头链表的简单实现
CSDN博客
03-22 3394
目录 1.双向循环带头链表的介绍。 2.双向循环带头链表的接口。 3.接口实现。 3.1创建新节点 3.2创建返回链表的头结点 3.3打印链表 3.4双向链表查找 3.5双向链表在pos的前面进行插入 3.5.1 头插 3.5.2 尾插 3.6双向链表删除pos位置的节点 3.6.1 尾删 3.6.2 头删 4.菜单 5.完整代码： 6.功能测试： 1.双向循环带头链表的介绍。 所谓双向循环带头链表可以分为以下3类来进行理解： 首先是双向：双向表示后一个节点可以找到
双向带头循环链表-实现思路+图解
Eliauk_U的博客
04-02 1911
目录 一.何为双向循环链表？ 1.何为'双向'？ 2.何为'带头'？ 3.何为'循环'？ 二.如何实现双向带头循环链表? 1.基本结构-结点的创建 2.创建哨兵位结点 3.链表的增删查改 一.何为双向循环链表？ 在学习双向带头循环链表之前，我们一定都学习过最基础的单链表。单链表是一种线性的数据结构，由若干个动态内存分配的结点相互链接而形成，其中每一个结点拥有一个指向下一个结点的指针。因此，通过头节点进行顺序访问，我们可以遍历这个单链表获取数据。单链表图示如下: 然而，由于.
双向链表的插入
weixin_52634719的博客
09-20 9406
概览: 已知p指针，那么a结点的地址就在p指针所指结点的prior里存着， a结点要变成s的前驱， 所以要给s的Prior域赋值，赋的是a结点的地址，即p的prior。 接下来 将s结点变成a结点的后继，就要给a结点的next域赋值，赋的是新插入结点的地址，而他此时在s里存着 a结点的next域就是p的前驱结点的next，即p->prior->next=s; 接下来s还要作为b的前驱，则又需要修改两个指针 一个呢是b作为新...
2-1-2：双链表插入、删除图解及可运行代码实现
weixin_45418543的博客
06-14 946
双链表：用3个数组实现的，而非指针题目来自于acwing平台，可自行百度此平台
C/C++学习（九）循环双链表的操作之创建，插入、删除
阳仔的博客
12-27 3349
双向链表 循环单链表的出现，虽然能够实现从任一结点出发沿着链能找到其前驱结点，但时间耗费是O（n）。如果希望从表中快速确定某一个结点的前驱，另一个解决方法就是在单链表的每个结点里再增加一个指向其前驱的指针域prior。这样形成的链表中就有两条方向不同的链，我们可称之为双（向）链表（Double Linked List）。双链表的结构定义如下： //建立一个线性双向链表的存储结构
数据结构——用c语言描述(第3版)课后答案
10-25
《数据结构——用C语言描述（第3版）》课后答案的描述使用C语言来实现各种数据结构和算法。以下是对几个常见数据结构的描述和相关代码示例。 1. 数组（Array）：数组是一种线性数据结构，用于存储相同类型的元素。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值