【数据结构】C语言实现双向循环链表

最新推荐文章于 2024-07-22 18:39:29 发布
最新推荐文章于 2024-07-22 18:39:29 发布
阅读量651 收藏 2
点赞数
分类专栏： 数据结构 C语言 文章标签： 数据结构 链表 单链表 c语言 指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43716338/article/details/113772769
版权

【数据结构】C语言实现双向循环链表

双向循环链表基本操作

在这里插入图片描述

存储结构类型定义

typedef struct DuLNode
{
	ElemType data;   //数据域 
	struct DuLNode *prior;   //直接前驱 
	struct DuLNode *next;	 //直接后继 
}DuLNode,*DuLinkList;

头插法

//头插法
void CreateList_H(DuLinkList *LHead,int n)
{
	int i;
	*LHead = (DuLinkList)malloc(sizeof(DuLNode));   //头结点
	DuLNode * LTail = (DuLinkList)malloc(sizeof(DuLNode));   //尾结点 
	DuLNode *tmp_node;    //临时结点（新插入结点）    
	(*LHead)->next = LTail;   //头结点next指向尾结点
	(*LHead)->prior = LTail;   //头结点prior指向尾结点 
	LTail->next = *LHead;      //尾结点next指向头结点 
	LTail->prior = *LHead;     //尾结点指向头结点  进而首位相连形成一个双向循环 
	printf("头插法输入%d个元素: ",n);
	scanf("%d",&LTail->data);    //循环外为尾结点输入数据先 
	 for(i=0;i<n-1;i++)
	 {
	 	tmp_node = (DuLinkList)malloc(sizeof(DuLNode));    //动态分配新节点空间单元 
	 	scanf("%d",&tmp_node->data);           // 为新结点输入数据 
	 	tmp_node->next = (*LHead)->next;       //新结点next指向后继结点
	 	tmp_node->prior = (*LHead)->next->prior;   //尾结点一直都在动，不能用之作为参考点，所以用头结点LHead指向自己 
//	 	(*LHead)->next = tmp_node;      //头结点next指针重置，指向新结点 
	 	(*LHead)->next->prior = tmp_node;   //原后继结点prior（使用固定的头结点表示）重置，指向新结点 
	 	(*LHead)->next = tmp_node;      //此处做个致命错误标志，这两步不能乱 
	 }
}

注意插入元素时指针域修改的先后顺序，例如：这里的倒数两行代码，先修改(*LHead)->next->prior = tmp_node; 再修改(*LHead)->next = tmp_node; 它们之间的关系prior指针需要头结点原来的next获得，如果先改了next就将出现指向错误和断链的现象。

尾插法

//尾插法
void CreateList_R(DuLinkList *LHead,int n)
{
	int i;
	*LHead = (DuLinkList)malloc(sizeof(DuLNode));   //开辟头结点内存单元 
	DuLNode *tmp_node;     //定义一个临时结点指针（新插入结点指针） 
	(*LHead)->next = *LHead;   //头结点next指向自己 
	(*LHead)->prior = *LHead;    //头结点prior指向自己 
	printf("尾插法输入%d个元素: ",n);
	for(i=0;i<n;i++)
	{
		tmp_node = (DuLinkList)malloc(sizeof(DuLNode));    //为新结点动态开辟空间，让新结点指针指向它 
		tmp_node->next = *LHead;    //新插入结点next与头结点进行连接 
		tmp_node->prior = (*LHead)->prior;    //新插入结点prior与原链尾连接   这两步其实就是将新插入结点的next和prior都连接到链尾 
		scanf("%d",&tmp_node->data);    //为新结点输入数据 
		(*LHead)->prior->next = tmp_node;    //使用头结点prior引出原链尾结点，并让它next指向新结点 
		(*LHead)->prior = tmp_node;       //头结点prior指向新结点 
	}
}

遍历

//遍历
Status print(DuLinkList LHead)
{
	DuLNode *tmp_node = LHead;  //一开始指向头结点 
	if(LHead->next == LHead)  return ERROR;   //空链表返回ERROR
	printf("当前链表："); 
	while(LHead != tmp_node->next)  //尾结点的next域不等于头结点指针时循环继续 
	{
		tmp_node = tmp_node->next;      //循环体内每移动一项立即输出data，然后再判断就不会漏了 
		printf("%d ",tmp_node->data);
	}
	printf("\n");
	return OK;
}

链表合并

//合并  A链合并到B链 
Status Union(DuLinkList *LHead_a,DuLinkList *LHead_b)
{
	if(((*LHead_a)->next == *LHead_a) || ((*LHead_b)->next == *LHead_b)) return ERROR;
	(*LHead_a)->prior->next = (*LHead_b)->next;   //A链链尾next指向B链首元结点
	(*LHead_b)->next->prior = (*LHead_a)->prior;     //B链链头prior与A链链尾相连 
	(*LHead_a)->prior = (*LHead_b)->prior;   //A链头结点prior与B链链尾相连 
	(*LHead_b)->prior->next = *LHead_a;  //B链尾结点next指向A链头结点 
	free(*LHead_b);   //释放B链头结点内存单元 
	free(LHead_b);     //释放B链头指针 
}

插入结点

图解
在这里插入图片描述

头插
//插入（头插法）
void ListInsert_H(DuLinkList *LHead,ElemType e)     //LHead头指针 指针 
{
	DuLNode *tmp_node = (DuLinkList)malloc(sizeof(DuLNode));    //新结点储存单元空间指针 
	tmp_node->data = e;     //新结点输入数据 
	tmp_node->next = (*LHead)->next;      //新结点next指向头结点指向的下一个结点 
	tmp_node->prior = (*LHead)->next->prior;     //新结点prior指向头结点（也可以把*LHead->next->prior替换为*LHead）
	(*LHead)->next->prior = tmp_node;     //将原首元结点的prior指向换为新结点 
	(*LHead)->next = tmp_node;        //将头结点next指向新结点
	printf("元素%d 成功插头~\n",e); 
}
尾插
//插入(尾插法)
void ListInsert_R(DuLinkList *LHead,ElemType e)    //LHead头指针 指针 
{
	DuLNode *tmp_node = (DuLinkList)malloc(sizeof(DuLNode));    //开辟空间单元给新结点 
	tmp_node->data = e;      //为新结点输入数据 
	tmp_node->next = *LHead;       //新结点next指向头结点 
	tmp_node->prior = (*LHead)->prior;    //新结点prior指向上一个元素（使用头结点的prior替代） 
	(*LHead)->prior->next = tmp_node;    //原链尾next指向新结点 
	(*LHead)->prior = tmp_node;          //头结点prior指向新结点
	printf("元素%d 成功插尾~\n",e); 
}
中间插
//插入到表中间 
Status ListInsert_C(DuLinkList LHead,int n,ElemType e)
{
	DuLNode *tmp_node = (DuLinkList)malloc(sizeof(DuLNode));    //新界结点指针并为之开辟空间 
	DuLNode *p = GetElem(LHead,n);           ///按位序找指针 
//	printf("%d",p->data);
	if(!p) return ERROR;          //如果返回指针有误就结束插入操作 
	tmp_node->data = e;              //新结点输入数据 
	tmp_node->next = p;              //新结点next指针指向查找原位置指针p 
	tmp_node->prior = p->prior;     //新结点prior指向原位置结点的prior的指针 
	p->prior->next = tmp_node;        //原位p结点的上一个结点的next指向新结点 
	p->prior = tmp_node;                //原位置结点的prior指向新结点 
	printf("元素%d 成功插入中间~\n",e);
	return OK;
}
整合到同一个函数

实现一个函数插三个位置。

//插入  整合了头尾中间 
Status ListInsert(DuLinkList *LHead,int n,ElemType e)
{
	DuLNode *tmp_node;                 //新结点指针 
	if(n==1) ListInsert_H(LHead,e);    //首先判断插入位置为1则是查到链头，所以用插头ListInsert_H 
	tmp_node = GetElem(*LHead,n);       //按位找该位置结点指针  
	if(!tmp_node) return ERROR;       //返回结点有误则结束 
	if(tmp_node->next == *LHead) ListInsert_R(LHead,e);       //如果该位置是链尾直接用插尾函数插入 
	ListInsert_C(*LHead,n,e);     //‘剩下的就是插中间 
	return OK;   
}

按结点位置查找

//按位查找
DuLNode *GetElem(DuLinkList LHead,int n)
{
	int j=1;  //这里从首元结点开始查找，j设置为1 
	DuLNode *tmp_node = LHead->next;  //指向首元结点
	while(tmp_node!=LHead && j<n)    //循环条件：链表非空——next域不指向自己，取值位置合理 
	{
		tmp_node = tmp_node->next;   //指针指向下一个 
		j++;   //位置计数加一 
	}
	if(tmp_node==LHead && j>=n) return ERROR;   //空链以及取值位置不合理返回ERROR 
	return tmp_node;   //返回查找位置 指针 
}

删除

//删除 
Status ListDetele(DuLinkList *LHead,int n)
{
	int i;
	DuLNode *tmp_node;
	tmp_node = (*LHead)->next;  //指向首元结点
	for(i=1;i<n;i++)
		tmp_node = tmp_node->next;         //for循环遍历查找第n个结点 
	tmp_node->next->prior = tmp_node->prior;    //第n个结点后一个的prior指向第n前一个结点指针 
	tmp_node->prior->next = tmp_node->next;        //同理，第n个前一个next指针指向第n个结点后一个 
	free(tmp_node);    //释放第n结点的内存单元空间 
	printf("成功删除位置%d的元素~\n",n); 
}

代码整合进行测试

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

#define OK 1
#define ERROR 0

typedef int Status;
typedef int ElemType;

typedef struct DuLNode
{
	ElemType data;   //数据域 
	struct DuLNode *prior;   //直接前驱 
	struct DuLNode *next;	 //直接后继 
}DuLNode,*DuLinkList;

//头插法
void CreateList_H(DuLinkList *LHead,int n)
{
	int i;
	*LHead = (DuLinkList)malloc(sizeof(DuLNode));   //头结点
	DuLNode * LTail = (DuLinkList)malloc(sizeof(DuLNode));   //尾结点 
	DuLNode *tmp_node;    //临时结点（新插入结点）    
	(*LHead)->next = LTail;   //头结点next指向尾结点
	(*LHead)->prior = LTail;   //头结点prior指向尾结点 
	LTail->next = *LHead;      //尾结点next指向头结点 
	LTail->prior = *LHead;     //尾结点指向头结点  进而首位相连形成一个双向循环 
	printf("头插法输入%d个元素: ",n);
	scanf("%d",&LTail->data);    //循环外为尾结点输入数据先 
	 for(i=0;i<n-1;i++)
	 {
	 	tmp_node = (DuLinkList)malloc(sizeof(DuLNode));    //动态分配新节点空间单元 
	 	scanf("%d",&tmp_node->data);           // 为新结点输入数据 
	 	tmp_node->next = (*LHead)->next;       //新结点next指向后继结点
	 	tmp_node->prior = (*LHead)->next->prior;   //尾结点一直都在动，不能用之作为参考点，所以用头结点LHead指向自己 
//	 	(*LHead)->next = tmp_node;      //头结点next指针重置，指向新结点 
	 	(*LHead)->next->prior = tmp_node;   //原后继结点prior（使用固定的头结点表示）重置，指向新结点 
	 	(*LHead)->next = tmp_node;      //此处做个致命错误标志，这两步不能乱 
	 }
}

//尾插法
void CreateList_R(DuLinkList *LHead,int n)
{
	int i;
	*LHead = (DuLinkList)malloc(sizeof(DuLNode));   //开辟头结点内存单元 
	DuLNode *tmp_node;     //定义一个临时结点指针（新插入结点指针） 
	(*LHead)->next = *LHead;   //头结点next指向自己 
	(*LHead)->prior = *LHead;    //头结点prior指向自己 
	printf("尾插法输入%d个元素: ",n);
	for(i=0;i<n;i++)
	{
		tmp_node = (DuLinkList)malloc(sizeof(DuLNode));    //为新结点动态开辟空间，让新结点指针指向它 
		tmp_node->next = *LHead;    //新插入结点next与头结点进行连接 
		tmp_node->prior = (*LHead)->prior;    //新插入结点prior与原链尾连接   这两步其实就是将新插入结点的next和prior都连接到链尾 
		scanf("%d",&tmp_node->data);    //为新结点输入数据 
		(*LHead)->prior->next = tmp_node;    //使用头结点prior引出原链尾结点，并让它next指向新结点 
		(*LHead)->prior = tmp_node;       //头结点prior指向新结点 
	}
}

//遍历
Status print(DuLinkList LHead)
{
	DuLNode *tmp_node = LHead;  //一开始指向头结点 
	if(LHead->next == LHead)  return ERROR;   //空链表返回ERROR
	printf("当前链表："); 
	while(LHead != tmp_node->next)  //尾结点的next域不等于头结点指针时循环继续 
	{
		tmp_node = tmp_node->next;      //循环体内每移动一项立即输出data，然后再判断就不会漏了 
		printf("%d ",tmp_node->data);
	}
	printf("\n");
	return OK;
}

//按位查找
DuLNode *GetElem(DuLinkList LHead,int n)
{
	int j=1;  //这里从首元结点开始查找，j设置为1 
	DuLNode *tmp_node = LHead->next;  //指向首元结点
	while(tmp_node!=LHead && j<n)    //循环条件：链表非空——next域不指向自己，取值位置合理 
	{
		tmp_node = tmp_node->next;   //指针指向下一个 
		j++;   //位置计数加一 
	}
	if(tmp_node==LHead && j>=n) return ERROR;   //空链以及取值位置不合理返回ERROR 
	return tmp_node;   //返回查找位置 指针 
}


//插入(尾插法)
void ListInsert_R(DuLinkList *LHead,ElemType e)    //LHead头指针 指针 
{
	DuLNode *tmp_node = (DuLinkList)malloc(sizeof(DuLNode));    //开辟空间单元给新结点 
	tmp_node->data = e;      //为新结点输入数据 
	tmp_node->next = *LHead;       //新结点next指向头结点 
	tmp_node->prior = (*LHead)->prior;    //新结点prior指向上一个元素（使用头结点的prior替代） 
	(*LHead)->prior->next = tmp_node;    //原链尾next指向新结点 
	(*LHead)->prior = tmp_node;          //头结点prior指向新结点
	printf("元素%d 成功插尾~\n",e); 
}

//插入（头插法）
void ListInsert_H(DuLinkList *LHead,ElemType e)     //LHead头指针 指针 
{
	DuLNode *tmp_node = (DuLinkList)malloc(sizeof(DuLNode));    //新结点储存单元空间指针 
	tmp_node->data = e;     //新结点输入数据 
	tmp_node->next = (*LHead)->next;      //新结点next指向头结点指向的下一个结点 
	tmp_node->prior = (*LHead)->next->prior;     //新结点prior指向头结点（也可以把*LHead->next->prior替换为*LHead）
	(*LHead)->next->prior = tmp_node;     //将原首元结点的prior指向换为新结点 
	(*LHead)->next = tmp_node;        //将头结点next指向新结点
	printf("元素%d 成功插头~\n",e); 
}

//插入到表中间 
Status ListInsert_C(DuLinkList LHead,int n,ElemType e)
{
	DuLNode *tmp_node = (DuLinkList)malloc(sizeof(DuLNode));    //新界结点指针并为之开辟空间 
	DuLNode *p = GetElem(LHead,n);           ///按位序找指针 
//	printf("%d",p->data);
	if(!p) return ERROR;          //如果返回指针有误就结束插入操作 
	tmp_node->data = e;              //新结点输入数据 
	tmp_node->next = p;              //新结点next指针指向查找原位置指针p 
	tmp_node->prior = p->prior;     //新结点prior指向原位置结点的prior的指针 
	p->prior->next = tmp_node;        //原位p结点的上一个结点的next指向新结点 
	p->prior = tmp_node;                //原位置结点的prior指向新结点 
	printf("元素%d 成功插入中间~\n",e);
	return OK;
}

//插入  整合了头尾中间 
Status ListInsert(DuLinkList *LHead,int n,ElemType e)
{
	DuLNode *tmp_node;                 //新结点指针 
	if(n==1) ListInsert_H(LHead,e);    //首先判断插入位置为1则是查到链头，所以用插头ListInsert_H 
	tmp_node = GetElem(*LHead,n);       //按位找该位置结点指针  
	if(!tmp_node) return ERROR;       //返回结点有误则结束 
	if(tmp_node->next == *LHead) ListInsert_R(LHead,e);       //如果该位置是链尾直接用插尾函数插入 
	ListInsert_C(*LHead,n,e);     //‘剩下的就是插中间 
	return OK;   
}

//删除 
Status ListDetele(DuLinkList *LHead,int n)
{
	int i;
	DuLNode *tmp_node;
	tmp_node = (*LHead)->next;  //指向首元结点
	for(i=1;i<n;i++)
		tmp_node = tmp_node->next;         //for循环遍历查找第n个结点 
	tmp_node->next->prior = tmp_node->prior;    //第n个结点后一个的prior指向第n前一个结点指针 
	tmp_node->prior->next = tmp_node->next;        //同理，第n个前一个next指针指向第n个结点后一个 
	free(tmp_node);    //释放第n结点的内存单元空间 
	printf("成功删除位置%d的元素~\n",n); 
}

//合并  A链合并到B链 
Status Union(DuLinkList *LHead_a,DuLinkList *LHead_b)
{
	if(((*LHead_a)->next == *LHead_a) || ((*LHead_b)->next == *LHead_b)) return ERROR;
	(*LHead_a)->prior->next = (*LHead_b)->next;   //A链链尾next指向B链首元结点
	(*LHead_b)->next->prior = (*LHead_a)->prior;     //B链链头prior与A链链尾相连 
	(*LHead_a)->prior = (*LHead_b)->prior;   //A链头结点prior与B链链尾相连 
	(*LHead_b)->prior->next = *LHead_a;  //B链尾结点next指向A链头结点 
	free(*LHead_b);   //释放B链头结点内存单元 
	free(LHead_b);     //释放B链头指针 
}
 
//测试
int main()
{
	DuLinkList LHead_a,LHead_b;   //定义两条链的头指针 
	printf("------头插法---------\n");
	CreateList_H(&LHead_a,3);
	print(LHead_a);
	printf("\n------尾插法--------\n");
	CreateList_R(&LHead_b,3);
	print(LHead_b);
	printf("\n------链表合并------\n");
	Union(&LHead_a,&LHead_b);
	print(LHead_a);
	printf("\n---头插法插入 10---\n");
	ListInsert_H(&LHead_a,10);
	print(LHead_a);
	printf("\n---尾插法插 5---\n");
	ListInsert_R(&LHead_a,5);
	print(LHead_a);
	printf("\n------按位查找------\n");
	DuLNode *p = GetElem(LHead_a,2);
	printf("第二个结点数据: %d\n",p->data);
	printf("\n---插入 100 到链表中间---\n");
	ListInsert(&LHead_a,4,100);
	print(LHead_a); 
	printf("\n-----链表删除--------\n");
	ListDetele(&LHead_a,2);
	print(LHead_a); 
 }
柘月十七
关注
专栏目录
C语言实现双向循环链表
f1443369600的博客
09-24 1962
C语言实现双向循环链表 一、双向循环链表的结构 以三个节点为例，双向循环链表结构如上图所示。每个节点都分为数据域和指针域，数据域是存储数据的；指针域存储前向指针和后向指针，前向指针指向该节点的上一个节点，后向指针指向该节点的下一个节点。循环链表是指首尾要相连，即第一个节点的前向指针指向最后一个节点，最后一个节点的后向指针指向第一个节点，形成一个环。 二、实现一个双向循环链表 1. 首先创建一个双...
c语言_数据结构_双向循环链表
SahPah的专栏
08-13 2037
双向循环链表与单向循环链表的区别在于，每个节点的指针域中除了有指向下一结点的next指针外，还有指向前一结点的prev指针：   在链表中，中间部分结点的next指针指向其直接后继结点，prev指针指向其直接前继结点。与单向循环链表相同，末结点的next指针不再指向NULL,而是指向头结点Head，而头结点的prev则指向末结点。 将新结点new插入到p所指向的结点之后：
c语言双向循环链表
weixin_33694172的博客
06-07 92
双向循环链表,先来说说双向链表,双向链表也叫双链表,是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点.而循环链表之前也有说过,单链表中就是让最后一个结点的指针指向第一个结点就能构成一个循环链表,这里其实也是一样的,只不过多了一步,让第一个结点的前驱指向最后一个结点就行了,(这里介绍的是带头结点的...
C语言实现双向链表、循环链表
最新发布
weixin_45310246的博客
07-22 205
【代码】C语言实现双向链表、循环链表。
C语言演示链表操作.rar_C语言_双向循环链表_数据结构_链表 list_链表操作
09-19
学习和掌握链表操作，尤其是双向循环链表，对于理解和编写复杂的数据结构和算法至关重要，这对于软件开发人员来说是必不可少的技能。在实际应用中，链表常用于实现如队列、栈、哈希表等高级数据结构，以及解决各种...
C语言数据结构之双向循环链表的实例
08-30
C语言数据结构之双向循环链表的实例 在计算机科学中，链表是一种常用的数据结构，它可以动态地分配内存来存储数据，且可以随机访问和插入、删除数据。双向循环链表是一种特殊的链表，它可以同时在链表的头部和尾部...
数据结构——双向循环链表（C语言实现）
GDYJLXQ的博客
10-22 353
双向循环链表：结构复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势。
C语言中双向链表和双向循环链表详解
08-30
本文主要介绍了C语言中双向链表和双向循环链表的实现与操作，包括双向链表和双向循环链表的定义、初始化、插入操作、删除操作等。 一、双向链表和双向循环链表的定义 在C语言中，双向链表是一种数据结构，具有前驱...
【数据结构-C语言】双向循环链表
sakura0908的博客
03-02 1610
对链表而言，双向均可遍历是最方便的，另外首尾相连循环遍历也可打打增加链表操作的便捷性。因此，双向循环链表，是在实际运用中最常见的链表形态。
C语言实现双向循环链表[下]
believe的专栏
11-10 2269
本次实现的是带有头结点的双向循环链表。此文参考了百度文库中的内容。 其基本操作有14个。 typedef struct DuLNode { ElemType data; DuLNode *prior,*next; }DuLNode,*DuLinkList; //函数声明 void InitList(DuLinkList *L);//初始化链表 void ClearList(
c语言实现--双向循环链表操作
weixin_30767835的博客
12-01 82
1，双向链表相当于两个单向循环链表。 2，双向链表的结点定义。 1 struct DULNode 2 { 3 int data; 4 struct DULNode * prior; 5 struct DULNode * next; 6 }; 7 8 typedef struct DULNode * linklist; 3，单循环链...
循环链表c语言csdn,C语言实现双向循环链表
weixin_33656211的博客
05-20 150
在之前的文章中，我写过一篇关于C语言实现双向链表的博文，下面是链接：双向链表介绍了双向链表的实现过程以及双向链表的优势，接下来我首先给大家介绍一下循环链表和双向链表的区别，之后再给大家介绍双向循环链表的具体实现。循环链表和双向链表的区别1、最后一个结点指针指向不同在建立一个循环链表时，必须使其最后一个结点的指针指向表头结点，而不是像双向链表那样置为NULL。此种情况还用于在最后一个结点后插入一个新...
双向循环链表C语言
qq_18431031的博客
03-01 166
#include <stdio.h> #include <stdlib.h> struct doubleList { int data; struct doubleList* front; struct doubleList* rear; }; struct doubleList* createList() { struct doubleList* headNode...
c语言下的双向循环链表
qq_41256954的博客
04-01 642
二.双向循环链表 1.概念 双向循环链表的节点包含一个数据域，两个指针域，一个指针域指向上一个节点，另一个指针域指向下一个节点 这样双向循环链表构成了两个相反方向遍历的圆环 双向循环链表与单链表相比，提高了访问的效率，也付出了多维护一个指针的代价 双向循环链表的插入和删除操作比单向链表复杂，查找和修改和单向链表的算法一样 2.排序 对于链表的排序一般使用插入法排序 （1）取出一个元素，自然有序 ...
c语言之双向循环链表
qq_41555580的博客
05-03 197
//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语言实现双向循环链表的教学示例。通过这个资源，学生和开发者可以学习到数据结构中链表的概念、特点以及如何在C语言环境下使用TC2.0编译器进行链表操作。资源包含了完整的代码文件...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值