王道数据结构——双链表、循环双链表实现

已于 2022-05-07 16:25:39 修改
阅读量820 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： 链表 数据结构 c++
于 2022-05-02 10:54:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42242452/article/details/124538017
版权

文章目录

ADT抽象数据类型

ADT 双链表(DoubleLinkList)
Data
	同线性表。元素具有相同的类型，相邻的元素具有前驱和后继关系。

Operation
	InitDLinkList(DLinkList &L);//初始化双链表
	CreateDList(DLinkList &L);//尾插法创建双链表
	PrintByOrderASC(DLinkList &L);//顺序打印双链表
	PrintByOrderDESC(DLinkList &L);//逆序打印双链表
	InsertByNextNode(Dnode *p,Dnode *s);//双链表的后插
	DListInsert(DLinkList &L, int i,ElemType e);//双链表的插入
	DeleteNextDnode(Dnode *p);//删除双链表的下一个结点
	DListDelete(DLinkList &L,int i,ElemType &e);//双链表的删除
	DestoryDList(DLinkList &L);//双链表的销毁
	

endADT

双链表的结构体定义

/* 相比单链表，也就多了一个头指针而已*/
typedef int ElemType;

typedef struct Dnode{
	ElemType data;//数据域
	struct Dnode * prior; //前驱指向 
	struct Dnode * next; //后驱指向 
}Dnode,*DLinkList;

双链表的初始化

/**
	初始化双链表 
*/

bool InitDLinkList(DLinkList &L) {
	L=(Dnode *)malloc(sizeof(Dnode)) ;//申请一个头结点 
	//初始化内存失败 
	if(L==NULL)return false;
	
	L->prior=NULL;//头结点的prior 永远指向NULL 
	L->next=NULL;
	
	return true;
}

双链表的创建——尾插法

尾插法和头插法与单链表的处理差不多，唯一的区别在于双链表多了一个头指针处理。头插法就不给出具体代码实现了。

/* 尾插法创建双链表 */
DLinkList CreateDList(DLinkList &L) {
	L=(Dnode *)malloc(sizeof(Dnode));//申请第一个结点 
	if(L!=NULL){
		L->prior=NULL; 
		L->next=NULL;
	}
	Dnode *s, *r=L;
	int x;
	cin>>x;
	while(x!=9999){
		s=(Dnode *)malloc(sizeof(Dnode));
		s->data=x;
		r->next=s;
		s->prior=r;//相比单链表，就多了一个指向r的前指针指向 
		r=s;
		cin>>x;
	}
	r->next=NULL;//最后一个结点指向为空
	
	return L; 
}

打印双链表

/*顺序打印双链表，跟单链表是一样的*/
void PrintByOrderASC(DLinkList &L){
	Dnode *p=L->next;//从第一个结点开始输出 
	while(p){//这样输出，导致当前的p可能为NULL 
		
		cout<<p->data<<" ";
		p=p->next;
	}
	cout<<endl;
}

/*逆序打印双链表，扫描到最后一个结点，再利用前驱结点倒回去*/
void PrintByOrderDESC(DLinkList &L){
	Dnode *p=L;
	while(p->next!=NULL){
		p=p->next;
	}
	
	while(p!=L){
		cout<<p->data<<" ";
		p=p->prior;
	}
	cout<<endl;
}

按值查找，按位查找，返回双链表的长度与单链表没有差别，这里也不给出具体的代码实现了。

双链表的后插

/**
	双链表的后插 
	如果p结点是最后一个结点，则需要增加判断条件之后再执行3 
	以下四步，如果顺序乱了，会出现断链或者自己指向自己的情况
	比如1,4变成了4,1 
	 
*/
bool InsertByNextNode(Dnode *p,Dnode *s){
	
	if(p==NULL||s==NULL) return false;
	//1.结点s的后继指向为p的后继结点 
	s->next=p->next;
	//2.p的后继结点的前指向修改为s 
	if(p->next!=NULL)//当p不是最后一个结点时
		p->next->prior=s;
	//3.s的前指向更改为p 
	s->prior=p;
	//4.p的后继指向更改为s 
	p->next=s;
	
	return true;
}

双链表的插入

/*前插,找到i-1,也可以后插*/
bool DListInsert(DLinkList &L, int i,ElemType e){
	if(i<1)	{
		cout<<"插入的位置有误!"<<endl;
		return false;
	}
	
	Dnode *p=L,*s;//从头结点开始遍历 
	int j=0;//从头结点开始遍历 
	while(p!=NULL&&j<i-1){
		p=p->next;
		j++;
	}
	
	s=(Dnode *)malloc(sizeof(Dnode)) ;
	s->data=e;
	InsertByNextNode(p,s);
}

删除双链表的下一个节点

/*删除双链表的下一个结点*/
bool DeleteNextDnode(Dnode *p){
	if(p==NULL)return false;

	Dnode *q=p->next;//q为p的后继结点
	if(q==NULL)//如果q为空，即p为双链表的最后一个结点
		return false;
		
	//不为空则将p的后继结点更改为q的后继结点	
	p->next=q->next;
	if(q->next!=NULL) //如果q不为最后一个结点
		q->next->prior=p;// q的后继结点的前驱指向p结点 
		
	free(q) ;//释放q结点

	return true; 	
}

双链表的删除

/*删除双链表的元素，并用e带回*/
bool DListDelete(DLinkList &L,int i,ElemType &e){
	if(i<1)	{
		cout<<"删除结点有误!" <<endl;
		return false;
	}
	Dnode *p=L;
	int j=0;//从头结点开始定位
	while(p!=NULL&&j<i-1) {
		p=p->next;
		j++;
	}
	
	//DeleteNextDnode(p);
	if(p==NULL)return false;//链表长为5，用户删除第7个元素，如果从第六个往后都为空 

	Dnode *q=p->next;//当前定位的结点，所要删除的结点 
	if(q==NULL)//如果q为空，即p为双链表的最后一个结点
		return false;
		
	//不为空则将p的后继结点更改为q的后继结点	
	p->next=q->next;
	if(q->next!=NULL) //如果q不为最后一个结点
		q->next->prior=p;// q的后继结点的前驱指向p结点 
	
	e=q->data;//带回所要删除的对象数据	
	free(q) ;//释放q结点
	return true;
	
}

双链表的销毁

/* 销毁双链表 */
void DestoryDList(DLinkList &L){
	while(L->next!=NULL){
		DeleteNextDnode(L);
	}
	free(L)	;//释放头结点 
	L=NULL;//头指针指向NULL 
}

循环双链表的初始化

/*初始化循环双链表*/
bool InitiDList(DLinkList &L){
	L=(Dnode *)malloc(sizeof(Dnode));
	if(L==NULL)return false;//初始化空间失败
	
	L->prior=L;//头指针指向自己 
	L->next=L;//尾指针指向自己
	//初始化，头尾指针都指向自己，自己抱着自己 
	return true;
}

循环双链表判空

/*判断循环双链表是否为空*/
bool IsEmpty(DLinkList &L){
	return (L->next==L)?true:false;
}

循环双链表判断表尾结点

/*判断节点p是否为循环双链表的表尾节点*/ 
bool isTrail(DLinkList &L, Dnode *p){
	return(p->next==L)?true:false;
}

后插

bool InsertByNextNode(Dnode *p,Dnode *s){
	

	//1.结点s的后继指向为p的后继结点 
	s->next=p->next;
	//2.p的后继结点的前指向修改为s 

	p->next->prior=s;
	//3.s的前指向更改为p 
	s->prior=p;
	//4.p的后继指向更改为s 
	p->next=s;
	
	return true;
}

删除下一个节点

/*删除循环双链表的下一个结点*/
bool DeleteNextDnode(Dnode *p){
	if(p==NULL)return false;
	Dnode *q=p->next;//q为p的后继结点
	//不为空则将p的后继结点更改为q的后继结点	
	p->next=q->next;
	q->next->prior=p;// q的后继结点的前驱指向p结点 
	free(q) ;//释放q结点
	return true; 	
}

后插和删除下一个节点在双链表和循环双链表之间区别在于循环双链表不需要判断后继节点是否为空，其他的一致。由于双链表跟循环双链表之间的区别，仅仅在于尾指针的指向是否是L，其它的代码实现方式跟双链表相差不多，仅在于尾指针的处理，所以，下面只给出了双链表的具体实现。

代码实现—双链表

#include<iostream>
#include<stdlib.h> 
using namespace std;

typedef int ElemType;

typedef struct Dnode{
	ElemType data;//数据域
	struct Dnode * prior; //前驱指向 
	struct Dnode * next; //后驱指向 
}Dnode,*DLinkList;


/**
	初始化双链表 
*/

bool InitDLinkList(DLinkList &L) {
	L=(Dnode *)malloc(sizeof(Dnode)) ;//申请一个头结点 
	//初始化内存失败 
	if(L==NULL)return false;
	
	L->prior=NULL;//头结点的prior 永远指向NULL 
	L->next=NULL;
	
	return true;
}



/**
	双链表的插入 
	如果p结点是最后一个结点，则需要增加判断条件之后再执行3 
	以下四步，如果顺序乱了，会出现断链或者自己指向自己的情况
	比如1,4变成了4,1 
	 
*/
bool InsertByNextNode(Dnode *p,Dnode *s){
	
	if(p==NULL||s==NULL) return false;
	//1.结点s的后继指向为p的后继结点 
	s->next=p->next;
	//2.p的后继结点的前指向修改为s 
	if(p->next!=NULL)//当p不是最后一个结点时
		p->next->prior=s;
	//3.s的前指向更改为p 
	s->prior=p;
	//4.p的后继指向更改为s 
	p->next=s;
	
	return true;
}

/*
	s->next = p->next;
	p->next->prior = s;//要判断当前的p结点是不是最后一个结点 
	p->next = s;
	s->prior = p;
*/


/*前插,找到i-1,也可以后插*/
bool DListInsert(DLinkList &L, int i,ElemType e){
	if(i<1)	{
		cout<<"插入的位置有误!"<<endl;
		return false;
	}
	
	Dnode *p=L,*s;//从头结点开始遍历 
	int j=0;//从头结点开始遍历 
	while(p!=NULL&&j<i-1){
		p=p->next;
		j++;
	}
	
	s=(Dnode *)malloc(sizeof(Dnode)) ;
	s->data=e;
	InsertByNextNode(p,s);
}


/* 尾插法创建双链表 */
DLinkList CreateDList(DLinkList &L) {
	L=(Dnode *)malloc(sizeof(Dnode));//申请第一个结点 
	if(L!=NULL){
		L->prior=NULL; 
		L->next=NULL;
	}
	Dnode *s, *r=L;
	int x;
	cin>>x;
	while(x!=9999){
		s=(Dnode *)malloc(sizeof(Dnode));
		s->data=x;
		r->next=s;
		s->prior=r;//相比单链表，就多了一个指向r的前指针指向 
		r=s;
		cin>>x;
	}
	r->next=NULL;//最后一个结点指向为空
	
	return L; 
}

/*顺序打印双链表，跟单链表是一样的*/
void PrintByOrderASC(DLinkList &L){
	Dnode *p=L->next;//从第一个结点开始输出 
	while(p){//这样输出，导致当前的p可能为NULL 
		
		cout<<p->data<<" ";
		p=p->next;
	}
	cout<<endl;
}

/*逆序打印双链表，扫描到最后一个结点，再利用前驱结点倒回去*/
void PrintByOrderDESC(DLinkList &L){
	Dnode *p=L;
	while(p->next!=NULL){
		p=p->next;
	}
	
	while(p!=L){
		cout<<p->data<<" ";
		p=p->prior;
	}
	cout<<endl;
}

/*删除双链表的下一个结点*/
bool DeleteNextDnode(Dnode *p){
	if(p==NULL)return false;

	Dnode *q=p->next;//q为p的后继结点
	if(q==NULL)//如果q为空，即p为双链表的最后一个结点
		return false;
		
	//不为空则将p的后继结点更改为q的后继结点	
	p->next=q->next;
	if(q->next!=NULL) //如果q不为最后一个结点
		q->next->prior=p;// q的后继结点的前驱指向p结点 
		
	free(q) ;//释放q结点

	return true; 	
}

/* 销毁双链表 */
void DestoryDList(DLinkList &L){
	while(L->next!=NULL){
		DeleteNextDnode(L);
	}
	free(L)	;//释放头结点 
	L=NULL;//头指针指向NULL 
}

/*删除双链表的元素，并用e带回*/
bool DListDelete(DLinkList &L,int i,ElemType &e){
	if(i<1)	{
		cout<<"删除结点有误!" <<endl;
		return false;
	}
	Dnode *p=L;
	int j=0;//从头结点开始定位
	while(p!=NULL&&j<i-1) {
		p=p->next;
		j++;
	}
	
	//DeleteNextDnode(p);
	if(p==NULL)return false;//链表长为5，用户删除第7个元素，如果从第六个往后都为空 

	Dnode *q=p->next;//当前定位的结点，所要删除的结点 
	if(q==NULL)//如果q为空，即p为双链表的最后一个结点
		return false;
		
	//不为空则将p的后继结点更改为q的后继结点	
	p->next=q->next;
	if(q->next!=NULL) //如果q不为最后一个结点
		q->next->prior=p;// q的后继结点的前驱指向p结点 
	
	e=q->data;//带回所要删除的对象数据	
	free(q) ;//释放q结点
	return true;
	
}

int main(){
	DLinkList L;
	InitDLinkList(L);
	CreateDList(L);
	PrintByOrderASC(L);
	
	cout<<"在第3个位置插入3:";
	DListInsert(L,3,3);
	PrintByOrderASC(L);
	
	int e;
	DListDelete(L,5,e);
	cout<<"删除第五个结点，第五个结点的值为:"<<e<<endl;
	cout<<"顺序输出最后结果为:";
	PrintByOrderASC(L);
	cout<<"逆序输出最后结果为:";
	PrintByOrderDESC(L);
	
}


运行结果:
1 2 3 4 5 9999
1 2 3 4 5
在第3个位置插入3:1 2 3 3 4 5
删除第五个结点，第五个结点的值为:4
顺序输出最后结果为:1 2 3 3 5
逆序输出最后结果为:5 3 3 2 1
舞狮式电流
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——双向循环链表
wry_sunny_的博客
03-15 679
双向循环链表是一种链式存储结构，它的最后一个结点指向头结点，形成一个环。因此，从循环链表中的任何一个结点出发都能找到任何其他结点。双向循环链表的操作和双向链表的操作基本一致，差别仅仅在于算法中的循环条件有所不同。双向循环链表的头结点的前驱指向最后一个结点，尾结点的后继指向头结点。 注意：双向循环链表中无其他结点，只有头结点时 ，头结点的前驱和后继度指向自身。 1、双向循环链表的存储结构 t...
数据结构——循环双链表的转置
qq_42242380的博客
07-10 731
我们实现的是一个带头结点的循环双链表，具体方法是设置两个工作指针p、q。p从第一个节点开始从头到尾进行遍历，而q从最后一个结点开始从未到头依次遍历。两个指针同时移动，每移动一次就进行一次数据元素的交换。 核心代码如下： void d() //循环双链表的倒置 { List *p = head->next, *q = head->pr...
王道数据结构（循环双链表）
m0_64008087的博客
05-03 138
【代码】王道数据结构（循环双链表）
王道数据结构精简笔记——双链表
weixin_53830825的博客
07-11 107
双链表不可随机存取，按位查找、按值查找操作都只能用遍历的方式实现。
408-王道-双向链表
m0_56553975的博客
11-21 219
双向链表
王道数据结构——循环双链表（双向循环链表）
UncleJokerly
08-05 209
循环双链表（双向循环链表）
王道考研数据结构之------循环双链表操作
liquid_road的博客
08-10 152
链接： 王道2021数据结构链接 提取码：rpy8 –来自百度网盘超级会员V4的分享 #include <stdio.h> #include <stdlib.h> typedef int ElemType typedef struct DNode{ ElemType data; struct DNode *prior, *next; }DNode, *DLinkList; //初始化空的循环双链表10 05:07 bool InitDlinkList(DlinkList &
王道考研——数据结构PPT.zip
08-21
2. **线性结构**：线性结构包括数组、链表（单链表、双链表、循环链表）、栈和队列。PPT会详细介绍这些结构的特性、操作（如插入、删除、查找）以及它们在实际问题中的应用。 3. **数组**：数组是最基础的数据结构...
考研王道数据结构代码.zip
11-26
王道数据结构教材以其清晰易懂的讲解和丰富的例题著称，其配套的可执行代码可以帮助学生更直观地理解各种数据结构的实现细节和操作过程。这些代码可能包括链表、数组、栈、队列、树、图、散列表等各种经典数据结构的...
王道数据结构.zip
05-13
《王道数据结构》是针对计算机科学与技术专业考研学子的重要参考资料，主要涵盖了数据结构的基础理论、算法设计以及分析等内容。这份压缩包包含了2019年和2020年的版本，无水印，适合考生们进行系统的学习和复习。 ...
王道考研数据结构PPT
01-12
王道考研数据结构PPT是专为准备考研的学生设计的一套教学资料，涵盖了数据结构的主要概念、原理和算法。下面将详细阐述其中可能包含的知识点。 1. **基本概念**：首先，你需要理解什么是数据结构，它是指数据的组织...
王道数据结构课后选填汇总
02-19
本汇总主要基于"王道数据结构"教材，旨在为考研复习提供帮助，特别是针对那些正在二刷数据结构的学生。下面将对第二章和第三章的主要知识点进行详尽的解析。 第二章通常涵盖线性结构，特别是数组和链表这两种基本的...
王道数据结构 双链表 ★★★★★
旅途
06-16 4080
c语言数据结构之双链表
考研数据结构（王道版）：循环双链表上基本操作的实现(C语言）
知且行的博客
01-20 789
循环双链表： 与单链表相比，双链表的优势就是可以双向操作链表，在单链表中只能从表头节点开始往后顺序遍历整个链表，而循环双链表可以从表中任意节点遍历。其缺点就是 由于一个不仅有头指针，而且存在尾指针，相比于单链表来说就比较浪费存储空间。 循环双链表代码实现： #include <stdio.h> #include <stdlib.h> #include <mat...
王道数据结构 | 双链表
fengganyuHL的博客
05-15 556
王道数据结构 | 双链表及其操作
《王道》第11章 链表之双链表
南方有乔木的博客
04-11 384
《王道》第11章 链表之双链表 目录 1.双链表的插入(以插入到p结点前为例) 2.双链表的删除 3.代码 4.补充 1.双链表的插入(以插入到p结点前为例) 第一步：首先找到插入位置，节点 s 将插入到节点 p 之前 第二步：将节点 s 的前驱指向节点 p 的前驱，即 s->prior = p->prior; ...
王道——双链表
下次再说的博客
03-15 145
* *下次再说 *
2022 数据结构与算法《王道》学习笔记 （六）双链表
小超嵌入式笔记
03-05 384
数据结构与算法系列文章目录 本文内容摘自《王道数据结构》，经自我总结后做成笔记，供学习参考用。 本文部分图片摘自博文 文章目录数据结构与算法系列文章目录前言1、双链表的插入操作2.双链表的删除操作3.静态链表4.顺序表和链表的比较 前言 单链表结点中只有一个指向其后继的指针，使得单链表只能从头结点依次顺序地向后遍历。要访问某个结点的前驱结点（插入、删除操作时），只能从头开始遍历，访问后继结点的时间复杂度为O(1)，访问前驱结点的时间复杂度为O(n)。 为了克服单链表的上述缺点，引入双链表，双链表结点中
数组算法--基本查找
最新发布
2303_78660417的博客
07-20 279
基本查找就是从数组的0索引处开始，依次往后查找，如果找到了对应索引处的值，就会，如果没有找到。因为数组的索引号是没有-1的，当返回-1的时候，就能明白没有找到。
2022王道数据结构考研复习指南
"2022王道数据结构去水印.pdf" 本书《2022年数据结构考研复习指导》是王道论坛组编的一本针对计算机专业研究生入学考试“数据结构”科目的复习教材。内容涵盖了数据结构课程的基础知识和重要概念，包括但不限于绪论...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值