数据结构 单链表的基本操作实现代码

最新推荐文章于 2023-01-03 21:37:45 发布
最新推荐文章于 2023-01-03 21:37:45 发布
阅读量1.7k 收藏 24
点赞数 1
文章标签： 数据结构 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wu____nai/article/details/109388884
版权

C语言 链表 数据结构 指针操作 线性结构
关键词由CSDN通过智能技术生成

实验3、单链表的基本操作实现
（1）实验目的
通过该实验，深入理解链表的逻辑结构、物理结构等概念，掌握链表基本操作的编程实现，熟练掌握C语言中指针的操作。和实验3对比，掌握线性结构两种不同存储方式的区别。
（2）实验内容
编程实现链表下教材第二章定义的线性表的基本操作，最好用菜单形式对应各个操作，使其编程一个完整的小软件。注意，每个功能模块一定要考虑非法的情况，并作出相应的提示，例如：求前驱，要分别能够测试第一个元素的前驱、其他正常的元素的前驱、输入一个在表中不存在的元素求其前驱，这三种情况应给出相应的提示语和结果值；插入和删除时要考虑插入或删除的位置是否合法等。
（3）实验要求：
菜单项包括：
1.初始化或重置链表
2.销毁链表
3.清空链表
4.链表长度
5.指定位置的元素值
6.链表已存在元素的位序
7.求输入元素的直接前驱
8.求输入元素的直接后继
9.在第i个位置插入一个元素
10.删除第i个元素
11.输出有的链表元素
12.初始化并用头插法（或尾插法）输入元素
13.实现单链表的逆序存放
要求：所有的提示语不允许出现在自定义的函数中，只能在main函数中出现提示语。

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

#define ok 1
#define error 0
#define question -1
#define shortcoming 2

typedef int Status;
typedef int ElemType;

typedef struct LNode{
	struct LNode *next;
	ElemType data;
}LNode , *linklist;


Status init(linklist &L);           //初始化或重置链表 
Status Destroy(linklist &L);              //销毁链表 
Status Empty(linklist &L);              //清空链表 
Status GetLength(linklist L);          //获取链表长度 
Status GetElem(linklist L, ElemType &e,int j);        //获取指定位置元素 
Status GetLoc(linklist L, int &e,int &j);              //获取指定元素位置 
Status GetPrior(linklist L ,int &e,int j);            //获取指定元素前驱 
Status GetNext(linklist L ,int &e,int j);              //获取指定元素后继 
Status Insert(linklist &L,int &e,int &j);        //在指定位置插入元素 
Status Delete(linklist &L,int &j);                       //删除指定位置元素 
Status shuchu(linklist L);                        //显示链表中全部元素 
Status shuru(linklist &L);                        //初始化并用头插法插入数据 
Status nixu(linklist &L);                           //链表元素的逆序存放 
int menu() {
	cout<<"1----初始化或重置链表"<<endl;
	cout<<"2----销毁链表"<<endl;
	cout<<"3----清空链表"<<endl;
	cout<<"4----求链表长度"<<endl;
	cout<<"5----获取链表中指定位置的元素"<<endl;
	cout<<"6----获取线性表元素的位置"<<endl;
	cout<<"7----求前驱"<<endl;
	cout<<"8----求后继"<<endl;
	cout<<"9----在链表指定位置插入元素"<<endl;
	cout<<"10---删除链表指定位置的元素"<<endl;
	cout<<"11---显示链表"<<endl;
	cout<<"12---初始化并用头插法（尾插法）输入元素"<<endl;
	cout<<"13---实现链表的逆序存放"<<endl;
	cout<<"   	退出，输出一个负数！"<<endl;
}

int main() {
	int a;
	linklist L = NULL;
	menu();
	while(true) {
		cout<<"请选择程序：";
		cin>>a;
		if (a < 0) {
			cout<<"程序已退出！"<<endl; 
			break;
		}
		if(a == 0 || a > 13) {
			cout<<"程序选择错误！请重新选择：";
			getch();
			continue;
		}
		if (a > 0 && a < 14) {
			switch(a) {
		case 1:{
			if(init(L) == ok) {
		cout<<"链表初始化成功！"<<endl;;
	} else if (init(L) == error){
		cout<<"链表初始化失败！"<<endl;
	} else {
		cout<<"链表重置成功！"<<endl;
	} 
			break;
		}
		case 2:{
			if(Destroy(L) == ok) {
	cout<<"链表已销毁！"<<endl;
} else if (Destroy(L) == question) {
	cout<<"链表不存在"<<endl; 
} else {
	cout<<"链表销毁失败，请重试！"<<endl;
}
			break;
		}
		case 3:{
			if (Empty(L) == ok) {
	cout<<"链表已清空!"<<endl; 
} else if (Empty(L) == question) {
	cout<<"链表为空，无需此操作！"<<endl;
} else {
	cout<<"链表不存在！"<<endl;
}
			break;
		}
		case 4:{
			if (GetLength(L) == error) {
	cout<<"链表不存在或链表为空！"<<endl;
} else {
	cout<<"链表长度为"<<GetLength(L)<<endl; 
}

			break;
		}
		case 5:{
			int e,j; 
			if (GetElem(L,e,j) == error) {
			cout<<"链表不存在！"<<endl;
		} else {
			if (GetElem(L,e,j) == shortcoming) {
				cout<<"链表为空！"<<endl; 
			} else {
			cout<<"请输入想要查询的位置：";
			cin>>j;
			if (GetElem(L,e,j) == ok) {
				cout<<"该位置的元素为：";
				cout<<e<<endl;
			}  else {
				cout<<"链表中没有该位置！"<<endl;
			}
			}
		}
			break;
		}
		case 6:{
			int e,j;
			if (L) {
		if (GetLength(L) == 0) {
			cout<<"链表为空！"<<endl; 
		} else {
		cout<<"请输入要查询的元素："; 
			cin>>e;
			if (GetLoc(L,e,j) == ok) {
				cout<<"该元素的位置是："<<j<<endl; 
			} else{
				cout<<"表中没有该元素！"<<endl;
			}
		}
	} else {
		cout<<"链表不存在！"<<endl;
	}	
		break;
		}
		case 7:{
			int e,j;
		if (GetPrior(L,e,j) == error) {
			cout<<"链表不存在或者链表为空，请程序3进行验证！"<<endl;
		} else {
			cout<<"请输入想要查询前驱的元素(第一次出现)：";
			cin>>j;
			if (GetPrior(L,e,j) == question) {
				cout<<"链表中没有该元素！"<<endl; 
			} else if (GetPrior(L,e,j) == shortcoming) {
				cout<<"该元素在链表中的第一个位置，没有前驱元素！"<<endl;
			} else {
				cout<<"该元素的前驱元素为：";
				cout<<e<<endl; 
			} 
		}
			break;
		}
		case 8:{
			int e,j;
			if (GetNext(L,e,j) == error) {
			cout<<"链表不存在或者链表为空，请程序3进行验证！"<<endl;
		} else {
			cout<<"请输入想要查询后继的元素(第一次出现)：";
			cin>>j;
			if (GetNext(L,e,j) == question) {
				cout<<"链表中没有该元素！"<<endl; 
			} else if (GetNext(L,e,j) == shortcoming) {
				cout<<"该元素在链表中的最后一个位置，没有后继元素！"<<endl;
			} else {
				cout<<"该元素的后继元素为：";
				cout<<e<<endl; 
			} 
		}
			break;
		}
		case 9:{
			if (L) {
			int e,j;
			cout<<"请输入想要插入元素的位置：";
			cin>>j;
			if (j > 0 && j <= GetLength(L) + 1) {
				cout<<"请输入想要插入的元素：";
				cin>>e;
				if (Insert(L,e,j)) {
					cout<<"插入成功！"<<endl;
				} else {
					cout<<"插入失败！"<<endl;
				}
			} else {
				cout<<"该位置不存在！"<<endl;
			}
		} else {
			cout<<"线性表不存在！"<<endl;
		}
			break;
		}
		case 10:{
			if (L) {
			int j;
			cout<<"请输入想要删除元素的位置：";
			cin>>j;
			if (j > 0 && j <= GetLength(L)) {
				if (Delete(L,j)) {
					cout<<"删除成功！"<<endl;
				} else {
					cout<<"删除失败！"<<endl;
				}
			} else {
				cout<<"该位置不存在！"<<endl;
			}
		} else {
			cout<<"线性表不存在！"<<endl;
		}
			break;
		}
		case 11:{ 
			if (shuchu(L)) {
				cout<<"数据已全部输出！"<<endl;
			}  else {
					cout<<"链表不存在！"<<endl;
				}  
		break;
		}
		case 12:{
			cout<<"请开始输入元素,（以'-99'结束）"<<endl;
			if (shuru(L) == error) {
				cout<<"链表初始化失败！"<<endl;
			} else {
				cout<<"链表元素输入完成！"<<endl;
				}
			break;
			}
		case 13:{
			if (L) {
				if (L->next == NULL) {
					cout<<"链表为空！"<<endl;
				} else {
					if (nixu(L) == ok) {
						cout<<"程序执行成功！"<<endl;
					} else {
						cout<<"程序出现错误，请联系技术人员"<<endl;
					}
				}
			} else {
				cout<<"链表不存在"<<endl;
			}
			break;
		}
			}
		}
	}
}

Status init(linklist &L) {                           //1初始化或重置链表 
	if (L) {
			Empty(L);
		//	L->next == NULL;
			return question;
	} else {
		L = (linklist)malloc(sizeof(LNode));
	if (L) {
		L->next = NULL;
	//	L->data = 0;
		return ok;
	} else {
		return error; 
	}
	}
}
 
Status Destroy(linklist &L) {                   //2销毁链表 
		if(L) {
		Empty(L);
		L = NULL;
		return ok;
	} else {
		return question; 
	}
}

Status Empty(linklist &L) {              //3清空链表 
	if (L) {
		if (L->next != NULL) {
			LNode *p,*q;
			p = L;
			while(p->next != NULL) {
				q = p->next;
				p->next = q->next;
				free(q);
			}
			return ok;
		} else {
			return question;
		}
	} else {
		return error;
	}
} 

Status GetLength(linklist L) {               //4获取链表长度 
	if (L) {
			int i = 0;
			LNode *p,*q;
			p = L;
			while(p->next != NULL) {
				q = p->next;
				p=q;
				i++;
		}
		return i;
	} else {
		return error;
	}
}

Status GetElem(linklist L, ElemType &e,int j) {            //5获取指定位置元素 
	if (L) {
		if (GetLength(L) == 0) {
			return shortcoming;
		} else {
			int i = 0;
			LNode *p,*q;
			p = L;
			if (j <= 0 || j > GetLength(L)) {
				return question;
			}
			while(p->next != NULL) {
				q = p->next;
				p=q;
				i++;
				if (i == j) {
					e = p->data;
				}
		}
		return ok;
		}
	} else {
		return error;
	}
}

Status GetLoc(linklist L, int &e,int &j) {             //6获取指定元素位置 
			int i = 0,flag = 0;
			LNode *p,*q;
			p = L;
			while(p->next != NULL) {
				q = p->next;
				p=q;
				i++;
				if (p->data == e) {
					j = i;
					flag++;
					return ok;
				}
		}
		if (flag == 0) {
			return question;
		}
}
 
Status GetPrior(linklist L,int &e,int j) {            //7获取指定元素前驱 
		if (L && GetLength(L) != 0) {
			int i = 0,flag = 0,k = 0;
			LNode *p,*q;
			p = L;
			while(p->next != NULL) {
				q = p->next;
				p=q;
				i++;
				if (p->data == j) {
					flag = 1;
					break;
				}
		}
		if (flag == 0) {
			return question;
		} else {
		if (i == 1) {
				return shortcoming;
			} else {
				p = L;
				while(p->next != NULL) {
				q = p->next;
				p=q;
				k++;
				if (k == i - 1) {
					e = p->data;
					break;
				}
			}
			return ok;
		}
	}
} else {
	return error;
}
}

Status GetNext(linklist L ,int &e,int j) {             //8获取指定元素前驱 
	if (L && GetLength(L) != 0) {
		int i = 0,flag = 0,k = 0;
		LNode *p,*q;
		p = L;
		while (p->next != NULL) {
			q = p->next;
			p = q;
			i++;
			if (p->data == j) {
				if (i == GetLength(L)) {
					return shortcoming;
				} else {
					q = p->next;
					p = q;
					e = p->data;
					flag = 1;
					return ok;
				}
			}
		}
		if (flag == 0) {
			return question;
		}
} else {
	return error;
}
}

Status Insert(linklist &L,ElemType &e,int &j) {             //9在指定位置插入元素 
		int i = 1;
		LNode *p,*s;
		p = L;
		while (p && i < j) {
			p = p->next;
			++i;
		}
		s = (linklist)malloc(sizeof(LNode));
		s->data = e;
		s->next = p->next;
		p->next = s;
		return ok;
}

Status Delete(linklist &L,int &j) {              //10删除指定位置元素 
			int i = 1;
			LNode *p,*q,*r;
			p = L;
			while (p->next && i < j) {           //循环遍历链表，直到找到第j个元素 
				p = p->next;              //p指向像一个结点 
				++i;                         
			} 
			q = p->next;               
			p->next = q->next;
			free(q);
			return ok;
} 
 
 Status shuchu(linklist L) {                //11示链表中全部元素 
	if (L) {
		LNode *p,*q;
		p = L;
		while (p->next != NULL) {
			q = p->next;
			p = q;
		//	cout<<1<<endl;
			cout<<p->data<<" ";
		}
		return ok; 
	} else {
		return error;
	}

}

Status shuru(linklist &L) {    //12初始化并用头插法插入数据 
	init(L);                 
	if (L) {
	int i; 
	LNode *p,*q;
	p = L;
	while (true) {
		cin>>i;
		if (i == -99) {
			break;
		} else {
		q = (linklist)malloc(sizeof(LNode));
		q->data = i;
		q->next = p->next;
		p->next = q;
		p = q;
		}
	} 
	return ok;
} else {
	return error;
}
}

Status nixu(linklist &L) {             //13 逆序存放链表 
	ElemType t;
	int x = 1,y = 1,j = 0;
	LNode *p,*q;
	p = L;
	q = p;
	for (int i = 0;i < GetLength(L);i++) {
		p = p->next;
		t = p->data;
		while (q->next != NULL) {
			q = q->next;
			j++;
			if (i + j == GetLength(L)) {
				p->data = q->data;
				q->data = t;
				break;
			} else {
				continue;
			}
		}
	}
	return ok;
}

刚开始接触CSND，没有写博客的经验，就直接上代码和要求了，

月鸟石
关注
数据结构-单链表基本操作-C语言代码
suxiaorui的博客
01-22 6万+
单链表基本操作 1.头插法建立单链表 2.尾插法建立单链表 3.查找结点 3.修改结点 4.插入结点 5.删除结点 本篇只有c语言代码，具体思路讲解请看这篇博客：数据结构-线性结构-单链表 1.头插法建立单链表 #include<stdio.h> #include<stdlib.h> //单链表的结构定义 typedef struct LNode { int data...
2023王道数据结构-单链表基本操作的实现代码（C++版）
qq_45961676的博客
05-10 1263
王道数据结构单链表基本操作
实验二：链表的基本操作的实验报告
12-04
源代码： #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define flag 0 typedef int ElemType; typedef struct linkList { ElemType data; struct linkList *next; }LinkList; #include #include //#include //#include "linkList.h" void init_LinkList(LinkList *head)
链表的操作实验
夏日漱石的博客
05-12 1527
单链表
实验3 链表的基本操作
qq_40772639的博客
10-18 214
头文件： #pragma once #ifndef MYLIST_H_ #define MYLIST_H_ #include <iostream> using namespace std; template<typename T = int> class MyList { private: struct Node { T data; Node* prior = nullptr; Node* next = nullptr;
单链表的基本操作和实现
qq56hm的博客
01-14 307
单链表的基本操作和实现 #include "bits/stdc++.h" using namespace std; typedef struct Lnode { string e;//结点的数据域 struct Lnode *next;//结点的指针域 } Lnode, *LinkList;//LinkList为指向结构体Lnode的指针类型 int InitList_L(LinkList &L); int DestroyList_L(LinkList &L); i
【数据结构】单链表的基本操作及实现
qq_51639901的博客
02-26 7379
线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素（这组存储单元可以是连续的，也可以是不连续的）。因此，为了表示每个数据元素与其直接后继数据元素之间的逻辑关系，对数据元素来说，除了存储其本身的信息之外，还需存储一个指示其直接后继的信息（即直接后继的存储位置）。这两部分信息组成数据元素的存储映像，称为节点，它包括两个域，其中存储数据单元信息的域被称为数据域，存储直接后继存储位置的域被称为指针域，指针域中的存储信息乘坐指针或链。n个节点((1<=i<=n)的存储映像...
数据结构单链表的基本操作实现(包含源代码)上机报告
07-13
数据结构中的单链表是一种常见的线性数据结构，它的每个节点包含两部分：一部分是数据域，用于存储数据；另一部分是指针域，用于指向下一个节点。本实验报告旨在通过C++实现单链表的基本操作，包括初始化、销毁、...
数据结构-单链表的学习及代码实现
最新发布
09-03
【数据结构-单链表的学习及代码实现】 单链表是一种基本的数据结构，它由一系列节点组成，每个节点包含数据域和一个指向下一个节点的指针。与数组不同，链表中的元素在内存中并不一定是连续存储的，而是通过指针...
C语言链表操作演示程序
12-01
使用的C语言和ege库编写的链表操作演示程序源码，对于链表的几个基本操作都具有演示动画，且数据全部随机产生
单链表及基本操作与实现
金啊豆嘞的博客
09-09 380
单链表的基本操作及基本实现如下： #include "stdio.h" #include "stdlib.h" typedef int ElemType; typedef struct LNode{ ElemType data; struct LNode *next; }LNode, *LinkList; LinkList InitList(LinkList &L);...
单链表的基本操作实现
OliverkingLi的博客
01-16 1256
一：实现基本单链表     这里想实现单链表的基本操作： 1.构造空的单链表 2.建立包含若干的数据元素的单链表 3.求出表长 4.获取第i个元素值 5.数据元素的插入 6.数据元素的删除 7.输出顺序表等     这里先定义单链表存储结构List；通过自定义函数实现单链表基本操作；然后调试运行程序。 list.h #inclu
单链表基本操作实现
m0_74250742的博客
01-03 191
单链表基本操作实现 #include<iostream> #include<stdlib.h> using namespace std; #define ERROR 0 #define OK 1 typedef int ElemType; typedef int Statue; typedef struct LNode{ ElemType data; struct LNode*next; } LinkList; //初始化链表 LinkList*InitLink
单链表基本操作的实现
qq1430727078的博客
04-07 821
.单链表的的初始化（带头结点的单链表） 构造一个空表 在内存中找到sizeof（LNode）的空间大小，用malloc分配出来，分配出来以后呢，转换为（LinKList*）类型。（LinKList*）是指向节点类型的指针 ...
数据结构实验3---单链表的基本操作实现
qq_62474991的博客
12-06 505
重点： 链表的定义和实现 难点： 单链表的逆序存放
单链表的基本操作C语言实现
sofia_m的博客
10-18 1433
          单链表主要有以下基本操作：头插，尾插，头删，尾删，返回结点在链表中的位置，任意位置插入值为data的结点， 删除pos位置上的结点 ，求链表中节点的个数，销毁单链表 。         代码如下所示： List.h #ifndef __LINKED_LIST__ #define __LINKED_LIST__ typedef int DataType; typede...
数据结构 实验二 链表的基本操作
TXYGoodluck的博客
09-25 9119
链表的基本操作 任务一：单链表的生成和输出 任务描述： 从键盘输入数据，创建一个初始链表。通过调用定义的基本操作函数来实现单链表上的插入、删除元素等操作。调试程序并对相应的输出作出分析；修改输入数据，预期输出并验证输出的结果。加深对有关算法的理解。 相关知识： 为了完成本关任务，你需要掌握： 1.尾插法建立单链表 2.单链表的遍历（输出） - 尾插法建立单链表 本关任务：尾插法是通过将新结点逐个插入到链表的尾部来创建链表。同前插法一样,每次申请一个新结点,读入相应的数据元素值。不同的是,为了使新结点能够插入
C++实现数据结构单链表基本操作代码教程
"数据结构单链表的基本操作的代码程序，包括创建、打印、获取指定位置元素和删除指定位置元素的功能。" 在计算机科学中，数据结构是组织和存储数据的方式，而单链表是一种简单但重要的数据结构。单链表由一系列节点...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值