数据结构-双向链表

已于 2024-03-27 15:06:31 修改
阅读量42 收藏
点赞数
分类专栏： 数据结构 文章标签： 链表 数据结构 c++ 算法 c语言
于 2022-11-03 13:04:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62362934/article/details/127668127
版权

一、main

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <stdio.h>
#include "com.h"
using namespace std;
 
// 1.初始化单链表 
void initlist_l(DuLinkList &L , int &flag) 
{
	if(flag == 1)  
		cout << "\t\t\t链表已存在，不能重复执行该操作" ;
	else 
	{
		if(InitList(L) == OVERFLOW)   
			cout << "\t\t\t操作失败" ;
		else
		{
			cout << "\t\t\t初始化单链表成功！" ;
			flag = 1;
		}
	} 
	cout << endl << endl ;
}
// 2.用头插法输入元素  3.用尾插法输入元素
void createlist_l(DuLinkList &L , int flag , int t)
{
	int n ;
	cout << "\t\t\t请输入待输入元素个数：" ;
	cin >> n ;  cout << "\t\t\t" ;
	if(n < 1)  cout << "n值不合法!" ;
	else if(flag == 0)  cout << "请先初始化链表!" ;
	else if(t == 2)  HeadCreateList_L(L , n) ; // 头插法
	else if(t == 3)  TailCreateList_L(L , n) ; // 尾插法 
	cout << "\t\t\t现链表为："  ;// << endl << "\t\t\t"
	ListTraverse(L) ;
	cout << "\t\t\t输入成功！" << endl << endl ;
}
// 4.销毁链表  5.清空链表
//void destroyclear(LinkList &L , int &flag , int t)
//{
//	if(flag == 0)  cout<< "\t\t\t请先初始化链表" ;
//	else if(t == 4)
//	{
//		if(DestroyList(L) == OK) 
//		{
//			flag = 0; 
//			cout << "\t\t\t销毁链表成功！";
//		}  
//	}
//	else if(t == 5)
//	{
//		ClearList(L) ;
//		cout << "\t\t\t清空链表成功！";
//	}
//	cout << endl << endl ;
//}
//8.查看第i个元素
//void getelem_l(LinkList &L , int flag) 
//{
//	int i ;
//	ElemType e ;
//	if(flag == 0)  cout<< "\t\t\t请先初始化链表" ;
//	else 
//	{
//		cout << "\t\t\t请输入序号i：" ;
//		cin >> i ;
//		if(GetElem_L(L ,i , e) == ERROR)  cout << "\t\t\ti值不合法！";
//		else  cout << "\t\t\t序列第" << i << "个元素为" << e ;
//	}
//	cout << endl << endl ;
//}
 9.查看元素e的位序
//void locateelem(LinkList &L , int flag) 
//{
//	ElemType e ;
//	if(flag == 0)  cout<< "\t\t\t请先初始化链表" ;
//	else 
//	{
//		cout << "\t\t\t请输入你想查看的元素值e：";
//		cin >> e ;
//		if(LocateElem_L(L , e) == ERROR)  cout << "\t\t\t该元素不存在" ;
//		else  cout << "\t\t\t该元素的位置为" << LocateElem_L(L , e) ; 
//	}
//	cout << endl << endl ;
//}
10.求输入元素的直接前驱
//void priorelem(LinkList &L , int flag) 
//{
//	int cur_e ;
//	ElemType pre_e ;
//	if(flag == 0)  cout << "\t\t\t请初始化链表！" ;
//	else
//	{
//		cout << "\t\t\t请输入元素值：";
//		cin >> cur_e ;
//		if(PriorElem( L , cur_e , pre_e) == OVERFLOW) cout << "\t\t\t该元素不存在";
//		else if(PriorElem( L , cur_e , pre_e) == ERROR) cout << "\t\t\t第一元素无前驱" ; 
//		else  cout << "\t\t\t元素" << cur_e << "的直接前驱为" << pre_e ; 
//	}
//	cout << endl << endl ;
//}
 11.求输入元素的直接后继
//void nextelem(LinkList &L , int flag)
//{
//	int cur_e ;
//	ElemType next_e ;
//	if(flag == 0)  cout << "\t\t\t请初始化链表！" ;
//	else
//	{
//		cout << "\t\t\t请输入元素值：";
//		cin >> cur_e ;
//		if(NextElem(L , cur_e , next_e) == OVERFLOW) cout << "\t\t\t该元素不存在";
//		else if(NextElem(L , cur_e , next_e) == ERROR) cout << "\t\t\t最后元素无后继"; 
//		else  cout << "\t\t\t元素" << cur_e << "的直接后继为" << next_e ; 
//	}
//	cout << endl << endl ;
//}
// 13.在第i个位置插入一个元素
void listinsert(DuLinkList &L , int flag) 
{
	int i ;
	ElemType e;
	if(flag == 0)  cout << "\t\t\t请先初始化链表!";
	else 
	{
		cout << "\t\t\t请要输入插入位置i：" ;
		cin >> i ;
		cout << "\t\t\t请输入插入值：";
		cin >> e;
		if(ListInsert(L , i , e) == ERROR)  
			cout << "\t\t\ti值不合法，操作失败" << endl;
		else 
			cout << "\t\t\t已在表中i=" << i << "位置插入元素" << e << endl ; 
		cout << "\t\t\t现在的列表为：" ;
		ListTraverse(L) ;
	}
	cout << endl << endl ;
}
// 14.删除第i个元素
void listdelete(DuLinkList &L , int flag)
{
	int i ;
	ElemType e;
	if(flag == 0)  cout << "\t\t\t请先初始化链表!";
	else 
	{
		cout << "\t\t\t请输入要删除位置i：" ;
		cin >> i ;
		if(ListDelete(L , i , e) == ERROR)   
			cout << "\t\t\ti值不合法，操作失败" << endl;
		else   
			cout << "\t\t\t已删除第" << i << "个元素" << e << endl; 
		cout << "\t\t\t现在的列表为：" ;
		ListTraverse(L) ;
	}
	cout << endl << endl ;
}
 15.置换第i个元素
//void putelem(LinkList &L , int flag)
//{
//	int i ;
//	ElemType e;
//	if(flag == 0)  cout << "\t\t\t请先初始化链表!";
//	else
//	{
//		cout << "\t\t\t请输入你想置换的元素序号:" ;
//		cin >> i ;
//		cout << "\t\t\t元素置换成：" ;
//		cin >> e ;
//		if(PutElem(L , i , e) == ERROR)  
//			cout << "\t\t\ti值不合法，操作失败" ;
//		else 
//			cout << "\t\t\t第" << i << "个元素已置换成" << e << endl;
//		cout << "\t\t\t现链表为：" ;//<< endl << "\t\t\t" ;
//		ListTraverse(L) ;
//	} 
//	cout << endl << endl ;
//}
16.实现单链表的逆序存放 
//void reverselist(LinkList &L , int flag) 
//{
//	if(flag == 0)  cout << "\t\t\t请先初始化链表!" ;
//	else
//	{
//		ReverseList(L) ;
//		cout << "\t\t\t逆序成功！" << endl ; 
//		cout << "\t\t\t逆序后的链表为：" << endl << "\t\t\t" ;
//		ListTraverse(L) ;
//	} 
//	cout << endl << endl ; 
//}

// 主菜单 
void Menu(DuLinkList &L , int flag) 
{
	printf("\t\t\t=================================================================\n");
	printf("\t\t\t|                                                               |\n");
	printf("\t\t\t|                    双向链表基本操作                           |\n");
	printf("\t\t\t|                                                               |\n");
	printf("\t\t\t|===============================================================|\n");
	printf("\t\t\t|                   请选择要操作的命令                          |\n");
	printf("\t\t\t|---------------------------------------------------------------|\n");
	printf("\t\t\t|                                                               |\n");
	printf("\t\t\t|    0.退出整个系统                1.初始化单链表               |\n");
	printf("\t\t\t|    2.用头插法输入元素            3.用尾插法输入元素           |\n");
//	printf("\t\t\t|    4.销毁链表                    5.清空链表                   |\n");
//	printf("\t\t\t|    6.判断链表 是否为空            7.查看链表长度               |\n");
//	printf("\t\t\t|    8.查看第i个元素               9.查看元素e的位序            |\n");
//	printf("\t\t\t|    10.求输入元素的直接前驱       11.求输入元素的直接后继      |\n");
	printf("\t\t\t|    12.遍历-输出链表所有的元素    13.在第i个位置插入一个元素   |\n");
//	15.置换第i个元素
	printf("\t\t\t|    14.删除第i个元素                                           |\n");
//	printf("\t\t\t|    16.实现单链表的逆序存放                                    |\n");
	printf("\t\t\t|                                                               |\n");
	printf("\t\t\t=================================================================\n");
	printf("\t\t\t选择（0---16):\t");
	int choice ;
	cin >> choice ; 
	switch(choice)
	{
		
		case 0 :   // 0.退出整个系统
			cout << "\t\t\t你已退出" << endl ;
			exit(0) ; 
			break ;
		case 1 :   // 1.初始化单链表 
			initlist_l(L , flag) ;
			break ;
		case 2 :   // 2.用头插法输入元素   逆序 
			createlist_l(L , flag , 2) ;
			break ;
		case 3 :  // 3.用尾插法输入元素
			createlist_l(L , flag , 3) ; 
			break ;
//		case 4 :  // 4.销毁链表
//			destroyclear(L , flag , 4) ;
//			break ;
//		case 5 : // 5.清空链表
//			destroyclear(L , flag , 5) ;
//			break ;
		case 6 : //6.判断链表是否为空
			if(ListEmpty(L))  cout << "\t\t\t该表为空表";
			else  cout << "\t\t\t该表不是空表" ;
			cout << endl << endl ;
			break ;
		case 7 : // 7.查看链表长度
			if(flag == 0)  cout << "\t\t\t请先初始化链表" ;
			else  cout << "\t\t\t表长为" << ListLength(L) ;
			cout << endl << endl ;
			break ;
//		case 8 :  // 8.查看第i个元素
//			getelem_l(L , flag) ;
//			break ;
//		case 9 :  // 9.查看元素e的位序
//			locateelem(L , flag) ;
//			break ;
//		case 10 : // 10.求输入元素的直接前驱
//			priorelem(L , flag) ;
//			break ;
//		case 11 :// 11.求输入元素的直接后继
//			nextelem(L , flag) ;
//			break ;	
		case 12 : // 12.遍历-输出链表所有的元素
			cout << "\t\t\t" ;
			ListTraverse(L) ;
			cout << endl << endl ;
			break ;
		case 13 : // 13.在第i个位置插入一个元素
			listinsert(L , flag) ;
			break ;
		case 14 : // 14.删除第i个元素
			listdelete(L , flag);
			break ;
//		case 15 : // 15.置换第i个元素
//			putelem(L , flag) ;
//			break ;
//		case 16 : //16.实现单链表的逆序存放 
//			reverselist(L , flag) ;
//			break ;
		default :
			cout << "\t\t\t输入不合理，请重新输入" ;
			cout << endl << endl ;
	}
	Menu(L , flag) ;
}



int main(int argc, char** argv) 
{
	DuLinkList L ; // L为单链表的头指针 
	int flag = 0;
	Menu(L , flag) ; // 菜单函数 
	return 0;
}

二、function

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

//  1.初始化单链表
Status InitList(DuLinkList &L)
{
	L = (DuLinkList)malloc(sizeof(DuLNode)) ;
	L->prior = NULL ;
	L->next = NULL ;
	return OK ;
}

//2.用头插法输入元素   逆序
Status HeadCreateList_L(DuLinkList &L , int n)
{
	if(!L || n < 1)  return ERROR ;
	int i ;
	DuLinkList s ;
	for(i = 1 ; i <= n ; i ++)
	{
		s = (DuLinkList)malloc(sizeof(DuLNode)) ;
		cin >> s->data ;
		s->next = L->next ;
	//	L->next->prior = s ;
		s->prior = L ;
		L->next = s ;
	}
	return OK ;
} 
//3.用尾插法输入元素   顺序 
Status TailCreateList_L(DuLinkList &L , int n)
{
	if(!L || n < 1)  return ERROR ;
	int i ;
	DuLinkList s , r = L; // r是尾指针 
	for(i = 1 ; i <= n ; i ++)
	{
		s = (DuLinkList)malloc(sizeof(DuLNode)) ;
		cin >> s->data ;
		s->prior = r ;
		r->next = s ;
		r = s ;
	}
	r->next = NULL ; // 尾指针指向空 
}
//6.判断链表是否为空 
Status ListEmpty(DuLinkList L)
{
	if(L->next = NULL)  return 1 ; // 空
	else  return 0 ; // 非空 
}
// 7.查看链表长度
int ListLength(DuLinkList L)
{
	DuLinkList p = L->next ;
	int len = 0;
	while(p)
	{
		len ++ ;
		p = p->next ;
	}
	return len ;
}
// 12.遍历-输出链表所有的元素
void ListTraverse(DuLinkList L)
{
	DuLinkList p = L->next;
	L = new LNode ;
//	for(p = L->next ; p ; p=p->next)
//	{
//		cout << p->data << " " ;
//	}
	while(p)
	{
		cout << p->data << " " ;
		p = p->next ;
	}
	cout << endl << endl ;
} 
// 13.在第i个位置插入一个元素 o(n)
Status ListInsert(DuLinkList &L , int i , ElemType e)
{
	DuLinkList p = L , s ;
	int j = 0;
	// 让p指向第i-1个位置 
	while(p && j < i-1)
	{
		p = p->next ;
		j ++ ;
	}
	if(!p || j > i-1)  return ERROR ;
	s = (DuLinkList) malloc(sizeof(DuLNode));
	s->data = e ;
	p->next->prior = s ;
	s->next = p->next;
	s->prior = p;
	p->next = s ;
	return OK ; 
}
// 14.删除第i个元素  o(n)
Status ListDelete(DuLinkList &L , int i , ElemType &e)
{
	DuLinkList p = L;
	int j = 0 ;
	// 让p指向第i个位置 
	while(p->next && j < i)
	{
		p = p->next ;
		j ++ ;
	}  
	if(!p->next || j > i)  return ERROR ;
	e = p->data ;
	p->prior->next = p->next ;
	p->next->prior = p->prior ;
	delete p ;
	return OK ;
}

三、com

#ifndef _FUNC_H
#define _FUNC_H

#define OK 0
#define ERROR -1
#define OVERFLOW -2

typedef int Status ;
typedef int ElemType ;

// 结构体
typedef struct DuLNode
{
	ElemType data ;
	struct DuLNode *prior ; //
	struct DuLNode *next ;
}DuLNode , *DuLinkList ;

extern Status InitList(DuLinkList &L) ;
extern Status HeadCreateList_L(DuLinkList &L , int n);
extern Status TailCreateList_L(DuLinkList &L , int n) ;
extern Status ListEmpty(DuLinkList L) ;
extern int ListLength(DuLinkList L) ;
extern void ListTraverse(DuLinkList L) ;
extern Status ListInsert(DuLinkList &L , int i , ElemType e); 
extern Status ListDelete(DuLinkList &L , int i , ElemType &e) ;





#endif

漫话数据结构-双向链表及基本操作.pptx
11-03
本讲座主要探讨了一种特殊的数据结构——双向链表。双向链表是一种线性数据结构，它允许我们在列表中的节点之间进行双向移动，而不仅仅像单链表那样只能从前往后或从后往前。 双向链表的定义： 双向链表是由一系列...
链存储结构-双向链表
12-11
总的来说，链存储结构中的双向链表是一种重要的数据结构，它在许多算法和数据处理场景中发挥着关键作用。学习和掌握双向链表的原理和操作，不仅可以加深对计算机科学基础的理解，也有助于解决实际编程问题，提高软件...
数据结构-链表.pdf
04-15
数据结构-链表 单向链表，双向链表、循环链表等
数据结构 双向链表（C++）
06-07
双向链表是一种特殊的数据结构，它在计算机程序设计中扮演着重要角色，特别是在C++这样的编程语言中。本节将深入探讨双向链表的概念、其结构、操作以及C++中的实现。 双向链表与单链表不同，它允许每个节点不仅有一...
数据结构-二叉树及其遍历
宁zz的博客
11-15 604
本篇文章咱们聊聊数据结构中的树，准确的说因该是只说一说二叉树以及相关的三种递归遍历、三种非递归遍历以及层次遍历。🍃二叉树 (BinaryTree) 是 n (n>0) 个结点所构成的集合，它或为空树(n-0)或为非空树，对于非空树(1) 有且仅有一个称之为根的结点:(2) 除根结点以外的其余结点分为两个互不相交的子集 TI 和 T2，分别称为 T 的左子树和右子树，且 T1 和 T2 本身又都是二叉树。🍃二叉树与树一样具有递归性质，二叉树与树的区别。
排序算法 -计数排序
qq_46538985的博客
11-16 513
计数排序
数据结构——AVL树
未知陨落的博客
11-16 1075
二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查 找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii 和E.M.Landis在1962年 发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度
数据结构《栈和队列》
weixin_74772041的博客
11-16 273
有关数据结构中的栈和队列的相关内容，以及它们的简单实现，和简单使用。
数据结构(初阶4)---循环队列详解
Mr_vantasy的博客
11-12 1093
c语言实现 循环队列，循环队列的疑点解析(๑ơ ₃ ơ)♥
数据结构C语言描述3(图文结合)--双链表、循环链表、约瑟夫环问题
weixin_74085818的博客
11-16 1104
🚡 双向链表，对比单链表来说，顾名思义，就是指向指向有两个指针，指向前后节点。🌾 结合单链表，单链表有无头和有头之分，双向链表也是一样，这里是无头双链表，采用再封装写法，不是二级指针写法再封装写法比较写起来比较容易，个人比较偏爱🤠🤠🤠🤠双链表图示：总结起来一句话：增删改查增加元素删除元素拿取元素查询元素修改元素…………………………
《数据结构》--二叉树【下】
Stark的博客
11-12 416
在节点结构中加入层号属性。结果容器由vector：res改为multimap：m。输出时，输出m.first和m.second即可将层号和节点值同时打印出来。最简单的方法就是在上面的基础上，输出m的最后一个元素的first属性值。在 二 的基础上，输出时，如果m.first == i,输出。二叉树满度也就是节点的度为2。也就是左右孩子都存在。分支节点是度不为0的节点。也就是有孩子节点存在。叶子节点是度为0的节点。也就是没有孩子节点。或者将代码改为：（插入时直接判断）
数据结构：选择排序
最新发布
qincjun的博客
11-16 125
【代码】数据结构：选择排序。
数据结构——排序
2401_82924480的博客
11-12 1135
关于排序的算法
C++图解数据结构(基于SDL2)之MyTree
嵇康的专栏
11-16 272
点击界面,随机生成节点,然后按下鼠标左键,第一次点击起点,第二次点击终点,就会简历一条路径,从起点指向第二个点,并挂在根节点上(这里我第一点击生成的为41,41就为根节点)std::vector<MyNode*> vertices;addEdge+invertTree+hasPathSum(75)综合效果。// DFS前序遍历并动态显示遍历过程。// 获取鼠标点击位置的节点索引。// 绘制二叉树节点及其连接线。// 二叉树节点定义。
数据结构前言
eternal__day的博客
11-16 702
Java 集合框架 Java Collection Framework ，又被称为容器 container ，是定义在 java.util 包下的一组接口 interfaces 和其实现类 classes。其主要表现为将多个元素 element 置于一个单元中，用于对这些元素进行快速、便捷的存储 store 、检索 retrieve 、 管理 manipulate ，即平时我们俗称的增删查改 CRUD。例如，一副扑克牌(一组牌的集合)、一个邮箱(一组邮件的集合)、一个通讯录(一组姓名和电话的映射关系)等等。
线性数据结构
2301_80148369的博客
11-16 438
为了避免当只有一个元素的时候，队头和队尾重合使处理变得麻烦，所以引入两个指针，front 指针指向对头元素，rear 指针指向队列最后一个元素的下一个位置，这样当 front 等于 rear 时，此队列不是还剩一个元素，而是空队列。当进行入队、出队操作的时候，front 和 rear 都会持续往后移动，当 rear 移动到最后的时候,我们无法再往队列中添加数据，即使数组中还有空余空间，这种现象就是。其实是一种特殊的单链表，和单链表不同的是循环链表的尾结点不是指向 null，而是指向链表的头结点。
数据结构之集合框架
旺旺碎冰冰的博客
11-16 366
数据结构(Data Structure)是计算机存储、组织数据的方式，指相互之间存在一种或多种特定关系的数据元素的集合。算法(Algorithm):就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。这篇博客的内容了解即可，最重要的是类和接口那个图，记不住没关系，接下来我们将围绕着这个图来进行讲解，多用就记住啦！
数据结构（单向链表）
yyw_17的博客
11-16 526
单向链表、单向链表原理、单向链表完整代码、链式存储的优缺点
数据结构-双向链表前插操作详解
"双向链表的前插操作算法及其在数据结构中的重要性" 在计算机科学中，数据结构是研究如何高效地存储和处理数据的重要领域。清华大学严蔚敏教授的《数据结构》C语言版中详细阐述了各种数据结构及其操作，其中包括...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值