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

最新推荐文章于 2024-01-10 22:06:26 发布
最新推荐文章于 2024-01-10 22:06:26 发布
阅读量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，没有写博客的经验，就直接上代码和要求了，

月鸟石
关注
  • 1
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
数据结构单链表的基本操作实现(包含源代码)上机报告
07-13
数据结构中的单链表是一种常见的线性数据结构，它的每个节点包含两部分：一部分是数据域，用于存储数据；另一部分是指针域，用于指向下一个节点。本实验报告旨在通过C++实现单链表的基本操作，包括初始化、销毁、...
【数据结构】实验三：链表
m0_65787507的博客
07-27 2180
数据结构实验
数据结构实验4：链表的基本操作
weixin_58628068的博客
01-10 1243
尾插法是一种在单链表中插入节点的方法，它将新节点插入到链表的尾部。相对于头插法，尾插法需要遍历整个链表找到尾节点，然后在尾节点之后插入新节点。在链表中查找元素的操作通常包括遍历链表，逐一比较节点的值，直到找到匹配的元素或者到达链表的末尾。带头结点的循环双向链表在链表尾部连接到头结点，同时每个节点都有一个指向前一个节点的指针。头插法是一种在单链表中插入节点的方法，它将新节点插入到链表的头部，成为新的头结点。每个节点有两个指针，一个指向前一个节点，另一个指向下一个节点。尾节点的指针指向头节点，形成一个闭环。
数据结构实验3---单链表的基本操作实现
qq_62474991的博客
12-06 502
重点： 链表的定义和实现 难点： 单链表的逆序存放
数据结构实验——实验二链表实验
qq_65814357的博客
06-10 1942
一、 实验任务编写算法实现下列问题的求解。(1)在第i个结点位置插入值为x的结点。实验测试数据基本要求：第一组数据：单链表长度n≥10，x=100, i分别为5,n,n+1,0,1,n+2第二组数据：单链表长度n=0，x=100，i=5(2)删除单链表中第i个元素结点。实验测试数据基本要求：第一组数据：单链表长度n≥10，i分别为5,n,1,n+1,0第二组数据：单链表长度n=0， i=5(3)在一个递增有序的单链表L中插入一个值为x的元素，并保持其递增有序特性。实验测试数据基本要求：单链表元素为 （10
数据结构——单链表的基本操作
煮酒blog
04-06 669
数据结构——单链表的基本操作数据结构——单链表的基本操作实验目的实验内容源代码 数据结构——单链表的基本操作 实验目的 通过该实验，深入理解链表的逻辑结构、物理结构等概念，掌握链表基本操作的编程实现，熟练掌握C语言中指针的操作。 实验内容 编程实现链表下教材第二章定义的线性表的基本操作，最好用菜单形式对应各个操作，使其编程一个完整的小软件。 参考界面： 源代码 #include <iostream> using namespace std; typedef int ElemType; ty
数据结构-单链表的学习及代码实现
09-03
【数据结构-单链表的学习及代码实现】 单链表是一种基本的数据结构，它由一系列节点组成，每个节点包含数据域和一个指向下一个节点的指针。与数组不同，链表中的元素在内存中并不一定是连续存储的，而是通过指针...
java 数据结构单链表的实现
08-30
"Java 数据结构单链表的实现" ...因此，本文通过介绍 Java 数据结构单链表的实现，旨在帮助读者更好地理解链表的基本概念和操作，并且提供了一些有用的代码示例，以便读者在实际开发中应用链表数据结构。
数据结构单链表的实现（C++）
06-07
在C++中实现单链表，我们需要理解其基本操作，如创建、插入、删除节点，以及遍历链表。下面将详细介绍这些知识点。 首先，创建单链表的节点结构体。节点通常包含两部分：存储数据的成员变量和指向下一个节点的指针...
实验二：链表的基本操作的实验报告
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)
数据结构线性表基本操作
热门推荐
lizhi20210729的博客
11-20 1万+
数据结构线性表基本操作基本内容线性表的顺序表示和实现线性表的顺序存储表示顺序表中基本操作的实现 基本内容 因为第一次数据结构阶段考写代码又想规范写又写不出规范的可读性强的代码，让我第一次意识到自己应该在这方面下一些功夫。这篇文章是记录自己把书上写的算法打到电脑上遇到的问题。 线性表的顺序表示和实现 线性表的顺序存储表示 将书中代码复刻如下： #define MAXSIZE 100//顺序表可能达到的最大长度 typedef struct { ElemType *elem;//储存空间的基地址
链表的操作实验
木头博客
02-28 3910
链表的操作实验 一、实验名称和性质 二、实验目的 1．掌握线性表的链式存储结构的表示和实现方法。 2．掌握链表基本操作的算法实现。 三、实验内容 1．建立单链表，并在单链表上实现插入、删除和查找操作（验证性内容）。 2．建立双向链表，并在双向链表上实现插入、删除和查找操作（设计性内容）。 3．计算已知一个单链表中数据域值为一个指定值x的结点个数（应用性设计内容）。 四、实验的软硬件环境要求 硬件环境要求：PC机（单机） 使用的软件名称、版本号以及模块： Windows环境下的TurboC2.0以上或
[Python]数据结构--链表
Festinatione facit vastum
01-11 648
[Python]数据结构–链表 ‘Festinatione facit vastum’ 链表的概念 单链表的实现 循环单链表的实现 链表 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另
数据结构实验之链表
lwcwam的博客
12-24 897
数据结构实验之链表
数据结构—链表（超详细）(山东大学）（数据结构实验三）
十二月的猫
11-03 218
首先是在确认链表的结构的时候，我们必然要定义一个Node结点类这个是链表的基本组成元素，然后就会遇到第一个问题——既然Node是元素那么我们需不需要定义一个类称为Nodelist代表链表里面包含元素Node。那么我们定义一个新的链表的本质操作就是给他一个开头就是给他一个指向Node的指针，那么这个链表就是被创建了。所以我们选用的是给Node*一个别名叫做NodeList，这样子我们创建一个NodeList就是创建一个指向Node的指针也就是创建了一个新的链表。【编译工具及其版本】
链表实现学生信息系统(数据结构实验)
Lonzoyoshi的博客
10-21 1095
定义一个包含学生信息（学号，姓名，成绩）的链表结构，使其具有如下功能：(1) 根据指定学生个数，逐个输入学生信息；(2) 逐个显示学生表中所有学生的相关信息；(3) 根据姓名进行查找，返回此学生的学号和成绩；(4) 根据指定的位置可返回相应的学生信息（学号，姓名，成绩）；(5) 给定一个学生信息，插入到表中指定的位置；(6) 删除指定位置的学生记录；(7) 统计表中学生个数。
【数据结构实验】单链表实验
山风不打咩的博客
04-01 5615
实验内容 1、利用头插法或尾插法建立单链表 2、对已建立的单链表实现插入、删除等基本操作； 3、输出链表所有结点数据 4、编写算法将这两个单链表归并为一个按元素值递减次序排列的单链表并计算表长。.........
单链表基本操作实现代码
最新发布
04-03
下面是单链表的基本操作实现代码： 1. 初始化链表： ```cpp struct ListNode { int val; ListNo* next; }; ListNode initList() { ListNode* head = new ListNode(); head->next = nullptr; return head; } `...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值