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

最新推荐文章于 2023-01-17 19:34:56 发布
最新推荐文章于 2023-01-17 19:34:56 发布
阅读量2k 收藏 15
点赞数 3
分类专栏： 作业 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50299150/article/details/121044802
版权

姓名：Far_Rainbow
学号： 202505000X
专业： 软件工程
年级：2020级

实验名称：实验3 单链表的基本操作实现

实验内容：

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

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

（3）实验要求：
菜单项包括：

  1. 初始化或重置链表
  2. 销毁链表
  3. 清空链表
  4. 链表长度
  5. 指定位置的元素值
  6. 链表已存在元素的位序
  7. 求输入元素的直接前驱
  8. 求输入元素的直接后继
  9. 在第i个位置插入一个元素
  10. 删除第i个元素
  11. 输出有的链表元素
  12. 初始化并用头插法（或尾插法）输入元素
  13. 实现单链表的逆序存放
    要求：所有的提示语和输出语句不允许出现在自定义的函数中，只能在main函数中出现提示语。
    注：销毁链表时需要循环释放每个结点所占用的空间。
    注：求前驱是指，输入一个元素值（而不是位置），求该元素在顺序表中的直接前驱元素值。求后继是指：输入一个元素值（而不是位置），求该元素在顺序表中的直接后继元素值。

（4）验收/测试用例
参考实验2

实验类型：验证性

实验的重难点：链表的定义和实现

实验环境：TDM-GCC 4.9.2 64-bit

实验步骤及完成任务情况：

一、设计思想

  1. 采用模板实现泛型编程，可创建任意数据类型的单链表；
  2. 采用链式存储方式，插入删除时间复杂度都是 O ( 1 ) O(1) O(1)

二、主要源代码

#include <iostream>
using std::cin;
using std::cout;
using std::endl;

template <typename T> struct Lnode {
	T data;
	Lnode<T>* next;
};

template <typename T> class List {
private:
	int _length;
	Lnode<T>* header;
	
public:
	void init() {header = new Lnode<T>; header->next = NULL; _length = 0;}
	void destroy();
	void clear();
	List() {header = NULL; }
	~List() {destroy(); }
	bool exist() const {return header != NULL ? 1 : 0;} 
	bool isempty() const {return _length > 0 ? 0 : 1; }
	int getlength() const {return _length; }
	Lnode<T>* find(int pos);
	int elemlocate(T const& e);
	Lnode<T>* priornode(T const& e);
	Lnode<T>* nextnode(T const& e);
	Lnode<T>* insert(int pos, T const& e);
	T remove(int pos);
	void traverse();
	void create(int n);
	Lnode<T>* reverse();
};

template <typename T> void List<T>::destroy()
{
	if (!exist())	return;
	Lnode<T>* p = header, *q;
	while(p){
		q = p->next;
		delete p;
		p = q;
	}
	header = NULL;
	_length = 0;
}

template <typename T> void List<T>::clear()
{
	Lnode<T>* p = header->next, *q;
	while(p){
		q = p->next;
		delete p;
		p = q;
	}
	_length = 0;
}

template <typename T> Lnode<T>* List<T>::find(int pos)
{
	int count = 0;
	Lnode<T>* p = header->next;
	while(p){
		count ++;
		if(count == pos)	return p;
		p = p->next;
	}
	return NULL;
}

template <typename T> int List<T>::elemlocate(T const& e)
{
	int count = 0;
	Lnode<T>* p = header->next;
	while(p)
	{
		count ++;
		if(p->data == e)	return count;
		p = p->next;
	}
	return 0;
}

template <typename T> Lnode<T>* List<T>::priornode(T const& e) //
{
	Lnode<T>* p = header->next, *q;
	while(p)
	{
		q = p->next;
		if(q && q->data == e)	return p;
		p = q;
	}
	return NULL;
}

template <typename T> Lnode<T>* List<T>::nextnode(T const& e) //
{
	Lnode<T>* p =header->next, *q;
	while(p){
		q = p->next;
		if(q && p->data == e)	return q;
		p = q;
	}
	return NULL;
}

template <typename T> Lnode<T>* List<T>::insert(int pos, T const& e)
{
	int count = 0;
	Lnode<T>* p = header; //注意考虑插入到首元结点的位置，故不用p=header->next; 
	Lnode<T>* q = new Lnode<T>;
	q->data = e;
	while(p){
		count ++;
		if(count == pos){
			q->next = p->next;
			p->next = q;
			++ _length;
			return q;
		}
		p = p->next;
	}
	return NULL;
}

template <typename T> T List<T>::remove(int pos) // 删不了第一个元素 和非法情况 
{
	int count = 0;
	Lnode<T>* p = header->next, *q;
	while(p)
	{
		q = p->next;
		count ++;
		if(count == pos-1){
			p->next = q->next;
			T e = q->data;
			delete q;
			-- _length;
			return e ;
		}
		p = q;
	}
}

template <typename T> void List<T>::traverse()
{
	Lnode<T>* p = header->next;
	while(p){
		cout<<p->data<<' ';
		p = p->next;
	}
}

template <typename T> void List<T>::create(int n)
{
	Lnode<T>* p;
	while(n --)
	{
		p = new Lnode<T>;
		cout<<"请输入想要插入的值：";
		cin>>p->data;
		p->next = header->next;
		header->next = p;
		++ _length;
	}
}

template <typename T> Lnode<T>* List<T>::reverse()
{
	if(header == NULL || header->next == NULL)	return header;
	Lnode<T>* now = header->next, *pre = NULL, *next = NULL;
	while(now){
		next = now->next;
		now->next = pre;
		pre = now;
		now = next;
	}
	header->next = pre;
	return header;
}

int main()
{
	cout<<"\n   基单链表的基本操作实现\n\n";
	cout<<"1---初始化一个单链表\n";
	cout<<"2---销毁单链表\n";
	cout<<"3---清空单链表\n";
	cout<<"4---求单链表长度\n";
	cout<<"5---获取线性表中指定位置的元素\n";
	cout<<"6---获取单链表元素的位置\n";
	cout<<"7---求前驱\n";
	cout<<"8---求后继\n";
	cout<<"9---在单链表指定位置插入元素\n";
	cout<<"10--删除单链表指定位置的元素\n";
	cout<<"11--显示单链表\n";
	cout<<"12--初始化并用头插法输入元素\n";
	cout<<"13--实现单链表的逆序存放\n"; 
	cout<<"\n\t退出，输入一个负数！\n\n";
	List<int> L;
	while(true)
	{
		int myOption;
		cout<<"\n请输入操作序号：";
		cin>>myOption;
		switch(myOption){
			case 1:{
				if(L.exist()){
					cout<<"初始化失败，单链表已存在！\n";
					break; 
				}
				L.init();
				cout<<"初始化成功!\n";
				break;
			}
			case 2:{
				if (!L.exist()){
					cout<<"销毁失败，单链表不存在\n";
					break; 
				}
				L.destroy();
				cout<<"销毁成功！\n";
				break;
			} 
			case 3:{
				if (!L.exist()){
					cout<<"清空失败，单链表不存在\n";
					break; 
				}
				if (L.isempty()) ; 
				else	L.clear();
				cout<<"清空成功！\n"; 
				break;
			}
			case 4:{
				if (!L.exist()){
					cout<<"请先创建单链表！\n";
					break; 
				}
				cout<<"单链表的长度是"<<L.getlength()<<endl; 
				break;
			}
			case 5:{
				if (!L.exist()){
					cout<<"单链表不存在，请先创建单链表！\n";
					break; 
				}
				if (L.isempty()){
					cout<<"单链表为空，请先插入元素！\n";
					break;
				}
				cout<<"请输入你要获取元素的位置：";
				int pos;
				cin>>pos;
				Lnode<int>* ptr = L.find(pos);
				if (!ptr) {
					cout<<"不存在该位置的元素\n";
					break;
				}
				cout<<"第"<<pos<<"位元素是 "<<ptr->data<<endl; 
				break;
			}
			case 6:{
				if (!L.exist()){
					cout<<"单链表不存在，请先创建单链表！\n";
					break; 
				}
				if (L.isempty()){
					cout<<"单链表为空，请先插入元素！\n";
					break;
				}
				cout<<"请输入您要获取位置的元素：";
				int e;
				cin>>e;
				if (!L.elemlocate(e)){
					cout<<"单链表中不存在该元素！\n";
					break;
				}
				cout<<"元素"<<e<<"的位置是"<<L.elemlocate(e)<<endl; 
				break;
			}
			case 7:{
				if (!L.exist()){
					cout<<"单链表不存在，请先创建单链表！\n";
					break; 
				}
				if (L.isempty()){
					cout<<"单链表为空，请先插入元素！\n";
					break;
				}
				cout<<"请输入您要获取前驱的元素：";
				int pos, e;
				cin>>e;
				Lnode<int>* ptr = L.priornode(e);
				if (!ptr){
					cout<<"获取失败，该元素不存在或无前驱！\n";
					break; 
				}
				cout<<"元素"<<e<<"的前驱元素是"<<(ptr-1)->data<<endl;
				break;
			}
			case 8:{
				if (!L.exist()){
					cout<<"单链表不存在，请先创建单链表！\n";
					break; 
				}
				if (L.isempty()){
					cout<<"单链表为空，请先插入元素！\n";
					break;
				}
				cout<<"请输入您要获取后继的元素：";
				int e;
				cin>>e;
				Lnode<int>* ptr = L.nextnode(e);
				if (!ptr){
					cout<<"获取失败，该元素不存在或无后继！\n";
					break; 
				}
				cout<<"元素"<<e<<"的后继元素是"<<(ptr+1)->data<<endl;
				break;
			}
			case 9:{
				if (!L.exist()){
					cout<<"单链表不存在，请先创建单链表！\n";
					break; 
				}
				cout<<"请输入指定位置：";
				int pos;
				cin>>pos;
				cout<<"请输入想要插入的值：";
				int e;
				cin>>e;
				if (!L.insert(pos, e)){
					cout<<"插入失败，请重新尝试！\n";
					break;
				}
				else	cout<<"插入完毕！\n";
				break;
			}
			case 10:{
				if (!L.exist()){
					cout<<"单链表不存在，请先创建单链表！\n";
					break; 
				}
				if (L.isempty()){
					cout<<"单链表为空！\n";
					break;
				}
				cout<<"请输入你要删除的元素的位置：";
				int pos;
				cin>>pos;
				int e = L.remove(pos);
				if (!e){
					cout<<"删除失败，请重新尝试！\n";
					break;
				}
				else	cout<<"删除完毕！"<<"被删除的元素是"<<e<<endl;;
				break;
			}
			case 11:{
				if (!L.exist()){
					cout<<"单链表不存在，请先创建单链表！\n";
					break; 
				}
				if (L.isempty()){
					cout<<"单链表为空！\n";
					break;
				}
				cout<<"单链表的所有元素是：";
				L.traverse();
				cout<<endl;
				break;
			} 
			case 12:{
				if (!L.exist()){
					cout<<"单链表不存在，请先创建单链表！\n";
					break; 
				}
				cout<<"请输入你想插入的元素个数：";
				int n;
				cin>>n;
				L.create(n);
				break;
			} 
			case 13:{
				if (!L.exist()){
					cout<<"单链表不存在，请先创建单链表！\n";
					break; 
				}
				if (L.isempty()){
					cout<<"单链表为空！\n";
					break;
				}
				cout<<"逆置前的单链表为：";
				L.traverse();
				cout<<endl<<"逆置后的单链表为：";
				L.reverse();
				L.traverse();
				cout<<endl;
				break;
			}
		}
		if(myOption >13 || myOption == 0)	cout<<"\n请输入小于13的正整数\n\n";
		if(myOption < 0){
			cout<<"\n退出程序！\n";
			break;
		}
	} 
	return 0;
}
Far_Rainbow
关注
  • 3
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构--单链表操作实验报告
04-12
1.从键盘输入顺序任意的5个整数，按有序插入的要求生成第一个有序单链表，将该链表输出显示。...3.将这两个有序单链表合并成一个有序单链表，要求使用两个单链表的原有空间进行合并，将生成的有序单链表输出显示。
单链表的基本操作实现
12-17
单链表的基本操作的实现，这个程序中演示了单链的初始化、前插法、后插法、单链表删除、查找以及输出等功能。使用c语言所写。
数据结构--单链表
weixin_49334154的博客
11-03 326
功能 1-----初始化或重置链表 2-----销毁单链表 3-----清空单链表 4-----求单链表长度 5-----获取单链表中指定位置的元素 6-----获取单链表指定元素的位序 7-----求输入元素的直接前驱 8-----求输入元素的直接后继 9-----在单链表第i个位置插入元素 10----删除单链表第i个位置的元素 11----输出单链表所有的的元素 12----初始化并用头插法输入元素 13----初始化并用尾插法输入元素 14----实现单链表的逆序存放 15----判断单链表是否为.
建立单链表存储数据（10，20，30，40，50，60，70，80，90,100）
l664474618的博客
03-29 3801
题目： 建立单链表存储数据（10，20，30，40，50，60，70，80，90,100），要求： （1）头插法或尾插法建立单链表，并输出单链表中所有元素； （2）输出单链表中的最大值和最小值； （3）键盘输入一个值x，输出链表中第一个值为x的元素的位序； （4）键盘输入一位序值b，在第b个元素之前插入值为500的元素，输出链表中的所有数据； （5）键盘输入位序值m，删除位序为m的元素，输出链表中的所有数据； （6）输出单链表的长度。 #include <stdio.h> #include &l
【C/C++数据结构实验】-实验3.链表基本操作的实现
bon_e_的博客
05-25 1053
【C/C++数据结构实验】这个系列是我这个学期上的数据结构课上老师布置的实验，实验题目如下。我一般用c++，但是没有用到类啥的，就是普普通通的面向过程的思想不是面向对象的思想，只是借用c++的一些方便的环境，比如形参处可以写——*&，引用型参数很好用。 有需要的同学们自取吧，虽然算法不是很巧妙，但是都是我实实在在学完了自己一点点写出来的，运行结果是完全没问题的。正好这门课结课了，发上来我也能再复习一下！
链式存储线性表（有头结点）
xyang
11-23 1208
/* * *数据结构 *链式存储线性表（有头结点） */ #include #include using namespace std; typedef int ElemType; typedef struct LNode { ElemType data; struct LNode *next; }LNode,*LinkList;//LNode 结构体类型，LinkList 结构体指针类
数据结构 【实验3 链表基本操作】
weixin_33754913的博客
03-28 648
实验3  链表基本操作 实验目的 1．  定义单链表的结点类型。 2．  熟悉对单链表的一些基本操作和具体的函数定义。 3．  通过单链表的定义掌握线性表的链式存储结构的特点。 4．  掌握循环链表和双链表的定义和构造方法。 实验内容 该程序的功能是实现单链表的定义和操作。该程序包括单链表结构类型以及对单链表操作的具体的函数定义和主函数。程序中的单链表（带头结点）结点为结构类型，结点...
头歌数据结构单链表的基本操作
05-18
头歌数据结构单链表的基本操作 第1关单链表的插入操作 第2关单链表的删除操作 第3关单链表的按照序号查找值操作 第4关单链表的按照值查找结点位序的操作 第5关单链表的逆置操作 第6关两个有序单链表的合并操作 稳过 ...
数据结构单链表的基本操作实现(包含源代码)上机报告
07-13
本实验报告旨在通过C++实现单链表的基本操作，包括初始化、销毁、建表、清空、判断是否为空、求表长、遍历、取值、插入、删除和查找，以及一些进阶应用，如链表的逆序和集合操作。 首先，我们定义单链表的抽象数据...
数据结构实验，单链表的实现.rar_单链表_数据结构实验
09-21
总之，这个实验旨在让你熟悉数据结构中的单链表，理解其工作原理，并能够用C语言编写相关的操作函数。熟练掌握单链表有助于提升你在数据结构和算法方面的技能，这对于任何IT专业人员来说都是至关重要的。
数据结构实现单链表的基本操作
06-24
主要是单链表中元素的插入，删除，还有转置，用C++编写的
顺序表链表（含菜单）的基本操作
11-02
基本的线性表操作，含菜单，线性表的插入，删除，查找，销毁，判断是否为空
【数据结构】C语言实现链表操作
Stafen_的博客
02-18 3621
链表：线性表的链式存储结构详细操作教程
数据结构实验3---单链表的基本操作实现
qq_62474991的博客
12-06 494
重点： 链表的定义和实现 难点： 单链表的逆序存放
【单链表基本操作的实现】学习笔记
最新发布
ABCeverydaY的博客
01-17 100
即构造一个如图的空表。
单链表的基本操作
weixin_34015566的博客
01-19 87
链表概述　　链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。它可以根据需要开辟内存单元。链表有一个“头指针”变量，以head表示，它存放一个地址。该地址指向一个元素。链表中每一个元素称为“结点”，每个结点都应包括两个部分：一为用户需要用的实际数据，二为下一个结点的地址。因此，head指向第一个元素：第一个元素又指向第二个元素；……，直到最后一个元素，该元素...
数据结构 C语言 实现单链表的各种基本操作
WindsProgrammer的博客
06-01 5516
大概写了150多行，都是很基础的操作。需要的自取。 （书籍为数据结构教程（第五版）李春葆） 实验内容 实验三 链表基本操作的实现 【实验目的】 1．掌握线性表的链式存储表示。 2．掌握单链表的基本操作，包括创建、查找、插入和删除等算法。 【实验内容】 编写程序linklist.cpp，实现单链表的各种基本运算（假设单链表的元素类型为char），并在此基础上设计主程序main.cpp，完成如下功能： 1．初始化单链表； 2．依次采用尾插法插入元素a，b，c，d，e； 3．输出单链表； 4．判断单链表的长度；
数据结构 单链表的基本操作实现代码
wu____nai的博客
10-30 1752
实验3、单链表的基本操作实现 （1）实验目的 通过该实验，深入理解链表的逻辑结构、物理结构等概念，掌握链表基本操作的编程实现，熟练掌握C语言中指针的操作。和实验3对比，掌握线性结构两种不同存储方式的区别。 （2）实验内容 编程实现链表下教材第二章定义的线性表的基本操作，最好用菜单形式对应各个操作，使其编程一个完整的小软件。注意，每个功能模块一定要考虑非法的情况，并作出相应的提示，例如：求前驱，要分别能够测试第一个元素的前驱、其他正常的元素的前驱、输入一个在表中不存在的元素求其前驱，这三种情况应给出相应的提示
实验三 链表的实现和应用（第4-5周）
我要吃木耳的博客
10-17 351
实验目的： 掌握线性表的链式存储结构设计与基本操作的实现。 实验内容与要求： ⑴定义线性表的链式存储表示； ⑵基于所设计的存储结构实现线性表的基本操作； ⑶编写一个主程序对所实现的线性表进行测试； ⑷线性表的应用：①设线性表L1和L2分别代表集合A和B，试设计算法求A和B的并集C，并用线性表L3代表集合C（无重复元素）；②设线性表L1和L2中的数据元素为整数，且均已按值非递减有序排列，试设计算法对L1和L2进行合并，用线性表L3保存合并结果（无重复元素），要求L3中的数据元素...
实验：单链表基本操作实现与应用
3. 实验步骤：实验分为两个主要阶段：数据结构的设计和核心算法的实现。数据结构部分涉及链表节点的定义和内存管理；核心算法则是如何高效地实现链表操作，比如通过迭代或递归方法来查找、插入和删除元素，以及如何...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值