循环双链表的基本操作C语言详解

最新推荐文章于 2024-08-05 09:00:00 发布
最新推荐文章于 2024-08-05 09:00:00 发布
阅读量863 收藏 6
点赞数
分类专栏： 数据结构 文章标签： 双向链表 循环链表 双循环链表 C语言 基本操作
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39791665/article/details/105028275
版权

1. 尾指针：不是尾结点的指针，是指向尾结点的指针
2. 头指针：不是头结点的指针，是指向头结点的指针，无论链表是否为空，头指针均不为空。
3. 头结点：放在第一个结点之前的结点（“零结点”），数据域可以不存放东西，也可以存放链表信息（如链表长度）。

循环链表的存储结构

typedef struct DulNode											//双循环链表的存储结构
{
	int data;													//数据域
	struct DulNode* prior;										//前驱指针
	struct DulNode* next;										//后继指针
}DulNode, * DuLinkList;

数据结构图示
百度搜到的图：
在这里插入图片描述

基本操作

1. int InitDuLinkedList(DuLinkList L); //初始化*

int InitDuLinkedList(DuLinkList* L)									//初始化,形参L是二级指针
{
	*L = (DulNode*)malloc(sizeof(DulNode));							//头结点申请地址
	if (*L == NULL)
	{
		printf("申请空间失败\n");
		exit(0);
	}
	(*L)->data = -999;								//随便存点数据								
	head = *L;										//头指针指向头结点
	tail = *L;										//尾指针指向尾结点，目前只有一个结点，它既是头结点，也是尾结点
	(*L)->prior = tail;								//头结点前驱初指向尾结点

	(*L)->next = (*L);								//(*L)所指结点初始化时，既是头结点，也是尾结点。所以尾结点(**L)的后继指针，指向头结点
	return 1;
}

2. DuLinkList CreatDuLinkList(DuLinkList L); //创建双循环链表*

DuLinkList CreatDuLinkList(DuLinkList* L)						//尾插法创建双循环向链表，形参L是二级指针
{
	int x;														//新插入的结点值
	printf("输入需要插入的元素值\n");
	scanf("%d", &x);

	while (x != 9999)											//输入9999时结束插入
	{
		DuLinkList s = (DulNode*)malloc(sizeof(DulNode));				 //创建新结点
		if (s == NULL)
		{
			printf("动态申请内存失败\n");
			exit(0);
		}
		s->data = x;												//将值存入新结点

		s->next = tail->next;									 //关键步骤
		tail->next->prior = s;
		tail->next = s;
		s->prior = tail;

		tail = s;                                              //尾指针指向新的尾结点,
		printf("插入成功\n");
		printf("输入需要插入的元素值(输入9999结束插入)\n");
		scanf("%d", &x);
	}
	return *L;                                              //返回单链表地址
}

3. int DuLinkListInsert(DuLinkList L, int i, int e); //位置i插入元素e

int DuLinkListInsert(DuLinkList* L, int i, int e)				//第i个位置插入指定元素e
{
	int j = 1;
	DuLinkList p, s;
	p = *L;
	while (p && j < i)											//寻找第i-1个结点
	{
		p = p->next;
		j++;
	}
	if (!p || j > i)
		return 0;											//插入位置非法

	s = (DulNode*)malloc(sizeof(DulNode));                    //动态分配内存
	if (s == NULL)
	{
		printf("动态申请内存失败\n");
		exit(0);
	}
	s->data = e;

	s->prior = p;											//双链表插入操作的四个关键步骤
	s->next = p->next;
	p->next->prior = s;
	p->next = s;

	if (p == tail)                                          //若插入位置为末尾，插入后，修改尾指针指向新尾结点
		tail = s;
	return 1;
}

4. int DuLinkListDelete(DuLinkList L, int i, int e); //删除位置i的元素，用e返回其值**

int DuLinkListDelete(DuLinkList* L, int i, int* e)                      //删除位序为i的结点，并用e返回其元素值
{
	DuLinkList p = *L;											//p最终指向被删除结点
	int j = 1;													//从第一个结点开始找
	while (p->next && j <= i)								 //遍历寻找第i个结点
	{
		p = p->next;
		j++;
	}

	if (!(p->next))										//若p->next=null,此时链表长度可能小于i
		return 0;
	if (p == tail)										//如果被删除的是尾结点，修改尾指针指向新的尾结点
		tail = p->prior;
	*e = p->data;										//返回值

	p->prior->next = p->next;                                //关键两步
	p->next->prior = p->prior;
	free(p);										  //释放内存

	return *e;
}

5. DulNode DuLinkPriorElem(DuLinkList L, int cur_e); //求第一个值为cur_e的前驱

DulNode* DuLinkPriorElem(DuLinkList L, int cur_e)					 //求前驱操作
{
	DuLinkList p = L->next;                         //p指向第一个结点，不是头结点
	while (p != head)                              //遍历整个链表寻找值为cur_e的结点,当p==head时遍历了一周
	{
		if (p->data == cur_e)
			break;
		p = p->next;
	}
	if (p == head)                                   //循环一周没找到
		return NULL;
	else return p->prior;
}

6. DulNode DuLinkNextElem(DuLinkList L, int cur_e); //求第一个值为cur_e的后继*

DulNode* DuLinkNextElem(DuLinkList L, int cur_e)			//求后继操作
{
	DuLinkList p = L->next;                         //p指向第一个结点，不是头结点
	while (p != head)                              //遍历整个链表寻找值为cur_e的结点,当p==head时遍历了一周
	{
		if (p->data == cur_e)
			break;
		p = p->next;
	}
	if (p == head)                                   //循环一周没找到
		return NULL;
	else return p->next;
}

7. DulNode GetElem(DuLinkList L, int i); //求位序为i的元素值*

DulNode* GetElem(DuLinkList L, int i)
{
	int j = 1;									//计数，初始化值为1
	DulNode* p = L->next;						//p 指向第一个结点，不是头结点
	if (i == 0)
		return L;								//返回头结点
	if (i < 1)
		return NULL;						 //位置i不合法
	while (p && j < i && p != head)					//从第一个结点开始找,p==head时，寻找了一周
	{
		p = p->next;
		j++;
	}
	if (p == head)								//链表循环了一周，i大于循环双链表长度，越界
		return NULL;
	return p;								 //返回第i个结点的指针，如果i大于表长，p=NULL
}

8. int DuLinkListTraverse(DuLinkList L); //遍历输出

int DuLinkListTraverse(DuLinkList L)						 //遍历访问整个表L
{
	DulNode* p;
	for (p = L->next; p != NULL; p = p->next)
	{
		printf("%-5d", p->data);
		if (p == tail)                                    //遍历到最后一个元素（tail指向尾结点）
			break;
	}
	return 0;
}

全部代码如下, 编译环境vc6.0:

#include <stdio.h>
#include <stdlib.h>

typedef struct DulNode											//双循环链表的存储结构
{
	int data;													//数据域
	struct DulNode* prior;										//前驱指针
	struct DulNode* next;										//后继指针
}DulNode, * DuLinkList;

struct DulNode* head = NULL;										//头指针,指向头结点
struct DulNode* tail = NULL;										//尾指针，指向尾结点

int InitDuLinkedList(DuLinkList* L);                             //初始化

DuLinkList CreatDuLinkList(DuLinkList* L);						//创建

int DuLinkListInsert(DuLinkList* L, int i, int e);					//位置i插入元素e

int DuLinkListDelete(DuLinkList* L, int i, int* e);				//删除位置i的元素，用e返回其值

DulNode* DuLinkPriorElem(DuLinkList L, int cur_e);					//求第一个值为cur_e的前驱

DulNode* DuLinkNextElem(DuLinkList L, int cur_e);					//求第一个值为cur_e的后继
	
DulNode* GetElem(DuLinkList L, int i);						//求位序为i的元素值

int DuLinkListTraverse(DuLinkList L);							//遍历输出


int main()
{
	int i, e;                                         //i存放元素位序，e存放元素值
	DuLinkList L, DulNode;
	InitDuLinkedList(&L);                            //初始化
	CreatDuLinkList(&L);

	printf("\n输入插入的位置i和元素值e\n");
	scanf("%d%d", &i, &e);
	if (DuLinkListInsert(&L, i, e))
		printf("插入成功\n");
	else printf("插入位置不合法\n\n");
	printf("\n\n遍历结果\n");
	DuLinkListTraverse(L);

	printf("\n输入删除的位序i\n");
	scanf("%d", &i);
	printf("删除的元素为值为%d\n\n", DuLinkListDelete(&L, i, &e));
	printf("\n\n遍历结果\n");
	DuLinkListTraverse(L);

	printf("\n输入需要查找元素的位序i\n");
	scanf("%d", &i);
	DulNode = GetElem(L, i);
	if (DulNode != NULL)
		printf("查找的元素值为%d\n", DulNode->data);
	else printf("查找的位序不合法\n\n");
	printf("\n\n遍历结果\n");
	DuLinkListTraverse(L);

	printf("\n输入需要查找后继的数值e\n");
	scanf("%d", &e);
	DulNode = DuLinkNextElem(L, e);
	if (DulNode != NULL)
		printf("查找的元素后继值为%d\n", DulNode->data);
	else printf("查不到改元素\n\n");

	printf("\n\n遍历结果\n");
	DuLinkListTraverse(L);
	return 0;
}
int InitDuLinkedList(DuLinkList* L)									//初始化,形参L是二级指针
{
	*L = (DulNode*)malloc(sizeof(DulNode));							//头结点申请地址
	if (*L == NULL)
	{
		printf("申请空间失败\n");
		exit(0);
	}
	(*L)->data = -999;								//随便存点数据								
	head = *L;										//头指针指向头结点
	tail = *L;										//尾指针指向尾结点，目前只有一个结点，它既是头结点，也是尾结点
	(*L)->prior = tail;								//头结点前驱初指向尾结点

	(*L)->next = (*L);								//(*L)所指结点初始化时，既是头结点，也是尾结点。所以尾结点(**L)的后继指针，指向头结点
	return 1;
}

DuLinkList CreatDuLinkList(DuLinkList* L)						//尾插法创建双循环向链表，形参L是二级指针
{
	int x;														//新插入的结点值
	printf("输入需要插入的元素值\n");
	scanf("%d", &x);

	while (x != 9999)											//输入999时结束插入
	{
		DuLinkList s = (DulNode*)malloc(sizeof(DulNode));				 //创建新结点
		if (s == NULL)
		{
			printf("动态申请内存失败\n");
			exit(0);
		}
		s->data = x;												//将值存入新结点

		s->next = tail->next;									 //关键步骤
		tail->next->prior = s;
		tail->next = s;
		s->prior = tail;

		tail = s;                                              //尾指针指向新的尾结点,
		printf("插入成功\n");
		printf("输入需要插入的元素值(输入9999结束插入)\n");
		scanf("%d", &x);
	}
	return *L;                                              //返回单链表地址
}

int DuLinkListInsert(DuLinkList* L, int i, int e)				//第i个位置插入指定元素e
{
	int j = 1;
	DuLinkList p, s;
	p = *L;
	while (p && j < i)											//寻找第i-1个结点
	{
		p = p->next;
		j++;
	}
	if (!p || j > i)
		return 0;											//插入位置非法

	s = (DulNode*)malloc(sizeof(DulNode));                    //动态分配内存
	if (s == NULL)
	{
		printf("动态申请内存失败\n");
		exit(0);
	}
	s->data = e;

	s->prior = p;											//双链表插入操作的四个关键步骤
	s->next = p->next;
	p->next->prior = s;
	p->next = s;

	if (p == tail)                                          //若插入位置为末尾，插入后，修改尾指针指向新尾结点
		tail = s;
	return 1;
}

int DuLinkListDelete(DuLinkList* L, int i, int* e)                      //删除位序为i的结点，并用e返回其元素值
{
	DuLinkList p = *L;											//p最终指向被删除结点
	int j = 1;													//从第一个结点开始找
	while (p->next && j <= i)								 //遍历寻找第i个结点
	{
		p = p->next;
		j++;
	}

	if (!(p->next))										//若p->next=null,此时链表长度可能小于i
		return 0;
	if (p == tail)										//如果被删除的是尾结点，修改尾指针指向新的尾结点
		tail = p->prior;
	*e = p->data;										//返回值

	p->prior->next = p->next;                                //关键两步
	p->next->prior = p->prior;
	free(p);										  //释放内存

	return *e;
}

DulNode* DuLinkPriorElem(DuLinkList L, int cur_e)					 //求前驱操作
{
	DuLinkList p = L->next;                         //p指向第一个结点，不是头结点
	while (p != head)                              //遍历整个链表寻找值为cur_e的结点,当p==head时遍历了一周
	{
		if (p->data == cur_e)
			break;
		p = p->next;
	}
	if (p == head)                                   //循环一周没找到
		return NULL;
	else return p->prior;
}

DulNode* DuLinkNextElem(DuLinkList L, int cur_e)			//求后继操作
{
	DuLinkList p = L->next;                         //p指向第一个结点，不是头结点
	while (p != head)                              //遍历整个链表寻找值为cur_e的结点,当p==head时遍历了一周
	{
		if (p->data == cur_e)
			break;
		p = p->next;
	}
	if (p == head)                                   //循环一周没找到
		return NULL;
	else return p->next;
}

DulNode* GetElem(DuLinkList L, int i)
{
	int j = 1;									//计数，初始化值为1
	DulNode* p = L->next;						//p 指向第一个结点，不是头结点
	if (i == 0)
		return L;								//返回头结点
	if (i < 1)
		return NULL;						 //位置i不合法
	while (p && j < i && p != head)					//从第一个结点开始找,p==head时，寻找了一周
	{
		p = p->next;
		j++;
	}
	if (p == head)								//链表循环了一周，i大于循环双链表长度，越界
		return NULL;
	return p;								 //返回第i个结点的指针，如果i大于表长，p=NULL
}

int DuLinkListTraverse(DuLinkList L)						 //遍历访问整个表L
{
	DulNode* p;
	for (p = L->next; p != NULL; p = p->next)
	{
		printf("%-5d", p->data);
		if (p == tail)                                    //遍历到最后一个元素（tail指向尾结点）
			break;
	}
	return 0;
}

**

测试案例

**
在这里插入图片描述

cdhuangjin-
关注
专栏目录
循环双链表的基本操作实现
IMIS_TwentyEight的博客
10-10 574
一．实验目的      巩固线性表的数据结构的存储方法和相关操作，学会针对具体应用，使用线性表的相关知识来解决具体问题。 二.实验内容 1.建立一个由n个学生成绩的顺序表，n的大小由自己确定，每一个学生的成绩信息由自己确定，实现数据的对表进行插入、删除、查找等操作。分别输出结果。 三.实验程序实现如下 1 2 3 4
[数据结构] 双向循环链表的基础操作
weixin_43717520的博客
05-19 1264
本篇文章主要说明的是带头双向循环链表的基础操作，如果对链表概念不太清楚的可以点击这篇文章进行了解。链表的基本结构与操作。 目录一. 基本结构二. 基础操作1. 在指定位置之前插入元素 一. 基本结构   与单链表不同，每一个节点都增加了一个指向前驱的节点，并且首届点和尾节点分别指向开头与结尾，构成双向循环链表。   接下来的篇幅，主要讲述双向链表与单链表操作的不同之处。 二. 基础操作 1. 在指定位置之前插入元素 void ListInsert(ListNode* pos, LTDataType x)
数据结构——双链表详解（超详细）
最新发布
effort123_的博客
08-05 570
哨兵位这个名字看起来是很威武的，其实了解它之后就知道它仅仅就是名字威武点，它才是真正意义上的头结点，哨兵位是不存数据的，它的存在仅仅就是为了说明这个链表是带头的，是用来“放哨的”，小编在讲述单链表的时候曾多次提到了头结点这个名字，那个时候头结点是链表第一个结点，这个叫法是不太规范的，不过为了让读者朋友更好的去理解链表的知识，小编于是就直接头结点来代替链表第一个结点了，不过各位读者朋友一定要清楚。下面紧跟小编的步伐，开启今天的双链表之旅！
数据结构第二章顺序表的基本操作
m0_57440665的博客
10-21 316
什么是顺序表？ 顺序表是线性表的顺序表示，即用一组地址连续的存储单元依次存储线性表的数据元素 顺序表的结构图 顺序表的基本操作 定义状态量 #include <stdlib.h> #include <stdio.h> #define OK 1 #define ERROR 0 #define OVERFLOW –2 #define TRUE 1 #define FALSE 0 typedef int Status; 定义顺序表的结构体 #def...
循环双向链表基础操作
A2438283157的博客
05-04 214
1.创建循环双向链表 2.双向循环链表的头插 3.双向循环链表的遍历 4.双向循环链表的尾插 5.双向循环链表的位置插入 6.双向循环链表判空 7.双向循环链表头删 8.双向循环链表尾删 9.双向循环链表位置删 10.双向循环链根据位置查询数据 11.双向循环链根据位置更新数据
双循环链表的基本操作
Mongo_girl
01-25 247
双循环链表的基本操作 【算法2.18、2.19】 Status InitList_DuL(DuLinkList *L) { *L = (DuLinkList)malloc(sizeof(DuLNode)); if(!(*L)) exit(OVERFLOW); (*L)-&gt;next = (*L)-&gt;prior = *L; return OK; } Status ...
C语言详解双向链表的基本操作
qq_61386381的博客
05-17 3618
双链表的定义与接口函数 定义双链表 接口函数 详解接口函数的实现 创建新节点（BuyLTNode） 初始化双链表（ListInit） 双向链表打印（ListPrint） 双链表查找（ListFind） 双链表销毁（ListDestory） 1、双链表pos位置之前插入（ListInsert） 2、双链表删除pos位置（ListEarse） 3、双向链表尾插（ListPushBack） 4、双向链表头插（ListPushFront） 5、双链表头删（ListPopF.......
C语言中双向链表和双向循环链表详解
08-30
C语言中双向链表和双向循环链表详解 本文主要介绍了C语言中双向链表和双向循环链表的实现与操作，包括双向链表和双向循环链表的定义、初始化、插入操作、删除操作等。 一、双向链表和双向循环链表的定义 在C语言...
C语言之双向链表详解及实例代码
12-31
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表...
双向循环链表的基本操作
积极奋斗的蜗牛
04-27 1897
总结一下双向循环链表的buf
双链表的基本操作
今晚打老虎
10-11 439
http://blog.csdn.net/gaoxiang_/article/details/8279536  双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。       为了练习，我这次设置了哨兵结点，哨兵结点，我个人理解就是我们一般意义上的头结点（是链
[数据结构]双向循环链表及其基本操作
代码中枢：软件工程理论与实践的桥梁
03-08 395
#include <iostream> #include <cstdio> using namespace std; typedef int Elem; typedef int Status; typedef struct DulList { /* data */ Elem data; struct DulList *prior; struct DulList...
带头节点的双向循环链表的基本操作
热门推荐
Ksaila的博客
08-30 1万+
双向循环链表： 双向循环链表中每一个节点都有一个直接的前驱和一个直接的后继 双向循环链表中的节点有两个指针域和一个存放数据的地方，两个指针域一个存放下一个节点的地址，一个存放前一个指针的地址 下面是双向循环链表的基本操作： CircularList.h #ifndef _LINKLIST_H_ #define _LINKLIST_H_ #include&lt;stdlib.h...
双向链表的基本操作
Bit_Dong的博客
06-07 518
上一节学习了单向链表单链表详解。本节学习双向链表。学习之前先对单向链表和双向链表做个回顾。 单向链表特点：   1.我们可以轻松的到达下一个节点, 但是回到前一个节点是很难的   2.只能从头遍历到尾或者从尾遍历到头(一般从头到尾) 双向链表特点：   1.每次在插入或删除某个节点时, 需要处理四个节点的引用, 而不是两个 实现起来要困难一些   2.相对于单向链表, 必然占用内存空间更大一些   3.既可以从头遍历到尾, 又可以从尾遍历到头 双向链表的定义:   双向链表也叫双链表，是链表的一种，它的每个
数据结构学习日记---双向循环链表+链表初级大总结
KLh
04-09 388
一、双向循环链表模型 节点与双向链表一样，都是有前驱指针域和后继指针，双向循环链表最后一个节点指向头节点 头节点前驱指针直线循环链表最后一个节点 2..寻找最后一个节点 structlist_node*p=NULL; p=head->prev; 3.设计一个双向循环链表： #include <stdio.h> #include <stdlib.h> //设计节点 struct list_node{ int data; struct list_nod..
C语言实现：普通与循环双向链表操作详解
"这篇文档介绍了C语言中双向链表的操作，包括普通双向链表和循环双向链表。主要内容包括链表的基本概念、操作原理、不同类型链表的区别以及具体的操作函数，如创建节点、插入节点、查找节点等。" 在C语言中，双向...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值