数据结构——双向循环链表（声明、初始化、增加、删除、搜索修改、顺序逆序遍历）

已于 2022-07-12 22:48:51 修改
阅读量745 收藏 5
点赞数
分类专栏： 数据结构 文章标签： 链表 数据结构 c++ c语言 算法
于 2022-07-12 13:51:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51231048/article/details/125741113
版权

以下是数据结构中双向循环链表的声明、初始化、增加节点、删除节点、插入节点、搜索节点的基本操作：

声明链表

typedef struct LNode{
	int data;
	LNode *next;
	LNode *pre;
}Lnode,*LinkList;

每一个节点有三个属性分别是
data：数据；
*next：下一个节点的地址；
*pre：上一个节点的地址。

初始化链表

void initial(LinkList &List){//指针的指针
	List = new Lnode;
	List->next = List;
	List->pre = List;
	List->data = 0;
	cout<<"循环链表创建完毕(首结点data:0)"<<endl; 
}

因为是双向链表，首节点的后继节点和前驱节点都是自己本身。

增加节点

void addNode(Lnode *&List,int data){
	LNode *p = List;
	LNode *start = List;//标记起点 
	while(p->next!=start){
		p = p->next;
	}
	LNode *newnode = new LNode;//尾插新节点 
	newnode->next = start;//尾节点 后继为 首节点 
	start->pre = newnode;//首节点的 前驱为 尾节点 （此处容易遗漏，要注意） 
	newnode->data = data; 
	p->next = newnode;//将尾节点接到链表末尾 
	newnode->pre = p;// 双向连接 
	
}

void add(Lnode *&List){
	int c;
	while(1){
		cout<<"请输入新增节点的data(输入0停止新增):"; 
		cin>>c;
		if(c==0){
			break;
		}
		addNode(List,c);
	}
	cout<<"节点新增完成!";
	showList(List); 
}

步骤如下：
1、声明新节点
2、将链表尾节点的后继由首节点更换为新节点；
3、新节点的后继设为尾节点；
4、将首节点的前驱设为新节点；
5、将新节点的前驱设为之前的尾节点（此时新节点成为新的尾节点）。

删除节点

void delNode(Lnode *&List,int index){
	LNode *p = List;
	LNode *s = List;
	int i = 0;
	while(i+1<index && p->next->next!=s->next){
		i++;
		p = p->next;
	}
	if(i+1<index){
		cout<<"超出循环链表长度"<<endl; 
	}else{
		Lnode *t = new Lnode;
		t = p->next;
		p->next = t->next;
		t->next->pre = p;
		delete t;
	}
}
void del(Lnode *&List){
	int index;
	cout<<"请输入要删除的元素下标（从1开始）:";
	cin>>index;
	delNode(List,index);
	showList(List);
}

步骤：
1、根据下标开始遍历；
2、p->next->next!=s->next目的有两个：
2.1：是让p可以顺利遍历到最后一个元素（如果只写p->next!=s会导致当p遍历到最后一个节点时就跳出循环，删除不了最后一个节点）；
2.2：在到达被删除的节点前一个节点就要开始准备删除工作，否则p到达被删除的节点时会导致删除该节点后后段链表接不上前段链表（即导致链表断裂）
3、声明中间变量节点（被删除的节点）；
4、被删节点的前一个节点的后继节点变为被删节点的后继节点；
5、被删节点的后继的前驱节点设为被删节点的前驱节点；

插入节点

void insertNode(Lnode *&List,int index){
	int i = 1; 
	LNode *p = List;
	Lnode *start = List;
	while(p->next != start && i < index){ 
		i++;
		p = p->next;
	}
	if(i<index || p->next == start){
		cout<<i<<endl;
		cout<<"插入位置超出链表长度!";
	}else{
		LNode *newnode = new LNode;
		newnode->next = p->next;
		newnode->pre = p;
		p->next->pre = newnode;
		int data;
		cout<<"请输入新节点的data:";
		cin>>data;
		newnode->data = data;
		p->next = newnode;
	}
} 

void insert(Lnode *&List){
	cout<<"请输入插入数据的位置(从1开始算):";
	int index;
	cin>>index;
	insertNode(List,index);
	cout<<"节点插入完成!";
	showList(List);
}

步骤：
1、到达插入位置前一个位置指针p停止移动；
2、设置新节点；
3、将新节点的前驱设为p，
4、将新节点的后继设为p的后继，
5、将p的后继设为新节点；
注意：3、4、5的顺序不能随意改变，如果先执行5，会导致新节点的后继是新节点本身。

搜索（修改）节点

void searchNode(LinkList &List, int data){
	LinkList p = List->next;//从头结点的下一个节点开始搜索 
	LinkList start = List;//首地址 
	int index = 1;
	int flat = 1;
	while(p!=start){
		if(p->data == data){
			cout<<"查找成功!第"<<index<<"个节点data为"<<data<<endl;
			flat = 0;
			//此处不设置跳出是为了查询相同元素的全部下标位置
			//如果只需要查询第一次出现的位置，在此处设置跳出循环即可 
		}
		p = p->next;
		index++;
	}
	if(flat){
		cout<<"No data '"<<data<<"' in this list!"<<endl; 
	}
}

void search(LinkList &List){
	int data;
	cout<<"请输入要查找的data:";
	cin>>data;
	searchNode(List,data);
}

特别说明：此处的指针从首节点的下一个地址开始搜索。

顺序与逆序遍历双向循环链表

void showList(LinkList &List){//等价于LNode *&List
	LNode *p = List;
	LNode *start = List;
	int index = 0;
	cout<<"当前链表信息:"<<endl;
	cout<<"顺序:"<<endl;
	cout<<"(首节点)"<<p->data<<"<-->";
	p = p->next; 
	while(p!=start){
		cout<<p->data<<"<-->";
		p = p->next;
	}
	cout<<p->data<<"(首节点)"<<endl;
//	**************************************//
	p = List;//重置p指针的位置 
	cout<<"逆序:"<<endl;
	cout<<"(首节点)"<<p->data<<"<-->";
	p = p->pre; 
	while(p!=start){
		cout<<p->data<<"<-->";
		p = p->pre;
	}
	cout<<start->data<<"(首节点)"<<endl;
}

注意：逆序的时候记得将p指针的地址重新设置回链表头部。

完整源代码

/*
		广西师范大学 计算机科学与工程学院 
		GuangXi Normal University College of Computer Science and Engineering  
		Student STZ 
*/ 
#include<iostream>
#include<stdio.h>
using namespace std;

typedef struct LNode{
	int data;
	LNode *next;
	LNode *pre;
}Lnode,*LinkList; 

void initial(LinkList &List){//指针的指针
	List = new Lnode;
	List->next = List;
	List->pre = List;
	List->data = 0;
	cout<<"循环链表创建完毕(首结点data:0)"<<endl; 
}

void showList(LinkList &List){//等价于LNode *&List
	LNode *p = List;
	LNode *start = List;
	int index = 0;
	cout<<"当前链表信息:"<<endl;
	cout<<"顺序:"<<endl;
	cout<<"(首节点)"<<p->data<<"<-->";
	p = p->next; 
	while(p!=start){
		cout<<p->data<<"<-->";
		p = p->next;
	}
	cout<<p->data<<"(首节点)"<<endl;
//	**************************************//
	p = List;//重置p指针的位置 
	cout<<"逆序:"<<endl;
	cout<<"(首节点)"<<p->data<<"<-->";
	p = p->pre; 
	while(p!=start){
		cout<<p->data<<"<-->";
		p = p->pre;
	}
	cout<<start->data<<"(首节点)"<<endl;
}

void addNode(Lnode *&List,int data){
	LNode *p = List;
	LNode *start = List;//标记起点 
	while(p->next!=start){
		p = p->next;
	}
	LNode *newnode = new LNode;//尾插新节点 
	newnode->next = start;//尾节点 后继为 首节点 
	start->pre = newnode;//首节点的 前驱为 尾节点 （此处容易遗漏，要注意） 
	newnode->data = data; 
	p->next = newnode;//将尾节点接到链表末尾 
	newnode->pre = p;// 双向连接 
	
}

void add(Lnode *&List){
	int c;
	while(1){
		cout<<"请输入新增节点的data(输入0停止新增):"; 
		cin>>c;
		if(c==0){
			break;
		}
		addNode(List,c);
	}
	cout<<"节点新增完成!";
	showList(List); 
}
void delNode(Lnode *&List,int index){
	LNode *p = List;
	LNode *s = List;
	int i = 0;
	while(i+1<index && p->next->next!=s->next){
		i++;
		p = p->next;
	}
	if(i+1<index){
		cout<<"超出循环链表长度"<<endl; 
	}else{
		Lnode *t = new Lnode;
		t = p->next;
		p->next = t->next;
		t->next->pre = p;
		delete t;
	}
}
void del(Lnode *&List){
	int index;
	cout<<"请输入要删除的元素下标（从1开始）:";
	cin>>index;
	delNode(List,index);
	showList(List);
}

void insertNode(Lnode *&List,int index){
	int i = 1; 
	LNode *p = List;
	Lnode *start = List;
	while(p->next != start && i < index){ 
		i++;
		p = p->next;
	}
	if(i<index || p->next == start){
		cout<<i<<endl;
		cout<<"插入位置超出链表长度!";
	}else{
		LNode *newnode = new LNode;
		newnode->next = p->next;
		newnode->pre = p;
		p->next->pre = newnode;
		int data;
		cout<<"请输入新节点的data:";
		cin>>data;
		newnode->data = data;
		p->next = newnode;
	}
} 

void insert(Lnode *&List){
	cout<<"请输入插入数据的位置(从1开始算):";
	int index;
	cin>>index;
	insertNode(List,index);
	cout<<"节点插入完成!";
	showList(List);
}

void searchNode(LinkList &List, int data){
	LinkList p = List->next;//从头结点的下一个节点开始搜索 
	LinkList start = List;//首地址 
	int index = 1;
	int flat = 1;
	while(p!=start){
		if(p->data == data){
			cout<<"查找成功!第"<<index<<"个节点data为"<<data<<endl;
			flat = 0;
			//此处不设置跳出是为了查询相同元素的全部下标位置
			//如果只需要查询第一次出现的位置，在此处设置跳出循环即可 
		}
		p = p->next;
		index++;
	}
	if(flat){
		cout<<"No data '"<<data<<"' in this list!"<<endl; 
	}
}

void search(LinkList &List){
	int data;
	cout<<"请输入要查找的data:";
	cin>>data;
	searchNode(List,data);
}


void menu(LinkList &List){
	int c = 0;
	while(1){
		cout<<"请选择操作:"<<endl;
		cout<<"1:新增节点"<<endl;
		cout<<"2:插入节点"<<endl;
		cout<<"3:删除节点"<<endl;
		cout<<"4:展示节点"<<endl;
		cout<<"5:搜索节点"<<endl;
		cout<<"6:退出系统"<<endl;
		cin>>c;
		switch(c){
			case 1:add(List);break;
			case 2:insert(List);break;
			case 3:del(List);break;
			case 4:showList(List);break;
			case 5:search(List);break; 
			case 6:return;
			default:;
		} 
	}
}

int main(){
	Lnode *List;
	initial(List);
	menu(List);
	return 0;
}

效果图

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

特别说明：本程序仅挑取关于链表的关键操作进行介绍，对于边界问题（如删除头结点）等特殊情况并没有做出处理。

芣苢的成长之路
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
双向链表的初始化删除及其插入操作
10-20
双向链表的初始化删除及其插入操作,欢迎大家下载
线性表——循环双向链表 定义、初始化、插入、删除
wh1236666的博客
10-03 649
#include <stdio.h> #include <crtdbg.h> #include <corecrt_malloc.h> typedef int DataType; 1.定义链表 typedef struct Node { DataType data; struct Node* prior; struct Node* next; }DListNode,*DLinkList; 2.初始化循环链表（双向链表） int ds_init(DListNode
循环双链表的创建初始化
diy_os的专栏
10-15 914
前面对单链表进行了简单的操作，下面是循环双链表的创建初始化： 点击(此处)折叠或打印 #includeiostream> //#includestdlib.h> using namespace std; struct List { int data; struct List *last, *next; };
Java 用双向循环链表实现 遍历
weixin_30908941的博客
09-19 275
package day2;/** * 构建双向循环链表，实现遍历功能 */public class DoubleLB { public static void main(String[] args) { DoubleLB doubleLB = new DoubleLB(); doubleLB.creatCicle(100); doubleL...
循环双向链表的初始化及创建-头插法和尾插法
小陈没烦恼
02-03 2640
什么是循环双向链表？ 为克服单链表的这种单向性特点，在双向链表的结点有两个指针域，一个指向直接后继，另一个指向直接前驱。 循环双向链表的操作 1.初始化 2.头插法创建链表 3.尾插法创建链表 4.打印链表中的所有元素 5.可以把循环单链表和循环双向链表来对比一下来理解。参考文章：循环单链表基本操作 循环双链表的结构 这个地方要区别循环单链表，单链表中只有一个指针域，而循环双链表有两个指针域。 typedef struct DuLNode{ int data; //数...
C语言数据结构之双向循环链表的实例
08-30
主要介绍了C语言数据结构之双向循环链表的实例的相关资料,需要的朋友可以参考下
python实现数据结构中双向循环链表操作的示例
12-16
看此博客之前建议先看看B站的视频python数据结构与算法系列课程，该课程中未实现双向循环链表的操作，所以我按照该视频的链表思路实现了双向循环链表的操作，欢迎大家阅读与交流，如有侵权，请联系博主！ 下面附上...
数据结构算双链表的初始化 插入 删除 遍历 代码
06-02
数据结构算双链表的初始化 插入 删除 遍历 代码
JavaScript数据结构之双向链表和双向循环链表的实现
01-19
双向链表：单向链表只能向着一个方向遍历链表节点，而在节点指针域中增加了前向指针的双向链表，则可以向着两个方向遍历节点。这使得双向链表也可以在任何一个节点遍历整个链表。 function DoublyLinkedList() { ...
链表的创建及相应操作 C语言
qq_43402544的博客
10-03 580
数据结构c语言 链表 通过上篇对线性表顺序存储表示的了解，今天进一步对线性表的链式表示进行尝试。本人小白，不喜勿喷。如有错误之处，还请原谅！ 完整代码如下： #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct LNode { int data;//结点的数据域 struct LNode *next;//结点的指针域 }LNode,*LinkList;//LinkL
【数据结构】双向循环链表的创建、初始化、插入、删除
qq_49828411的博客
01-04 6169
文章目录一、部分实现1.双向循环链式存储结构2.初始化双向循环链表3.使用尾插法插入结点4.插入第i个结点（在第i个结点之前插入）4.删除第i个结点5.遍历双向循环链表6.主函数二、全部代码三、运行结果 一、部分实现 1.双向循环链式存储结构 代码如下： /*链式存储结构*/ typedef struct DuLNode { ElemType data; struct DuLNode* prior; struct DuLNode* next; }DuLNode,*DuLinkList; 2.初
双向链表的双向遍历
A___jay的博客
03-04 3320
双向链表的双向遍历 双向链表相比较于单向链表的优势之一就是可以快速遍历，对于单向链表只能借助于单个指针逐个遍历，而对于双向链表而言因为每个节点都存在一个前指针和后指针，所以可以借助于两个指针双向遍历，相对于单向链表而言可以节省很多时间。但是对于双向链表的双向遍历需要考虑的因素偏多，代码的步骤需要非常严谨。对于两个指针而言需要考虑节点数是奇数还是偶数，若是奇数，要考虑两指针相遇的情况，只需要输出其中...
双向链表遍历
qq_40713201的博客
06-12 386
代码
双向循环链表 初始化 插入 删除
blacop的博客
02-24 717
#include <stdio.h> #include <stdlib.h> #define OK 1 #define ERROR -1 #define TRUE 1 #define FALSE -1 #define NULL 0 #define OVERFLOW -2 #define ElemType int #define Status int typedef int ElemType type
c语言双向循环链表查找,双向循环链表（C语言描述）（五）(示例代码)
weixin_39956353的博客
05-24 104
1 //dictionary.h2 #ifndef __DICTIONARY_H__3 #define __DICTIONARY_H__45 #include 6 #include 7 #include 89 #include "mystring.h"10 #include "linkedlist.h"1112 voiddict_init();13 voiddict_show();1415 #en...
数据结构-双向循环链表
有朋自远方来，不亦乐乎。
08-05 234
通过向 main 函数中调用 initLine 函数，就可以成功创建一个存储有。当问题中涉及到需要 "循环往复" 地遍历表中数据时，就需要使用双向循环链表。单链表通过首尾连接可以构成单向循环链表。数据的双向循环链表，双向链表进行首尾连接。...
双向链表的遍历和生成
如若
05-04 436
双向链表，又称为双链表，是链表的一种，它的每个数据结点都有两个指针，分别指向直接后继和直接前驱。所以，双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。 基本操作： #include <iostream> using namespace std; class Node { public: int dat; Node *pre; Node *next; Node(int val) { dat = val;
【数据结构】循环双向链表定义和基本操作
Z_sea的博客
12-18 1288
循环双向链表： 循环双向链表的定义： typedef struct CDLNode{ LElemType data; struct CDLNode * pre; struct CDLNode * next; CDLNode(LElemType Data=0,struct CDLNode* Pre=NULL,struct CDLNode* Next=NULL){...
双向链表的初始化，建立，添加节点和删除节点（注意插入和删除要分三种情况）
热门推荐
fengsuiyingdong的专栏
12-25 1万+
/*双向循环链表*/ #include "declaration.h" typedef struct DulNode { int data; struct DulNode *next,*prior; }DulNode,*DulLinkList; Status InitList_DUL(DulLinkList &L)//初始化一个带头结点的双向循环链表,ok { L=(DulNode
写一个双向循环链表逆序的代码
最新发布
08-17
双向循环链表是一种链表数据结构，其中每个节点除了指向下一个节点外，还额外指向前一个节点。实现双向循环链表的逆序操作，我们可以按照以下步骤进行： 1. 首先判断链表是否为空，若为空则直接返回原链表。 2. ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

芣苢的成长之路

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值