学习笔记------数据结构(C语言版) 双循环链表

最新推荐文章于 2023-01-02 03:07:34 发布
最新推荐文章于 2023-01-02 03:07:34 发布
阅读量702 收藏 1
点赞数
分类专栏： 学习笔记---数据结构 文章标签： c语言 数据结构 双循环链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CYTCHAN/article/details/50502833
版权
本文详细介绍了如何使用C语言来实现双循环链表的数据结构，包括关键的函数实现和示例代码。
摘要由CSDN通过智能技术生成

//Function realization.cpp

#include"predefined.h"
#include"DoubleLinkList.h"
Status ListInsert_DuL(DuLinkList *L,int i,ElemType e)
//算法2.18：在带头结点的双链循环线性表L中第i个位置之前插入元素e，
//i的合法值为1<=i<=表长+1。
{
	DuLinkList p,s;
	if(!(p=GetElemP_DuL(*L,i))) return ERROR;
	if(!(s=(DuLinkList)malloc(sizeof(DuLNode)))) return ERROR;
	(*s).data=e;
	(*s).prior=(*p).prior;
	(*(*p).prior).next=s;
	(*s).next=p;
	(*p).prior=s;
	return OK;
}

Status ListDelete_DuL(DuLinkList *L,int i,ElemType *e)
//算法2.19：删除带头结点的双链循环表L的第i个元素，i的合法值为1<=i<=表长。
{
	DuLinkList p;
	if(!(p=GetElemP_DuL(*L,i))) return ERROR;
	*e=(*p).data;
	(*(*p).prior).next=(*p).next;
	(*(*p).next).prior=(*p).prior;
	free(p);
	return OK;
}

Status InitList_DuL(DuLinkList *L)//构造一个带头结点的空双链表
{
	(*L)=(DuLinkList)malloc(sizeof(DuLNode));
	if(!(*L)) exit(OVERFLOW);
	(**L).next=(**L).prior=*L;
	return OK;
}

Status DestroyList_DuL(DuLinkList *L)//销毁双链表
{
	DuLinkList p,q;  
    p=*L;  
   do
    {  
        q=(*p).next;  
        free(p);  
        p=q;  
    }  
	while(p!=*L);
	(*L)=NULL;
    return OK; 
}

Status ClearList_DuL(DuLinkList *L)//双链表置空
{
	DuLinkList p,q;  
    p=*L;  
    if(!p) return FALSE;   
    p=(*p).next;  
    while(p!=*L)  
    {  
        q=p;  
        p=(*p).next;  
        free(q);  
    }  
	(**L).next=(**L).prior=*L;  
    return OK;  
}

Status ListEmpty_DuL(DuLinkList L)//若双链表为空，返回TRUE。
{
	if(L&&(*L).next==L&&(*L).prior==L) return TRUE;
	else return FALSE;
}

Status ListLength_DuL(DuLinkList L)//求双链表L的长度。
{
	ElemType n=0;  
    DuLinkList p;
	if(L)
	{
		p=(*L).next; 
        while(p!=L) 
		{
			n++;
		    p=(*p).next;
	    }
	}
    return n;
}

Status GetElem_DuL(DuLinkList L,int i,ElemType *e)//用e返回L中第i的元素的值
{
	DuLinkList p;  
	int j=1;
	p=(*L).next;
	if(L)
	{
		while(p!=L&&j<i)
		{
			p=(*p).next;
			++j;
		}
	   if(p==L||j>i) return ERROR;  
       *e=(*p).data;  
       return OK;
	}
	else return ERROR;
}

Status LocateElem_DuL(DuLinkList L,ElemType e,Status (*compare)(DuLinkList L,ElemType e))
//返回双链表L中第一个与e满足关系compare元素的位序
{
	DuLinkList p;  
    p=L;  
    Status n;  
    n=compare(p,e);  
    if(n) return n;  
    else return FALSE; 
}

Status PriorElem_DuL(DuLinkList L,ElemType cur_e,ElemType *e)//返回前驱
{
	DuLinkList p;
	p=(*L).next;
	if(L)
	{
		while(p!=L)
		{
			if((*p).data==cur_e)
			{
				if((*p).prior==L) return ERROR;
				else
				{
					*e=(*(*p).prior).data;
					return OK;
				}

			}
			p=(*p).next;
		}
	}
	return ERROR;
}

Status NextElem_DuL(DuLinkList L,ElemType cur_e,ElemType *e)//返回后继
{
	DuLinkList p;
	p=(*L).next;
	if(L)
	{
		while(p!=L)
		{
			if((*p).data==cur_e)
			{
				if((*p).next==L) return ERROR;
				else 
				{
					*e=(*(*p).next).data;
					return OK;
				}
			}
			p=(*p).next;
		}
	}
	return ERROR;
}

DuLinkList GetElemP_DuL(DuLinkList L,int i)
//返回双链表L指向第i个元素的指针。
{
	DuLinkList p;
	int j;
	if(i>ListLength_DuL(L)+1||i<1) return NULL;
	p=(*L).next;
	for(j=1;j<i;j++)
	{
		p=(*p).next;
	}
	return p;
}

Status ListTraverse_DuL(DuLinkList L,Status (*visit)(DuLinkList L))
//依次对双链表L中每个元素调用visit函数。
{
	DuLinkList p;  
    Status m; 
    p=(*L).next;
    while(p!=L)
    {  
        m=visit(p);  
        if(m) p=(*p).next;  
        else return FALSE;  
    }  
    return OK;
}

//main.cpp

#include"predefined.h"
#include"DoubleLinkList.h"
Status equal(DuLinkList L,ElemType e)  
{  
    int i;
	DuLinkList p;
	p=(*L).next;
    for(i=1;p!=L;i++)
    {  
		if((*p).data==e)  return i;  
        p=(*p).next;
    }
	return FALSE;
}
Status visit(DuLinkList L)  
{  
    printf("%d ",(*L).data);  
    return OK;  
} 
int main()
{
	DuLinkList La;
	Status s;
	int n,i,m;
	ElemType e;
	printf("Function 1\n★函数InitList_DuL(DuLinkList *L)测试...\n");
	s=InitList_DuL(&La);
	printf("▲初始化双链循环表La: %d (0:失败 1:成功)\n\n",s);
	printf("Function 2\n★函数ListEmpty_DuL(DuLinkList L)测试...\n");
	s=ListEmpty_DuL(La); 
	printf("▲表La是否为空表: %d   (0:否 1:是)\n\n",s);
	printf("Function 3\n★函数ListInsert_DuL(DuLinkList *L,int i,ElemType e)测试...\n");
    printf("▲请输入准备向La输入的个数：");  
    scanf("%d",&n);
	for(i=1;i<=n;i++)  
    {  
        printf("▲请输入La第%d个数：",i);  
        scanf("%d",&m);  
        s=ListInsert_DuL(&La,i,m);  
        printf("▲插入成功?:%d   (1:成功 0:失败)\n",s);  
    }  
    printf("\n");
	printf("Function 4\n★函数ListTraverse_DuL(DuLinkList L,Status (*visit)(DuLinkList L))测试...\n");
	printf("▲La中的元素为：La={");
	ListTraverse_DuL(La,visit);
	printf("}\n\n"); 
	printf("Function 5\n★函数ListLength_DuL(DuLinkList L)测试...\n");
	s=ListLength_DuL(La);  
    printf("▲La的长度为：%d\n\n",s);
	printf("Function 6\n★函数ListDelete_DuL(DuLinkList *L,int i,ElemType *e)测试...\n");
	ListDelete_DuL(&La,3,&e);
	printf("▲删除La中第3个元素：\"%d\"\n",e);  
    printf("▲La中的元素为：La={");
	ListTraverse_DuL(La,visit);
	printf("}\n\n"); 
	printf("Function 7\n★函数GetElem_DuL(DuLinkList L,int i,ElemType *e)测试...\n");
	GetElem_DuL(La,3,&e);
	printf("▲La中第三个位置元素为 \"%d\"\n\n",e); 
	printf("Function 8\n★函数LocateElem_DuL(DuLinkList L,ElemType e,Status (*compare)(DuLinkList L,ElemType e))测试...\n");
	s=LocateElem_DuL(La,5,equal);
	printf("▲La中第一个等于元素\"5\"的位置为 %d\n\n",s);
	printf("Function 9\n★函数PriorElem_DuL(DuLinkList L,ElemType cur_e,ElemType *e)测试...\n");
	PriorElem_DuL(La,5,&e);
	printf("▲La中元素\"5\"的前驱为 %d\n\n",e);
	printf("Function 10\n★函数NextElem_DuL(DuLinkList L,ElemType cur_e,ElemType *e)测试...\n");
	NextElem_DuL(La,5,&e);
	printf("▲La中元素\"5\"的后继为 %d\n\n",e);
	printf("Function 11\n★函数ClearList_DuL(DuLinkList *L)测试...\n");
	printf("▲La置空前 :");  
    ListEmpty_DuL(La)?printf("表La为空！！！\n"):printf("表La非空！！！\n");
	ClearList_DuL(&La);
	printf("▲La置空后 :");  
    ListEmpty_DuL(La)?printf("表La为空！！！\n"):printf("表La非空！！！\n");
	printf("Function 12\n★函数DestroyList_DuL(DuLinkList *L)测试...\n");
	printf("▲La销毁前 :");  
    La?printf("表La存  在！！！\n"):printf("表La不存在！！！\n");
	DestroyList_DuL(&La);
	printf("▲La销毁后 :");  
    La?printf("表La存  在！！！\n"):printf("表La不存在！！！\n");
}

//DoubleLinkList.h 

typedef struct DuLNode
{
	ElemType data;
	struct DuLNode *prior;
	struct DuLNode *next;
}DuLNode,*DuLinkList;
Status ListInsert_DuL(DuLinkList *L,int i,ElemType e);
Status ListDelete_DuL(DuLinkList *L,int i,ElemType *e);
Status InitList_DuL(DuLinkList *L);
Status DestroyList_DuL(DuLinkList *L);
Status ClearList_DuL(DuLinkList *L);
Status ListEmpty_DuL(DuLinkList L);
Status ListLength_DuL(DuLinkList L);
Status GetElem_DuL(DuLinkList L,int i,ElemType *e);
Status LocateElem_DuL(DuLinkList L,ElemType e,Status (*compare)(DuLinkList L,ElemType e));
Status PriorElem_DuL(DuLinkList L,ElemType cur_e,ElemType *e);
Status NextElem_DuL(DuLinkList L,ElemType cur_e,ElemType *e);
DuLinkList GetElemP_DuL(DuLinkList L,int i);
Status ListTraverse_DuL(DuLinkList L,Status (*visit)(DuLinkList L));

Status equal(DuLinkList L,ElemType e);
Status visit(DuLinkList L);


//predefined.h 

#include "stdio.h"
#include "stdlib.h"
#define   TRUE           1
#define   FALSE          0
#define   OK             1
#define   ERROR          0
#define   INFEASIBLE    -1
#define   OVERFLOW      -2
typedef   int Status;
typedef   int ElemType;

注意：双循环链表插入和删除操作和单链表的区别！

笑对人生Charles
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
学习笔记-双向链表与环形链表
touteng55的博客
02-17 260
双向链表 在单链表的基础上，每个节点增加了一个pre属性指向前一个节点。 因为单链表只有next指针，因此只能单向遍历。而双向链表可以从前或从后遍历。另外也可以自我删除，也就是不用借助被删节点的前一个节点进行删除，直接靠自己就行。 增删改查 节点增加了pre指向前一个节点 //双向链表的节点 class StudentNode2{ public int no; public String name; StudentNode2 next; StudentNode2 pre;
《数据结构与算法分析（c语言版）》学习笔记①链表
Chestnut_NBT的博客
05-03 455
链表相关函数(指针法)：链表的建立：#inlucde&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define LEN sizeof(NODE) typedef struct NODE { int elem; struct NODE* next }NODE; NODE * creat() { NODE * head,*P1,*P2; int n=0,i...
c语言 链表 双向链表 双向循环链表
02-26
从linux内核移植出来，独立于用户数据结构，里面有实例参考。C语言代码。
双循环是什么意思c语言,什么是双循环
weixin_28974337的博客
05-24 732
双循环分好多种，您问的是不是双循环制冷？下面我解释一下双循环制冷双级压缩制冷循环原理:其工作过程为：从蒸发器出来的蒸汽经回热器后被低压压缩机吸入，压缩到中间压力并与中冷器出来的干饱和蒸汽在管路中进行混合，使从低压机排出的过热蒸汽被冷却后再进入高压压缩机，经压缩到冷凝压力并进入冷凝器，冷凝后的高压制冷剂液体进入了中冷器的蛇形盘管进行再冷却，然后进入回热器与从蒸发器出来的低温低压蒸汽进行热交换，使从中...
数据结构学习笔记之链表（C语言版）
kimg_bo的专栏
01-04 1277
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表 由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元 素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。        使用链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分
(带表头)双循环链表的C语言实现(详细)
qq_983030560的博客
01-02 993
带表头的双循环链表的C语言实现(详细)
数据结构自学笔记(C语言)链表
weixin_43389179的博客
06-29 214
从上一节内容里可以看出，线性表的顺序存储结构的特点是逻辑关系上相邻的两个数据元素在物理位置上也相邻，因此可以通过物理地址的关系来随机存取表中任意元素，它的存储位置可以用一个简单的直观的公式来表示。然而从另一方面来看，这个特点也导致了这种存储结构的弱点，在插入或者删除操作时需要移动大量元素。这节我们学习线性表的链式存储结构。 线性表的链式存储结构其实就是我们学C语言时最难的链表，他的特点是可以用一组...
算法数据结构学习笔记-C语言.zip
01-01
本学习笔记将深入探讨数据结构的基础知识，以及如何在C语言中实现这些结构。 1. **数组**：数组是最基本的数据结构，它是由相同类型元素的集合组成，通过索引进行访问。在C语言中，数组可以是一维、二维或多维的，...
考研复习知识笔记-数据结构
04-16
数据结构笔记-考研复习 数据结构是计算机科学中的一门重要学科，研究如何组织、存储和使用数据。...这些知识点是考研复习笔记中的一些重要内容，通过学习和掌握这些知识点，可以更好地理解和应用数据结构。
链表树-复合数据结构应用实例.zip
最新发布
06-17
“链表树-复合数据结构应用实例.zip”这个压缩包很可能包含了各种链表和树的实例代码、练习题、解决方案，以及相关的学习笔记。my_resource文件可能是所有资源的集合，其中可能包含了详细讲解、示例代码和练习案例，...
C语言双循环结构程序,C语言，循环结构程序运算
weixin_39785814的博客
05-21 343
#include main( ){int i,j,x=0;for (i=0;i<2;i++){x++;for (j=0 ; j<=3 ; j++){if (j%2)continue ;x++;}x++ ;}printf("x=%d\n",x);}因为你的程序有几个错误·所以我帮你修改了一下 首先这个答案是8这道题的目的就是能让你理解for循环的作用 还有continue的一个用法从程序...
c语言双循环链表,循环链表之双循环链表（C语言版）
weixin_35822833的博客
05-19 583
依然沿袭过去的风格，进入双循环链表之前，先提另一种结构，双向链表，先有了双向链表再有了双循环链表。这两种结构和单链表一样都有带头结点和不带头结点之分。我们先来看一下这几种结构的结构图:双链表双循环链表既然单向链表有普通的链表也就是不循环的链表、那么双向链表也一样，也有普通的双向链表和双向循环链表；也有带头结点，不带头结点的结构，这里依然是两种结构都给出算法，但是普通的循环链表不写，这里只写循环双链...
C语言实现数据结构双循环链表
Orange_Fanta的博客
10-12 156
#include <stdio.h> #include <stdlib.h> typedef struct DNode{ int data; struct DNode * next,*prior; }DNode, * DLinkList; bool InitiList(DLinkList &L){ L= (DNode*)malloc(sizeof(DNode)); if(L==NULL) return false; L->next=NULL; L-
c语言双循环链表,C语言——双向循环链表篇
weixin_39679091的博客
05-19 352
单向链表中的每一个节点有且只有一个指针，这个指针就是用来指向下一个节点的，单向链表顾名思义就是链表方向是单方向的，而本文要介绍的双向链表就是链表方向是双方向的，也就是双向链表中的每一个节点有两个指针，一个指针用来指向上一个节点(前驱)，另一个指针用指向下一个节点(后继)。本文主要是总结一下自己对双向链表的基本操作，当然我也只是写了几个比较简单的操作，其中包括双向链表的创建，插入节点，删除节点，还有...
C语言:循环结构讲解（for、while、do...while）
仔仔木的博客
05-11 5662
for循环、while循环、do...while循环讲解及图解 三位数逆序
c语言之双向循环链表
qq_41555580的博客
05-03 187
//c语言之双向循环链表 #include<stdio.h> #include<malloc.h> typedef struct Student{ int data; struct Student *Next; struct Student *Prior;// }*PNode,Node; PNode creatlist(){ PNode he...
c语言双循环系统,C语言二次系统学习3（分支循环、函数）
weixin_42503069的博客
05-24 192
本次学习，主要针对语句和函数两部分进行学习。分支语句(if，switch)与循环语句(while，for，do while)switch语句中，在每个选择之后如果不进行break跳出，会执行下一个case，而且应注意default语句的使用，一般会放在{}代码块的后方do while语句中，会首先执行一次循环，再进行判定，所以使用相对较少。while循环中，()中的判断条件会比循环代码的使用多一次...
c语言实现双循环链表（创建、增、删、查、改、显示、退出功能）学生管理系统
lqc_suser的博客
08-07 571
双循环链表（学生管理系统） #include&amp;lt;stdio.h&amp;gt; #include&amp;lt;stdlib.h&amp;gt; #include&amp;lt;windows.h&amp;gt; typedef struct student//定义数据结构体 { int number; char name[20]; char sex[4]; float suiji; fl...
【数据结构】C语言实现双向循环链表
weixin_43716338的博客
02-09 638
【数据结构】C语言实现双向循环链表双向循环链表基本操作存储结构类型定义头插法尾插法遍历链表合并插入结点头插尾插中间插整合到同一个函数按结点位置查找删除代码整合进行测试 双向循环链表基本操作 存储结构类型定义 typedef struct DuLNode { ElemType data; //数据域 struct DuLNode *prior; //直接前驱 struct DuLNode *next; //直接后继 }DuLNode,*DuLinkList; 头插法 //头插法 vo
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值