数据结构实验3---单链表的基本操作实现

最新推荐文章于 2024-01-10 22:06:26 发布
最新推荐文章于 2024-01-10 22:06:26 发布
阅读量587 收藏 5
点赞数
分类专栏： 数据结构 文章标签： 数据结构 链表 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_62474991/article/details/128204491
版权

（1）实验目的

通过该实验，深入理解链表的逻辑结构、物理结构等概念，掌握链表基本操作的编程实现，熟练掌握C语言中指针的操作。和实验2对比，掌握线性结构两种不同存储方式的区别。

（2）实验内容

编程实现链表下教材第二章定义的线性表的基本操作，最好用菜单形式对应各个操作，使其编程一个完整的小软件。注意，每个功能模块一定要考虑非法的情况，并作出相应的提示，例如：求前驱，要分别能够测试第一个元素的前驱、其他正常的元素的前驱、输入一个在表中不存在的元素求其前驱，这三种情况应给出相应的提示语和结果值；插入和删除时要考虑插入或删除的位置是否合法等。

（3）实验要求：

菜单项包括：

1.初始化或重置链表

2.销毁链表

3.清空链表

4.链表长度

5.指定位置的元素值

6.链表已存在元素的位序

7.求输入元素的直接前驱

8.求输入元素的直接后继

9.在第i个位置插入一个元素

10.删除第i个元素

11.输出有的链表元素

12.初始化并用头插法（或尾插法）输入元素

13.实现单链表的逆序存放

要求：所有的提示语和输出语句不允许出现在自定义的函数中(输出函数除外)，只能在main函数中出现提示语。

注：销毁链表时需要循环释放每个结点所占用的空间。

注：求前驱是指，输入一个元素值（而不是位置），求该元素在顺序表中的直接前驱元素值。求后继是指：输入一个元素值（而不是位置），求该元素在顺序表中的直接后继元素值。

（4）验收/测试用例

参考实验2

#include<iostream>
using namespace std;
typedef int ElemType;
typedef int Status;
typedef struct Lnode {
	ElemType data; //数据域
	struct Lnode* next;//指针域
}Lnode, * LinkList;
#define OK 1
#define ERROR 0

//1.初始化或重置链表
Status InitList(LinkList& L) {
	L = (LinkList)malloc(sizeof(Lnode));//申请内存空间
	if (L == NULL) {
		exit(OVERFLOW);
	}//内存空间分配失败，退出程序，并返回OVERFLOW的值给主调进程
	L->next = NULL;//next节点指向空
	return OK;
}

//2.销毁链表
Status DeleteList(LinkList& L) {
	LinkList p;//定义一个指针
	while (L) {//while循环重复进行，实现释放全部节点
		p = L;//设置一个指针p与头指针相投，并依次断开头部指针
		L = L->next;
		free(p);//释放节点的内存
	}
	L = NULL;//设置头指针为空
	return OK;
}

//3.清空链表
Status ClearList(LinkList& L) {
	LinkList p, q;//定义两个指针
	p = L->next;//p为首元节点
	if (!p) {//p不存在的情况下，链表中不存在元素，返回错误
		return ERROR;
	}
	while (p) {//当p存在时进行循环
		q = p->next;//q为p的下一个节点
		free(p);//释放p的空间
		p = q;//令p与下一个节点相连
	}
	L->next = NULL;//设置头指针为空
	return OK;
}

//4.链表长度
Status ListLength(LinkList& L) {
	int i = 0;//定义一个整型变量并初始化为0，代表头节点
	LinkList p;//定义一个指针
	p = L;//p指向头节点
	while (p->next) {//当p指向的地址不为空时，进入循环
		p = p->next;//p指向下一个节点
		i++;//当节点不为空时，i加1，直到p指向的地址为空时结束
	}
	return i;//返回长度值
}

//5.指定位置的元素值
Status GetElem(LinkList L, int i, ElemType& e) {
	LinkList p;
	p = L->next;//p指向首元节点
	int j = 1;
	while (p && j < i) {//while循环寻找所求元素的位置，当p不为空并且j<输入位置时进入循环
		p = p->next;
		++j;
	}
	if (!p || j > i) {//当输入的位置过大或过小时，输出错误
		return ERROR;
	}
	e = p->data;
	return e;
}

//6.链表已存在元素的位序
Status ListLocate(LinkList& L, int&i, ElemType e) {
	LinkList p;
	i = 1;
	p = L->next;//p指向首元节点
	while (p) {//当p不为空时，进入循环
		if (p->data == e) {//当元素等于输入数字时，结束循环
			return OK;
		}
		i++;
		p = p->next;//p等于p的下一个元素
	}
	return ERROR;//当表中的所有元素都不相等时，返回错误
}

//7.求输入元素的直接前驱
Status PriorList(LinkList L, ElemType& e) {
	LinkList p, q = nullptr;
	int i = 1;
	p = L->next;
	while (p != NULL) {
		if (p->data == e && i != 1)
		{
			return q->data;

		}
		else if (p->data==e&&i==1) 
		{
			return ERROR;
		}
		q = p;
		p = p->next;
		i++;
	}
	return ERROR;
}
//8.求输入元素的直接后继
Status NextList(LinkList L, ElemType& e) {
	int i = 0;
	LinkList p;
	p = L;
	while (p != NULL)
	{
		if (p->data == e)
		{
			if (p->next != NULL)
				return p->next->data;
			else
				return ERROR;
		}
		p = p->next;
	}
	return ERROR;
}
//9.在第i个位置插入一个元素
Status ListInsert(LinkList& L, int i, ElemType& e) {
	LinkList p, s;
	p = L;
	int j = 0;
	while (p && j < i - 1) {
		p = p->next;
		++j;
	}
	if (!p || j > i - 1) {
		return ERROR;
	}
	s = (LinkList)malloc(sizeof(Lnode));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return OK;
}

//10.删除第i个元素
Status ListDelete(LinkList& L, int i) {
	LinkList p, s;
	int j = 0;
	p = L;
	while (p->next && j < i - 1) {
		p = p->next;
		++j;
	}
	if (!p->next || j > i - 1) {
		return ERROR;
	}
	s = p->next;
	p->next = s->next;
	free(s);
	return OK;
}

//11.输出所有的链表元素
Status OutPutList(LinkList& L) {
	LinkList p;
	p = L;
	if (p->next == NULL) {//当链表为空时，直接输出错误
		return ERROR;
	}
	while (p->next != NULL) {
		p = p->next;
		cout << p->data << "  ";
	}
	return OK;
}
//12.初始化并用头插法（或尾插法）输入元素
// 头插法
Status HeadList(LinkList& L, int n) {
	LinkList p;
	int i;
	L = (LinkList)malloc(sizeof(Lnode));
	L->next = NULL;
	for (i = n;i > 0;i--) {
		p = (LinkList)malloc(sizeof(Lnode));
		cin >> p->data;
		p->next = L->next;
		L->next = p;
		//L->next = L;
	}
	OutPutList(L);
	return OK;
}
// 尾插法
Status TailList(LinkList& L, int n, ElemType& e) {
	LinkList p, q;
	int i;
	L = (LinkList)malloc(sizeof(Lnode));
	L->next = NULL;
	p = L;
	for (i = 0;i < n;i++) {
		q = (LinkList)malloc(sizeof(Lnode));
		cin >> e;
		q->data = e;
		q->next = NULL;
		p->next = q;
		p = p->next;
	}
	OutPutList(L);
	return OK;
}
//13.实现单链表的逆序存放
Status ListInverse(LinkList& L) {
	LinkList p, q;
	p = L->next;
	L->next = NULL;
	while (p) {
		q = p;
		///
		p = p->next;
		q->next = L->next;
		L->next = q;
	}
	OutPutList(L);
	return OK;
}

int main() {
	LinkList L = 0;
	bool initlist = false;
	ElemType e = 0;
	int op = 0;
	int i;
	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.在第i个位置插入一个元素" << endl;
	cout << "10.删除第i个元素" << endl;
	cout << "11.输出所有的链表元素" << endl;
	cout << "12.初始化并用头插法（或尾插法）输入元素" << endl;
	cout << "13.实现单链表的逆序存放" << endl;
	cout << "输入一个负数，退出程序" << endl;
	int n = 1;
	while (n) {
		int select;
		cout << "------------------------------------" << endl;
		cout << "请输入你选择的功能：";
		cin >> select;
		switch (select) {
		case 1:
			if (InitList(L)) {
				initlist = true;
				cout << "链表初始化成功" << endl;
			}
			else {
				cout << "错误，链表初始化失败" << endl;
			}
			break;
		case 2:
			if (initlist == true) {
				if (DeleteList(L)) {
					initlist = false;
					cout << "链表销毁成功" << endl;
				}
			}
			else {
				cout << "请先初始化链表" << endl;
			}
			break;
		case 3:
			if (initlist == true) {
				if (ClearList(L)) {
					cout << "链表已清空" << endl;
				}
				else {
					cout << "链表为空" << endl;
				}
			}
			else {
				cout << "请先初始化链表" << endl;
			}
			break;
		case 4:
			if (initlist == true) {
				if (ListLength(L)) {
					cout << "链表长度为" << ListLength(L) << endl;
				}
				else {
					cout << "链表为空" << endl;
				}
			}
			else {
				cout << "请先初始化链表" << endl;
			}
			break;
		case 5:
			if (initlist == true) {
				if (L->next != NULL) {
					do {
						cout << "请输入你要获取元素的位置：";
						cin >> i;
						if (GetElem(L, i, e)) {
							cout << "第" << i << "个元素为：" << GetElem(L, i, e) << endl;
						}
						else {
							cout << "你要获取的位置错误" << endl;
						}
						cout << "1.继续 2.退出" << "  ";
						cin >> op;
					} while (op == 1);
				}
				else {
					cout << "链表为空" << endl;
				}
			}
			else {
				cout << "请先初始化链表" << endl;
			}
			break;
		case 6:
			if (initlist == true) {
				if (L->next != NULL) {
					do {
						int i = 1;
						cout << "请输入你要获取位置的元素：";
						cin >> e;
						if (ListLocate(L, i, e)) {
							cout << "元素" << e << "的位序是：" << i << endl;
						}
						else {
							cout << "此元素不存在" << endl;
						}
						cout << "1.继续 2.退出" << "  ";
						cin >> op;
					} while (op == 1);
				}
				else {
					cout << "链表为空" << endl;
				}
			}
			else {
				cout << "请先初始化链表" << endl;
			}
			break;
		case 7:
			if (initlist == true) {
				if (L->next != NULL) {
					cout << "请输入你要求前驱的元素:";
					cin >> e;
					i = 1;
					if (PriorList(L, e) == ERROR) {
						cout << "首元素无前驱或元素不存在" << endl;
					}
					else {
						cout << "元素" << e << "的前驱为：" << PriorList(L, e) << endl;
					}
				}
				else {
					cout << "链表为空" << endl;
				}
			}
			else {
				cout << "请先初始化链表" << endl;
			}
			break;
		case 8:
			if (initlist == true) {
				cout << "请输入你要求后继的元素:";
				cin >> e;
				if (NextList(L, e) == ERROR) {
					cout << "尾元素无后继或元素不存在" << endl;
				}
				else {
					cout << "元素" << e << "的后继为：" << NextList(L, e) << endl;
				}
			}
			else {
				cout << "请先初始化链表" << endl;
			}
			break;
		case 9:
			if (initlist == true) {
				int lo;
				do {
					int i = ListLength(L);
					cout << "请输入你要插入的位置：";
					cin >> lo;
					if (lo <= 0) {
						cout << "插入位置过小" << endl;
					}
					else if (lo > i + 1) {
						cout << "插入位置过大" << endl;
					}
					else {
						cout << "请输入你要插入的元素：";
						cin >> e;
						if (ListInsert(L, lo, e)) {
							cout << "插入成功" << endl;
						}
						else {
							cout << "插入失败" << endl;
						}
					}
					cout << "1.继续 2.退出" << "  ";
					cin >> op;
				} while (op == 1);
			}
			else {
				cout << "请先初始化链表" << endl;
			}

			break;
		case 10:
			if (initlist == true) {
				if (L->next != NULL) {
					do {
						cout << "请输入你要删除的位置：";
						cin >> i;
						if (ListDelete(L, i)) {
							cout << "删除成功" << endl;
						}
						else {
							cout << "删除位置错误" << endl;
						}
						cout << "1.继续 2.退出" << "  ";
						cin >> op;
					} while (op == 1);
				}
				else {
					cout << "链表为空" << endl;
				}
			}
			else {
				cout << "请先初始化链表" << endl;
			}
			break;
		case 11:
			if (initlist == true) {
				if (L->next != NULL) {
					OutPutList(L);
					cout << endl;
				}
				else {
					cout << "链表为空" << endl;
				}
			}
			else {
				cout << "请先初始化链表" << endl;
			}
			break;
		case 12:
		{cout << "1.初始化并用头插法输入元素" << endl;
		cout << "2.初始化并用尾插法输入元素" << endl;
		cout << "输入负数退出程序" << endl;
		cout << "请输入你的选择：";
		int i;
		cin >> op;
		switch (op) {
		case 1:
			cout << "头插法输入元素" << endl;
			cout << "请输入你要插入的元素个数：";
			cin >> i;
			cout << "请输入你要插入的元素：";
			HeadList(L, i);
			initlist = true;
			cout << endl;
			break;
		case 2:
			cout << "尾插法输入元素" << endl;
			cout << "请输入你要插入的元素个数：";
			cin >> i;
			cout << "请输入你要插入的元素：";
			TailList(L, i, e);
			initlist = true;
			cout << endl;
			break;
		default:
			if (op < 0) {
				cout << "退出程序" << endl;
			}
		}
		break;
		case 13:
			if (initlist == true) {
				if (L->next != NULL) {
					ListInverse(L);
					cout << endl;
				}
				else {
					cout << "链表为空" << endl;
				}
			}
			else {
				cout << "请先初始化链表" << endl;
			}
			break;
		default:
			if (select < 0) {
				cout << "退出程序" << endl;
				n = 0;
			}
		}
		}
	}
}

数据结构实验3 单链表的基本操作实现
Far_Rainbow的博客
10-29 2285
姓名：Far_Rainbow 学号： 202505000X 专业： 软件工程 年级：2020级 实验名称：实验3 单链表的基本操作实现 实验内容： （1）实验目的 通过该实验，深入理解链表的逻辑结构、物理结构等概念，掌握链表基本操作的编程实现，熟练掌握C语言中指针的操作。和实验2对比，掌握线性结构两种不同存储方式的区别。 （2）实验内容 编程实现链表下教材第二章定义的线性表的基本操作，最好用菜单形式对应各个操作，使其编程一个完整的小软件。注意，每个功能模块一定要考虑非法的情况，并作出相应的提示，例如：求前
数据结构实验三（单链表）
m0_57272576的博客
10-26 334
#include <stdio.h> #include <iostream> #include<stdlib.h> using namespace std; #define OK 1 #define ERROR 0 #define OVERFLOW -1 typedef int Status; typedef int ElemType; typedef struct LNode{ ElemType dat...
实验3 链表的基本操作
qq_40772639的博客
10-18 264
头文件： #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;
数据结构 单链表的基本操作实现代码
wu____nai的博客
10-30 1880
实验3、单链表的基本操作实现 （1）实验目的 通过该实验，深入理解链表的逻辑结构、物理结构等概念，掌握链表基本操作的编程实现，熟练掌握C语言中指针的操作。和实验3对比，掌握线性结构两种不同存储方式的区别。 （2）实验内容 编程实现链表下教材第二章定义的线性表的基本操作，最好用菜单形式对应各个操作，使其编程一个完整的小软件。注意，每个功能模块一定要考虑非法的情况，并作出相应的提示，例如：求前驱，要分别能够测试第一个元素的前驱、其他正常的元素的前驱、输入一个在表中不存在的元素求其前驱，这三种情况应给出相应的提示
链表的操作实验
夏日漱石的博客
05-12 1630
单链表
数据结构--单链表操作实验报告
04-12
1.从键盘输入顺序任意的5个整数，按有序插入的要求生成第一个有序单链表，将该链表输出显示。...3.将这两个有序单链表合并成一个有序单链表，要求使用两个单链表的原有空间进行合并，将生成的有序单链表输出显示。
数据结构-单链表-实验报告.rar_C++_tripk8z_单链表_单链表实验_实验报告
09-21
（2）验证单链表及其基本操作的实现； （3）进一步理解算法与程序的关系，能够将单链表算法转换为对应的程序。 1.2 实验要求： （1）用头插法（或尾插法）建立带头结点的单链表； （2）对已建立的单链表实现插入、...
数据结构--单链表操作--实验报告.doc
07-11
在本实验中，我们关注的是单链表的创建、查找、插入和合并等基本操作。实验的目标是通过Visual C++编程语言来熟悉程序设计，并掌握单链表的操作。 1. **单链表的创建**： 创建单链表通常从一个空链表开始，然后...
数据结构实验报告--单链表.docx
07-11
数据结构实验报告的主题聚焦于单链表这一基本的数据结构，它是计算机科学中处理动态数据集合的重要工具。单链表是一种线性数据结构，其特点在于每个节点包含两个部分：一个是用于存储数据的数据域，另一个是用于指向...
《数据结构》实验三：单链表
Wayne_Xiaowei的博客
05-05 1141
《数据结构》实验三：                 线性表综合实验 一．实验目的      巩固线性表的数据结构的存储方法和相关操作，学会针对具体应用，使用线性表的相 关知识来解决具体问题。 二．实验时间    准备时间为第 7 周到第 8 周，具体集中实验时间为第 4 周第 2 次课。2 个学时。 三．实验内容 1.建立一个由 n 个学生成绩的顺序表，n 的大小由自己确定，每一个学生的成绩信息...
实验二：链表的基本操作的实验报告
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)
数据结构（初阶 三）单链表的实现
qq_45559559的博客
08-13 1150
顺序表的实现及相关试题
python3 链表_数据结构与算法的Python实现（三）——线性表之链表
weixin_39940714的博客
11-26 293
上一篇中我提到线性表的另一种实现——链表，这一篇就主要讲链表。一、链表的概念和基本思想（一）链表的概念线性表的一个基本特性就是元素的序列关系，顺序表虽然没有直接指明序列关系，但因为保存在了连续的存储空间内，所以形成了这种关系。我们也可以不把元素连续存储，而在每个元素中指明序列关系，这样就也可以实现线性表了，基于这种链接结构的线性表，就叫做链表。（二）实现链表的基本思想1.表中的每一个元素都独立存储...
数据结构实验三之单链表.
TJYYYM的博客
05-01 537
2..建立一个由n个学生成绩的顺序表，实现对数据的插入，删除，查找等操作。源代码：#ifndef Student_H#define Student_Htemplate&lt;class DataType&gt;struct Node{ DataType data; Node&lt;DataType&gt;*next;};template&lt;class DataType&gt;class Stu...
数据结构实验4：链表的基本操作
最新发布
weixin_58628068的博客
01-10 1723
尾插法是一种在单链表中插入节点的方法，它将新节点插入到链表的尾部。相对于头插法，尾插法需要遍历整个链表找到尾节点，然后在尾节点之后插入新节点。在链表中查找元素的操作通常包括遍历链表，逐一比较节点的值，直到找到匹配的元素或者到达链表的末尾。带头结点的循环双向链表在链表尾部连接到头结点，同时每个节点都有一个指向前一个节点的指针。头插法是一种在单链表中插入节点的方法，它将新节点插入到链表的头部，成为新的头结点。每个节点有两个指针，一个指向前一个节点，另一个指向下一个节点。尾节点的指针指向头节点，形成一个闭环。
数据结构 实验二 链表的基本操作
TXYGoodluck的博客
09-25 9318
链表的基本操作 任务一：单链表的生成和输出 任务描述： 从键盘输入数据，创建一个初始链表。通过调用定义的基本操作函数来实现单链表上的插入、删除元素等操作。调试程序并对相应的输出作出分析；修改输入数据，预期输出并验证输出的结果。加深对有关算法的理解。 相关知识： 为了完成本关任务，你需要掌握： 1.尾插法建立单链表 2.单链表的遍历（输出） - 尾插法建立单链表 本关任务：尾插法是通过将新结点逐个插入到链表的尾部来创建链表。同前插法一样,每次申请一个新结点,读入相应的数据元素值。不同的是,为了使新结点能够插入
【数据结构实验】单链表实验
山风不打咩的博客
04-01 5924
实验内容 1、利用头插法或尾插法建立单链表 2、对已建立的单链表实现插入、删除等基本操作； 3、输出链表所有结点数据 4、编写算法将这两个单链表归并为一个按元素值递减次序排列的单链表并计算表长。.........
实验三 链表的实现和应用（第4-5周）
我要吃木耳的博客
10-17 434
实验目的： 掌握线性表的链式存储结构设计与基本操作的实现。 实验内容与要求： ⑴定义线性表的链式存储表示； ⑵基于所设计的存储结构实现线性表的基本操作； ⑶编写一个主程序对所实现的线性表进行测试； ⑷线性表的应用：①设线性表L1和L2分别代表集合A和B，试设计算法求A和B的并集C，并用线性表L3代表集合C（无重复元素）；②设线性表L1和L2中的数据元素为整数，且均已按值非递减有序排列，试设计算法对L1和L2进行合并，用线性表L3保存合并结果（无重复元素），要求L3中的数据元素...
数据结构3--深入了解单向链表的实现
cainiaochufa2021的博客
03-17 977
文章目录链表1.从顺序表到链表1.1用指针来实现链表中空间的联系1.2创建一个节点1.3头指针、第一个节点和最后一个节点头指针的创建2.管理链表中的元素2.1访问链表中的各个元素2.1.1打印链表2.1.2在链表中查找数据2.1.3改变链表中某一个节点的值2.2创建新的节点2.3在链表中添加节点2.3.1在链表的末尾添加节点2.3.2在链表的头部添加节点2.3.3在链表的指定位置添加节点在指定位置的前面添加节点在链表的指定位置后面添加节点2.4删除链表中的节点2.4.1删除链表最后一个节点2.4.2删除链表
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

用户1234567890

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

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

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

打赏作者

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

抵扣说明：

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

余额充值