数据结构实验1
《数据结构》实验报告模板(附实例)--实验一线性表的基本操作实现
《数据结构》实验报告模板(附实例)---实验一线性表的基本操作实现实验一线性表的基本操作实现及其应用一、实验目的1、熟练掌握线性表的基本操作在两种存储结构上的实现,其中以熟悉各种链表的操作为重点。
2、巩固高级语言程序设计方法与技术,会用线性链表解决简单的实际问题。
二、实验内容√ 1、单链表的表示与操作实现 ( * )2、约瑟夫环问题3、Dr.Kong的艺术品三、实验要求1、按照数据结构实验任务书,提前做好实验预习与准备工作。
2、加“*”题目必做,其他题目任选;多选者并且保质保量完成适当加分。
3、严格按照数据结构实验报告模板和规范,及时完成实验报告。
四、实验步骤(说明:依据实验内容分别说明实验程序中用到的数据类型的定义、主程序的流程以及每个操作(成员函数)的伪码算法、函数实现、程序编码、调试与分析、总结、附流程图与主要代码)㈠、数据结构与核心算法的设计描述(程序中每个模块或函数应加注释,说明函数功能、入口及出口参数)1、单链表的结点类型定义/* 定义DataType为int类型 */typedef int DataType;/* 单链表的结点类型 */typedef struct LNode{ DataType data;struct LNode *next;}LNode,*LinkedList;2、初始化单链表LinkedList LinkedListInit( ){ // 每个模块或函数应加注释,说明函数功能、入口及出口参数 }3、清空单链表void LinkedListClear(LinkedList L){// 每个模块或函数应加注释,说明函数功能、入口及出口参数}4、检查单链表是否为空int LinkedListEmpty(LinkedList L){ …. }5、遍历单链表void LinkedListTraverse(LinkedList L){….}6、求单链表的长度int LinkedListLength(LinkedList L){ …. }7、从单链表表中查找元素LinkedList LinkedListGet(LinkedList L,int i){ //L是带头结点的链表的头指针,返回第 i 个元素 }8、从单链表表中查找与给定元素值相同的元素在链表中的位置LinkedList LinkedListLocate(LinkedList L, DataType x){ …… }9、向单链表中插入元素void LinkedListInsert(LinkedList L,int i,DataType x) { // L 为带头结点的单链表的头指针,本算法// 在链表中第i 个结点之前插入新的元素 x}10、从单链表中删除元素void LinkedListDel(LinkedList L,DataType x){ // 删除以 L 为头指针的单链表中第 i 个结点 }11、用尾插法建立单链表LinkedList LinkedListCreat( ){ …… }㈡、函数调用及主函数设计(可用函数的调用关系图说明)㈢程序调试及运行结果分析㈣实验总结五、主要算法流程图及程序清单1、主要算法流程图:2、程序清单(程序过长,可附主要部分)说明:以后每次实验报告均按此格式书写。
数据结构课程设计实验1_城市链表
数据结构课程设计实验报告实验一链表部分选题为:2.4.3—城市链表1、需求分析(1)创建一个带有头结点的单链表。
(2)结点中应包含城市名和城市的位置坐标。
(3)对城市链表能够利用城市名和位置坐标进行有关查找、插入、删除、更新等操作。
(4)能够对每次操作后的链表动态显示。
2、概要设计为了实现以上功能,可以从以下3个方面着手设计。
(1)主界面设计为了实现城市链表相关操作功能的管理,设计一个含有多个菜单项的主控菜单子程序以系统的各项子功能,方便用户使用本程序。
本系统主控菜单运行界面如下所示。
(2)存储结构设计本系统主要采用链表结构类型来表示存储在“城市链表”中的信息。
其中链表结点由4个分量组成:城市名name、城市的横坐标posx、城市的纵坐标posy、指向下一个结点的指针next。
(3)系统功能设计本程序设计了9个功能子菜单,其描述如下:①建立城市链表。
由函数creatLink()实现。
该功能实现城市结点的输入以及连接。
②插入链表记录。
由函数insert()实现。
该功能实现按坐标由小到大的顺序将结点插入到链表中。
③查询链表记录。
由searchName()函数和searchPos()函数实现。
其中searchName()实现按照城市名查询的操作,searchPos()实现按照城市坐标查询的操作。
④删除链表记录。
由delName()函数和delPos()函数实现。
其中delName()函数实现按照城市名删除的操作,delPos()函数实现按照城市坐标删除的操作。
⑤ 显示链表记录。
由printList ()函数实现。
该功能实现格式化的链表输出操作,可以显示修改后的链表状态。
⑥ 更新链表信息。
由update ()函数实现。
该功能实现按照城市名更新城市的坐标信息。
⑦ 返回城市坐标。
由getPos ()函数实现。
该功能实现给定一个已存储的城市,返回其坐标信息的操作。
⑧ 查看与坐标P 距离小于等于D 的城市。
由getCity ()函数实现。
数据结构实验一顺序表
数据结构实验一1、实验目的∙掌握线性表的逻辑特征∙掌握线性表顺序存储结构的特点,熟练掌握顺序表的基本运算2、实验内容:建立顺序表,完成顺序表的基本操作:初始化、插入、删除、逆转、输出、销毁, 置空表、求表长、查找元素、判线性表是否为空;1.问题描述:利用顺序表,设计一组输入数据(假定为一组整数),能够对顺序表进行如下操作:∙创建一个新的顺序表,实现动态空间分配的初始化;∙根据顺序表结点的位置插入一个新结点(位置插入),也可以根据给定的值进行插入(值插入),形成有序顺序表;∙根据顺序表结点的位置删除一个结点(位置删除),也可以根据给定的值删除对应的第一个结点,或者删除指定值的所有结点(值删除);∙利用最少的空间实现顺序表元素的逆转;∙实现顺序表的各个元素的输出;∙彻底销毁顺序线性表,回收所分配的空间;∙对顺序线性表的所有元素删除,置为空表;∙返回其数据元素个数;∙按序号查找,根据顺序表的特点,可以随机存取,直接可以定位于第i 个结点,查找该元素的值,对查找结果进行返回;∙按值查找,根据给定数据元素的值,只能顺序比较,查找该元素的位置,对查找结果进行返回;∙判断顺序表中是否有元素存在,对判断结果进行返回;.编写主程序,实现对各不同的算法调用。
2.实现要求:∙“初始化算法”的操作结果:构造一个空的顺序线性表。
对顺序表的空间进行动态管理,实现动态分配、回收和增加存储空间;∙“位置插入算法”的初始条件:顺序线性表L 已存在,给定的元素位置为i,且1≤i≤ListLength(L)+1 ;操作结果:在L 中第i 个位置之前插入新的数据元素e,L 的长度加1;∙“位置删除算法”的初始条件:顺序线性表L 已存在,1≤i≤ListLength(L) ;操作结果:删除L 的第i 个数据元素,并用e 返回其值,L 的长度减1 ;∙“逆转算法”的初始条件:顺序线性表L 已存在;操作结果:依次对L 的每个数据元素进行交换,为了使用最少的额外空间,对顺序表的元素进行交换;∙“输出算法”的初始条件:顺序线性表L 已存在;操作结果:依次对L 的每个数据元素进行输出;∙“销毁算法”初始条件:顺序线性表L 已存在;操作结果:销毁顺序线性表L;∙“置空表算法”初始条件:顺序线性表L 已存在;操作结果:将L 重置为空表;∙“求表长算法”初始条件:顺序线性表L 已存在;操作结果:返回L 中数据元素个数;∙“按序号查找算法”初始条件:顺序线性表L 已存在,元素位置为i,且1≤i≤ListLength(L)操作结果:返回L 中第i 个数据元素的值∙“按值查找算法”初始条件:顺序线性表L 已存在,元素值为e;操作结果:返回L 中数据元素值为e 的元素位置;∙“判表空算法”初始条件:顺序线性表L 已存在;操作结果:若L 为空表,则返回TRUE,否则返回FALSE;分析: 修改输入数据,预期输出并验证输出的结果,加深对有关算法的理解。
《数据结构》实验1实验报告
南京工程学院实验报告<班级>_<学号>_<实验X>.RAR文件形式交付指导老师。
一、实验目的1.熟悉上机环境,进一步掌握语言的结构特点。
2.掌握线性表的顺序存储结构的定义及实现。
3.掌握线性表的链式存储结构——单链表的定义及实现。
4.掌握线性表在顺序存储结构即顺序表中的各种基本操作。
5.掌握线性表在链式存储结构——单链表中的各种基本操作。
二、实验内容1.顺序线性表的建立、插入及删除。
2.链式线性表的建立、插入及删除。
三、实验步骤1.建立含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。
2.利用前面的实验先建立一个顺序表L={21,23,14,5,56,17,31},然后在第i个位置插入元素68。
3.建立一个带头结点的单链表,结点的值域为整型数据。
要求将用户输入的数据按尾插入法来建立相应单链表。
四、程序主要语句及作用程序1的主要代码(附简要注释)public struct sequenlist{public const int MAXSIZE=1024; /*最大值为1024*/public elemtype[] vec;public int len; /* 顺序表的长度 */public sequenlist( int n){vec=new elemtype[MAXSIZE ];len = n;}};class Program{static void Main(string[] args){sequenlist list1 = new sequenlist(5);for (int i = 0; i < 5; i++){list1.vec[i] = i;}for (int i = 0; i < 5; i++){Console.Write("{0}---", list1.vec[i]) ;}Console.WriteLine("\n");Console.WriteLine("表长:{0}\n",list1.len );Console.ReadKey();}}程序2的主要代码(附简要注释)public void insertlist(int i, int x){if (len >= MAXSIZE)throw new Exception("上溢"); /*长度大于最大值则抛出异常*/if (i < 1 || i > len + 1)throw new Exception("位置");/插入位置小于1或大于len+1则抛出插入位置错误的异常for (int j = len; j >= i; j--)vec[j] = vec[j - 1]; //注意第j个元素存在数组下标为j-1处vec[i - 1] = x;len++;}};class Program{static void Main(string[] args){sequenlist list2 = new sequenlist(7);list2.vec[0] = 21;list2.vec[1] = 23;list2.vec[2] = 14;list2.vec[3] = 5;list2.vec[4] = 56;list2.vec[5] = 17;list2.vec[6] = 31;Console.Write("请输入第i个位置插入元素:");int loc =Convert.ToInt32( Console.ReadLine());Console.Write("请输入第{0}个位置插入的元素:", loc);int ele = Convert.ToInt32(Console.ReadLine());Console.WriteLine("插入前的线性表:");for (int i = 0; i < list2.len ; i++){Console.Write("{0}---", list2.vec[i]);}Console.WriteLine("\n");list2.insertlist(loc, ele);Console.WriteLine("插入后的线性表:");for (int i = 0; i < list2.len ; i++){Console.Write("{0}---", list2.vec[i]);}Console.WriteLine("\n");Console.ReadKey();}}程序3的主要代码(附简要注释)class Node{private int num;public int Num{set { num = value; }/输入值get { return num; }/获得值}private Node next;public Node Next{set { next = value; }get { return next; }}}class Pp{static void Main(string[] args){Node head;Node tempNode, tempNode1;int i;head = new Node();Console.WriteLine("输入六项数据:\n");Console.Write("输入第1项数据:");head.Num = Convert.ToInt32(Console.ReadLine());head.Next = null;tempNode = head;for (i = 1; i < 6; i++){tempNode1 = new Node();Console.Write("输入第{0}项数据:",i+1);tempNode1.Num = Convert.ToInt32(Console.ReadLine());/插入项转换为整形数值 tempNode1.Next = null;tempNode.Next = tempNode1;tempNode = tempNode.Next;}Console.WriteLine("线性表:");tempNode = head;for (i = 0; i < 6; i++){Console.Write("{0}", tempNode.Num);if (i < 5){Console.Write("--");}tempNode = tempNode.Next;}Console.ReadKey();}}五、程序运行结果截图程序1程序2程序3六、收获,体会及问题(写得越详细、越个性化、越真实越好,否则我不知道你做这个实验的心路历程,也就无法充分地判断你是否是独立完成的这个实验、你是否在做这个实验时进行了认真仔细地思考、通过这个实验你是否在实践能力上得到了提高)这次试验刚开始做时完全不知道从哪下手,才刚上了几节课,对于线性表、链式表都不是理解的很透彻,不知道用哪个软件编写程序。
数据结构实验一 实验报告
班级:姓名:学号:实验一线性表的基本操作一、实验目的1、掌握线性表的定义;2、掌握线性表的基本操作;如建立、查找、插入和删除等..二、实验内容定义一个包含学生信息学号;姓名;成绩的顺序表和链表二选一;使其具有如下功能:1 根据指定学生个数;逐个输入学生信息;2 逐个显示学生表中所有学生的相关信息;3 根据姓名进行查找;返回此学生的学号和成绩;4 根据指定的位置可返回相应的学生信息学号;姓名;成绩;5 给定一个学生信息;插入到表中指定的位置;6 删除指定位置的学生记录;7 统计表中学生个数..三、实验环境Visual C++四、程序分析与实验结果#include<stdio.h>#include<malloc.h>#include<stdlib.h>#include<string.h>#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status; // 定义函数返回值类型typedef struct{char num10; // 学号char name20; // 姓名double grade; // 成绩}student;typedef student ElemType;typedef struct LNode{ElemType data; // 数据域struct LNode *next; //指针域}LNode;*LinkList;Status InitListLinkList &L // 构造空链表L {L=struct LNode*mallocsizeofstruct LNode; L->next=NULL;return OK;}Status GetElemLinkList L;int i;ElemType &e // 访问链表;找到i位置的数据域;返回给 e{LinkList p;p=L->next;int j=1;whilep&&j<i{p=p->next;++j;}ifp||j>i return ERROR;e=p->data;return OK;}Status SearchLNode L;char str;LinkList &p // 根据名字查找{p=L.next;whilep{ifstrcmpp->;str==0return OK;p=p->next;}return ERROR;}Status ListInsertLinkList L;int i;ElemType e // 在i个位置插入某个学生的信息{LinkList p;s;p=L;int j=0;whilep&&j<i-1{p=p->next;++j;}ifp||j>i-1 return ERROR;s=struct LNode*mallocsizeofLNode;s->data=e;s->next=p->next;p->next=s;return OK;}Status ListDeleteLinkList p;int i // 删除i位置的学生信息{int j=0;whilep->next&&j<i-1{p=p->next;++j;}ifp->next||j>i-1 return ERROR;LinkList q;q=p->next;p->next=q->next;delete q;return OK;}void InputElemType *e{printf"姓名:"; scanf"%s";e->name;printf"学号:"; scanf"%s";e->num;printf"成绩:"; scanf"%lf";&e->grade;printf"输入完成\n\n";}void OutputElemType *e{printf"姓名:%-20s\n学号:%-10s\n成绩:%-10.2lf\n\n";e->name;e->num;e->grade;}int main{LNode L;LinkList p;ElemType a;b;c;d;printf"\n********************************\n\n";puts"1. 构造链表";puts"2. 录入学生信息";puts"3. 显示学生信息";puts"4. 输入姓名;查找该学生";puts"5. 显示某位置该学生信息";puts"6. 在指定位置插入学生信息";puts"7. 在指定位置删除学生信息";puts"8. 统计学生个数";puts"0. 退出";printf"\n********************************\n\n"; int x;choose=-1;whilechoose=0{puts"请选择:";scanf"%d";&choose;switchchoose{case 1:ifInitListpprintf"成功建立链表\n\n";elseprintf"链表建立失败\n\n";break;case 2:printf"请输入要录入学生信息的人数:";scanf"%d";&x;forint i=1;i<=x;i++{printf"第%d个学生:\n";i;Input&a;ListInsert&L;i;a;}break;case 3:forint i=1;i<=x;i++{GetElem&L;i;b;Output&b;}break;case 4:char s20;printf"请输入要查找的学生姓名:";scanf"%s";s;ifSearchL;s;pOutput&p->data;elseputs"对不起;查无此人";puts"";break;case 5:printf"请输入要查询的位置:";int id1;scanf"%d";&id1;GetElem&L;id1;c;Output&c;break;case 6:printf "请输入要插入的位置:";int id2;scanf"%d";&id2;printf"请输入学生信息:\n";Input&d;ifListInsert&L;id2;d{x++;puts"插入成功";puts"";}else{puts"插入失败";puts"";}break;case 7:printf"请输入要删除的位置:";int id3;scanf"%d";&id3;ifListDelete&L;id3{x--;puts"删除成功";puts"";}else{puts"删除失败";puts"";}break;case 8:printf"已录入的学生个数为:%d\n\n";x;break;}}printf"\n\n谢谢您的使用;请按任意键退出\n\n\n"; system"pause";return 0;}用户界面:(1)根据指定学生个数;逐个输入学生信息:(2)逐个显示学生表中所有学生的相关信息:(3)根据姓名进行查找;返回此学生的学号和成绩:(4)根据指定的位置可返回相应的学生信息学号;姓名;成绩:(5)给定一个学生信息;插入到表中指定的位置:(6)删除指定位置的学生记录:(7)统计表中学生个数:五、实验总结数据结构是一门专业技术基础课..它要求学会分析研究计算机加工的数据结构的特性;以便为应用涉及的数据选择适当的逻辑结构;存储结构及相应的算法;并初步掌握算法的时间分析和空间分析技术..不仅要考虑具体实现哪些功能;同时还要考虑如何布局;这次的实验题目是根据我们的课本学习进程出的;说实话;我并没有真正的读懂书本的知识;所以刚开始的时候;感到很棘手;于是又重新细读课本;这一方面又加强了对书本的理解;在这上面花费了一些心血;觉得它并不简单;是需要花大量时间来编写的....在本次实验中;在程序构思及设计方面有了较大的锻炼;能力得到了一定的提高..。
数据结构实验报告1-线性结构的顺序存储
教师签名: 2008 年 月 日
第2页共2页
2、参照课本,定义一个向量类模板,编写它的成员函数模板,对类模板加以实现;编写向量的并、 交运算功能函数;编写主程序,对两个向量进行分别进行合并、交运算。
3、通过阅读课本栈类板代码,理解栈类操作特点;编写一个借助于栈,将二进制数转换为十进制数 字串的程序;编写汉诺塔问题程序,理解函数的递归调用。
4、参照课本,定义一个顺序队列类模板,编写它的成员函数模板 ,对类模板加以实现;编写主程序, 对队列进行各种基本操作,理解队列的操作特性。
五、 实验总结(包括心得体会、问题回答及实验改进意见,可附页)
通过本次实验,基本上能够理解线性结构的顺序存储方式及各种不同线性结构的操作方式;顺序存 储方式主要用于线性的数据结构,它把逻辑上相邻的数据元素存储在物理上相邻的存储单元里结点之间 的关系由存储单元的邻接关系来体现。线性表、向量、栈、队列都属于线性结构的顺序存储,各结点的 物理地址是相邻的,每一次插入、删除运算会引起相应结点物理地址的重新排列;栈的操作特点是先进 后出,而队列的操作特点是先进先出。
2、 对两个向量进行合并、交运算,结果如下: 输入向量 La 的结点元素:1 2 3 4 5,输入 Lb 的结点元素:1 2 3 4 5 6,则两向量的交集为:1 2 3 4 5;并集为:1 2 3 4 5 6。
3、(1)将二进制数转换为十进制数字串的程序,结果如下: 输入要转换的带符号整数 x:+3;则 x 转换成十进制数字串输出为:+3
Байду номын сангаас
第1页共2页
四、 实验结果(包括程序或图表、结论陈述、数据记录及分析等,可附页)
1、 对线性表进行插入、删除、定位等操作,结果如下: 输入线性表元素:1 2 3 4 5,(1)选择插入,输入插入位置 2,插入值 9,则新的线性表为:1 2 9 3 4 5;(2)选择删除,输入删除元素序号 5,则新的线性表为:1 2 9 3 4;(3)选择取值,输入要求 值元素序号 2,则屏幕输出:第2个元素的值为 9;(4)选择查找,输入要查找的元素值 9,则屏幕输 出:要查找元素的序号为 2。
数据结构实验1环境使用实习报告
数据结构实验1环境使用实习报告下载提示:该文档是本店铺精心编制而成的,希望大家下载后,能够帮助大家解决实际问题。
文档下载后可定制修改,请根据实际需要进行调整和使用,谢谢!本店铺为大家提供各种类型的实用资料,如教育随笔、日记赏析、句子摘抄、古诗大全、经典美文、话题作文、工作总结、词语解析、文案摘录、其他资料等等,想了解不同资料格式和写法,敬请关注!Download tips: This document is carefully compiled by this editor. I hope that after you download it, it can help you solve practical problems. The document can be customized and modified after downloading, please adjust and use it according to actual needs, thank you! In addition, this shop provides you with various types of practical materials, such as educational essays, diary appreciation, sentence excerpts, ancient poems, classic articles, topic composition, work summary, word parsing, copy excerpts, other materials and so on, want to know different data formats and writing methods, please pay attention!1. 引言数据结构是计算机科学中的重要基础,通过实践操作来深入理解数据结构的实际应用至关重要。
数据的结构实验的1
数据的结构实验的1:数据结构实验的1第一点:数据结构实验的重要性和目的数据结构实验是计算机科学和软件工程领域中非常重要的一部分。
它不仅是理论知识的具体实践,而且也是理解和掌握数据结构的关键步骤。
数据结构是计算机科学中的基础,它研究如何有效地存储、组织和处理数据。
通过实验,学生可以深入了解数据结构的工作原理和性能,培养解决问题的能力,提高编程技能,为将来的职业生涯打下坚实的基础。
数据结构实验的目的在于通过实际的操作和观察,让学生更好地理解和掌握各种数据结构的特点和应用场景。
通过实验,学生可以学习如何选择合适的数据结构来解决实际问题,如何设计和实现数据结构的相关算法,以及如何分析数据结构的性能和优化算法。
这些能力和技能对于计算机科学和软件工程领域的人才来说至关重要。
第二点:数据结构实验的基本内容和步骤数据结构实验通常包括多个基本内容和步骤,旨在帮助学生全面掌握数据结构的知识和技能。
以下是常见的数据结构实验内容和步骤:1.实验准备:在实验之前,学生需要了解实验要求和目的,阅读相关的理论知识,熟悉实验中所使用的编程语言和工具。
2.实验设计:学生需要根据实验要求,设计合适的数据结构和算法,选择合适的数据输入和测试用例,以确保实验结果的准确性和可靠性。
3.实验实现:学生需要根据设计方案,编写相应的代码来实现数据结构和算法。
在这个过程中,学生需要注重代码的可读性和可维护性,遵循编程规范和习惯。
4.实验测试:学生需要对实现的数据结构和算法进行测试,验证其正确性和性能。
测试可以包括手工测试和自动化测试,以保证实验结果的准确性和可靠性。
5.实验报告:学生需要根据实验结果和观察,撰写实验报告,总结实验中的发现和收获,反思实验中的问题和不足,提出改进的建议和思考。
通过这些基本内容和步骤,学生可以全面地掌握数据结构的知识和技能,培养解决问题的能力和创新思维,为将来的职业生涯打下坚实的基础。
数据结构实验是计算机科学和软件工程领域中不可或缺的一部分,学生应该重视并积极参与其中。
数据结构 实验一:实现单链表各种基本运算的算法
- 1 -实验一:实现单链表各种基本运算的算法一、 实验目的1、 掌握单链表存储结构的类型定义;2、 实现单链表各种基本运算的算法。
二、 实验环境1、 Windows 操作系统;2、 Visual C++ 6.0三、 实验内容实现单链表各种基本运算的算法。
四、 概要设计1.存储结构的类型定义:Typedef struct LNode{ElemType data;Struct LNode *next;}LinkList;2.单链表示意图:3.项目组成图:4.algo2_2.cpp 的程序文件包含的函数原型及功能:InitList(LinkList *&L) 初始化单链表LDestroyList(LinkList *&L) 释放单链表LListEmpty(LinkList *L)判断单链表L 是否为空表ListLength(LinkList *L)返回单链表L 的元素个数DispList(LinkList *L)输出单链表LGetElem(LinkList *L,int i,ElemType &e)获取单链表L 的第i 个元素LocateElem(LinkList *L,ElemType e)在单链表L 中查找元素eListInsert(LinkList *&L,int i,ElemType e)在单链表L 中的第i 个位置上插入元素e…… head a 1 a 2 a 3 a n ∧ListDelete(LinkList *&L,int i,ElemType &e)在单链表L中删除第i个元素5.exp2_2.cpp程序文件简介:InitList(LinkList *&L) 初始化单链表LDestroyList(LinkList *&L) 释放单链表LListEmpty(LinkList *L) 判断单链表L是否为空表ListLength(LinkList *L) 返回单链表L的元素个数DispList(LinkList *L) 输出单链表LGetElem(LinkList *L,int i,ElemType &e) 获取单链表L的第i个元素LocateElem(LinkList *L,ElemType e) 在单链表L中查找元素eListInsert(LinkList *&L,int i,ElemType e) 在单链表L中的第i个位置上插入元素e ListDelete(LinkList *&L,int i,ElemType &e) 在单链表L中删除第i个元素6.proj2-2的项目的模块结构:在文件algo2-2中,(1)定义单链表结构类型;(2)初始化单链表(3)定义释放单链表的函数(4)定义判断单链表是否为空的函数(5)定义返回单链表元素个数的函数(6)定义输出单链表的函数(7)定义获取第i个元素的函数(8)定义查找元素的函数(9)定义插入元素的函数(10)定义删除元素的函数在文件exp2-2中分别调用algo2-2中所定义的函数7.函数调用关系图:五、详细设计源代码清单见附录。
数据结构实验报告(一)线性表的应用
数据结构实验报告(⼀)线性表的应⽤实验说明数据结构实验⼀ 线性表的实验——线性表的应⽤⼀、实验⽬的通过本实验使学⽣了解线性表的⼀种简单应⽤,熟悉线性表顺序存储与链式存储的特性,特别训练学⽣编程灵活控制链表的能⼒,为今后编程控制更为复杂的数据结构奠定基础。
⼆、实验内容1.⽤顺序表和链表分别分别编程实现教材中例⼦2-1与2-2。
要求:(1)只能⽤C语⾔编程实现;(2)完全保持书中算法2.1与算法2.2形式,不允许有任何变化,除⾮语法上不允许;所调⽤各函数参照书中19页的功能描述,其中函数名、参数个数及性质、函数功能必须与书中完全⼀致,不能有变化。
2.利⽤线性表表⽰⼀元多项式完成多项式的加、减、乘、求导、求值运算。
要求:(1)输⼊的⼀元多项式可以采⽤只输⼊各项的系数与指数这种简化的⽅式。
如对于多项式2x2+6x5,输⼊可为: 2,2 6,5 这样的简单形式。
(2)遇到有消项时应当处理,如2x2+6x5与3x2-6x5进⾏相加时,结果为5*x^2。
(3)当给定x的值时,能计算表达式相加或相减的结果。
(4)操作的结果放⼊⼀个新线性表中,原来的两个表达式存储表⽰不变,也可以不是产⽣新的线性表,⽽是将两上线性表合并为⼀个。
(5)要求程序功能模块划分合理(每个函数功能单⼀、可重⽤性好),使⽤空间尽可能少,算法尽可能⾼效。
实验报告1.实现功能描述使⽤线性表表⽰⼀元多项式完成多项式的加、减,乘,求导、求值运算。
2.⽅案⽐较与选择(1)因为使⽤的是线性表,所以主要⽅案有数组法和链表法。
(2)从时间复杂度来说,使⽤数组法更优;从空间复杂度来说,链表法更优。
因为数组法是指定好空间的,若式⼦⼤⼩超出设置⼤⼩,那程序必然出错;若式⼦⼤⼩⼩于设置⼤⼩,那就意味着有多余的空间被浪费了。
综合来讲,若计算式⼦较为庞⼤,使⽤链表法更佳;相反,若计算式⼦较⼩,数组法更佳。
3.设计算法描述(1)单个项式的数据存储使⽤了结构体,数组法是在⼀个结构体中定义两个⼀维数组;链表法是通过⼀个结构体作为⼀个节点,通过next指针连接起来。
数据结构实验实训报告单
一、实验名称:数据结构实验实训二、实验时间:2023年10月25日三、实验地点:计算机实验室四、实验目的:1. 理解并掌握数据结构的基本概念和常用算法;2. 学会使用C++语言实现数据结构的操作;3. 提高编程能力和问题解决能力;4. 加深对数据结构在实际应用中的理解。
五、实验内容:1. 实验一:线性表(1)实验内容:实现线性表的基本操作,如插入、删除、查找、排序等。
(2)实验步骤:a. 定义线性表的数据结构;b. 实现线性表的插入、删除、查找、排序等操作;c. 编写测试程序,验证实验结果。
2. 实验二:栈与队列(1)实验内容:实现栈和队列的基本操作,并分析其时间复杂度和空间复杂度。
(2)实验步骤:a. 定义栈和队列的数据结构;b. 实现栈和队列的入栈、出栈、入队、出队等操作;c. 分析栈和队列的时间复杂度和空间复杂度;d. 编写测试程序,验证实验结果。
3. 实验三:链表(1)实验内容:实现链表的基本操作,如插入、删除、查找、排序等。
(2)实验步骤:a. 定义链表的数据结构;b. 实现链表的插入、删除、查找、排序等操作;c. 编写测试程序,验证实验结果。
4. 实验四:树与二叉树(1)实验内容:实现二叉树的基本操作,如插入、删除、查找、遍历等。
(2)实验步骤:a. 定义二叉树的数据结构;b. 实现二叉树的插入、删除、查找、遍历等操作;c. 编写测试程序,验证实验结果。
5. 实验五:图(1)实验内容:实现图的基本操作,如图的创建、添加边、查找路径等。
(2)实验步骤:a. 定义图的数据结构;b. 实现图的创建、添加边、查找路径等操作;c. 编写测试程序,验证实验结果。
六、实验心得:1. 通过本次实验,我对数据结构的基本概念和常用算法有了更深入的理解,为今后的学习和工作打下了坚实的基础。
2. 在实验过程中,我学会了使用C++语言实现数据结构的操作,提高了自己的编程能力。
3. 通过对数据结构在实际应用中的分析,我认识到数据结构在计算机科学中的重要地位,为今后的职业发展指明了方向。
数据结构课程实验报告
数据结构课程实验报告数据结构课程实验报告引言:数据结构是计算机科学中非常重要的一门课程,它研究了数据的组织、存储和管理方法。
在数据结构课程中,我们学习了各种数据结构的原理和应用,并通过实验来加深对这些概念的理解。
本文将对我在数据结构课程中的实验进行总结和分析。
实验一:线性表的实现与应用在这个实验中,我们学习了线性表这种基本的数据结构,并实现了线性表的顺序存储和链式存储两种方式。
通过实验,我深刻理解了线性表的插入、删除和查找等操作的实现原理,并掌握了如何根据具体应用场景选择合适的存储方式。
实验二:栈和队列的实现与应用栈和队列是两种常见的数据结构,它们分别具有后进先出和先进先出的特点。
在这个实验中,我们通过实现栈和队列的操作,加深了对它们的理解。
同时,我们还学习了如何利用栈和队列解决实际问题,比如迷宫求解和中缀表达式转后缀表达式等。
实验三:树的实现与应用树是一种重要的非线性数据结构,它具有层次结构和递归定义的特点。
在这个实验中,我们学习了二叉树和二叉搜索树的实现和应用。
通过实验,我掌握了二叉树的遍历方法,了解了二叉搜索树的特性,并学会了如何利用二叉搜索树实现排序算法。
实验四:图的实现与应用图是一种复杂的非线性数据结构,它由节点和边组成,用于表示事物之间的关系。
在这个实验中,我们学习了图的邻接矩阵和邻接表两种存储方式,并实现了图的深度优先搜索和广度优先搜索算法。
通过实验,我深入理解了图的遍历方法和最短路径算法,并学会了如何利用图解决实际问题,比如社交网络分析和地图导航等。
实验五:排序算法的实现与比较排序算法是数据结构中非常重要的一部分,它用于将一组无序的数据按照某种规则进行排列。
在这个实验中,我们实现了常见的排序算法,比如冒泡排序、插入排序、选择排序和快速排序等,并通过实验比较了它们的性能差异。
通过实验,我深入理解了排序算法的原理和实现细节,并了解了如何根据具体情况选择合适的排序算法。
结论:通过这些实验,我对数据结构的原理和应用有了更深入的理解。
数据结构实验报告(实验)
数据结构实验报告(实验)数据结构实验报告(实验)1. 实验目的1.1 理解数据结构的基本概念和操作1.2 学会使用数据结构解决实际问题1.3 掌握常用数据结构的实现和应用2. 实验环境2.1 操作系统:Windows 102.2 编程语言:C++2.3 开发工具:Visual Studio3. 实验内容3.1 实验一:线性表的实现和应用3.1.1 设计并实现线性表的基本操作函数3.1.2 实现线性表的插入、删除、查找等功能 3.1.3 实现线性表的排序算法3.1.4 应用线性表解决实际问题3.2 实验二:栈和队列的实现和应用3.2.1 设计并实现栈的基本操作函数3.2.2 设计并实现队列的基本操作函数3.2.3 实现栈和队列的应用场景3.2.4 比较栈和队列的优缺点3.3 实验三:树的实现和应用3.3.1 设计并实现二叉树的基本操作函数3.3.2 实现二叉树的创建、遍历和查找等功能3.3.3 实现树的遍历算法(前序、中序、后序遍历)3.3.4 应用树解决实际问题4. 数据结构实验结果4.1 实验一的结果4.1.1 线性表的基本操作函数实现情况4.1.2 线性表的插入、删除、查找功能测试结果4.1.3 线性表的排序算法测试结果4.1.4 线性表解决实际问题的应用效果4.2 实验二的结果4.2.1 栈的基本操作函数实现情况4.2.2 队列的基本操作函数实现情况4.2.3 栈和队列的应用场景测试结果4.2.4 栈和队列优缺点的比较结果4.3 实验三的结果4.3.1 二叉树的基本操作函数实现情况4.3.2 二叉树的创建、遍历和查找功能测试结果 4.3.3 树的遍历算法测试结果4.3.4 树解决实际问题的应用效果5. 实验分析与总结5.1 实验问题与解决方案5.2 实验结果分析5.3 实验总结与心得体会6. 附件附件一:实验源代码附件二:实验数据7. 法律名词及注释7.1 版权:著作权法规定的对原创作品享有的权利7.2 专利:国家授予的在一定时间内对新型发明享有独占权利的证书7.3 商标:作为标识企业商品和服务来源的标志的名称、符号、图案等7.4 许可协议:指允许他人在一定条件下使用自己的知识产权的协议。
数据结构实验报告-实验一顺序表、单链表基本操作的实现
数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现l 实验⽬的1、顺序表(1)掌握线性表的基本运算。
(2)掌握顺序存储的概念,学会对顺序存储数据结构进⾏操作。
(3)加深对顺序存储数据结构的理解,逐步培养解决实际问题的编程能⼒。
l 实验内容1、顺序表1、编写线性表基本操作函数:(1)InitList(LIST *L,int ms)初始化线性表;(2)InsertList(LIST *L,int item,int rc)向线性表的指定位置插⼊元素;(3)DeleteList1(LIST *L,int item)删除指定元素值的线性表记录;(4)DeleteList2(LIST *L,int rc)删除指定位置的线性表记录;(5)FindList(LIST *L,int item)查找线性表的元素;(6)OutputList(LIST *L)输出线性表元素;2、调⽤上述函数实现下列操作:(1)初始化线性表;(2)调⽤插⼊函数建⽴⼀个线性表;(3)在线性表中寻找指定的元素;(4)在线性表中删除指定值的元素;(5)在线性表中删除指定位置的元素;(6)遍历并输出线性表;l 实验结果1、顺序表(1)流程图(2)程序运⾏主要结果截图(3)程序源代码#include<stdio.h>#include<stdlib.h>#include<malloc.h>struct LinearList/*定义线性表结构*/{int *list; /*存线性表元素*/int size; /*存线性表长度*/int Maxsize; /*存list数组元素的个数*/};typedef struct LinearList LIST;void InitList(LIST *L,int ms)/*初始化线性表*/{if((L->list=(int*)malloc(ms*sizeof(int)))==NULL){printf("内存申请错误");exit(1);}L->size=0;L->Maxsize=ms;}int InsertList(LIST *L,int item,int rc)/*item记录值;rc插⼊位置*/ {int i;if(L->size==L->Maxsize)/*线性表已满*/return -1;if(rc<0)rc=0;if(rc>L->size)rc=L->size;for(i=L->size-1;i>=rc;i--)/*将线性表元素后移*/L->list[i+=1]=L->list[i];L->list[rc]=item;L->size++;return0;}void OutputList(LIST *L)/*输出线性表元素*/{int i;printf("%d",L->list[i]);printf("\n");}int FindList(LIST *L,int item)/*查找线性元素,返回值>=0为元素的位置,返回-1为没找到*/ {int i;for(i=0;i<L->size;i++)if(item==L->list[i])return i;return -1;}int DeleteList1(LIST *L,int item)/*删除指定元素值得线性表记录,返回值为>=0为删除成功*/ {int i,n;for(i=0;i<L->size;i++)if(item==L->list[i])break;if(i<L->size){for(n=i;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return i;}return -1;}int DeleteList2(LIST *L,int rc)/*删除指定位置的线性表记录*/{int i,n;if(rc<0||rc>=L->size)return -1;for(n=rc;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return0;}int main(){LIST LL;int i,r;printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.size,LL.Maxsize);printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.list,LL.Maxsize);while(1){printf("请输⼊元素值,输⼊0结束插⼊操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d",&i);if(i==0)break;printf("请输⼊插⼊位置:");scanf("%d",&r);InsertList(&LL,i,r-1);printf("线性表为:");OutputList(&LL);}while(1){printf("请输⼊查找元素值,输⼊0结束查找操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d ",&i);if(i==0)break;r=FindList(&LL,i);if(r<0)printf("没有找到\n");elseprintf("有符合条件的元素,位置为:%d\n",r+1);}while(1){printf("请输⼊删除元素值,输⼊0结束查找操作:");fflush(stdin);/*清楚标准缓存区*/scanf("%d",&i);if(i==0)break;r=DeleteList1(&LL,i);if(i<0)printf("没有找到\n");else{printf("有符合条件的元素,位置为:%d\n线性表为:",r+1);OutputList(&LL);}while(1){printf("请输⼊删除元素位置,输⼊0结束查找操作:");fflush(stdin);/*清楚标准输⼊缓冲区*/scanf("%d",&r);if(r==0)break;i=DeleteList2(&LL,r-1);if(i<0)printf("位置越界\n");else{printf("线性表为:");OutputList(&LL);}}}链表基本操作l 实验⽬的2、链表(1)掌握链表的概念,学会对链表进⾏操作。
《数据结构》实验内容与要求
实验一顺序表基本操作的实现与应用顺序表的运算·create(sqlist A):创建顺序表A,并返回其中的元素个数。
·disp(sqlist A,int n):输出一个具有n个元素的顺序表A。
·ins(sqlist A,int n, int i,elemtype x):在顺序表A的第i个元素前插入一个元素x。
若i=0,则新元素作为第1个元素;若i=n,则插入在顺序表的最后。
·del(sqlist A, int n, int i):在顺序表A中删除第i个元素。
·find(sqlist A, int n, elemtype x):在一个有n个元素的顺序表A中查找元素值为x 的元素。
一、【实验目的】掌握线性表在顺序存储下的插入与删除等基本运算二、【实验内容】1、设计顺序表的基本运算算法。
2、编写一个算法实现两个有序(从小到大)顺序表合并成为一个顺序表,合并后的结果放在第一个顺序表中,不另设新的顺序表存储(假设这两个有序顺序表中没有相同的元素)。
3、请编写26个字母按特定字母值插入或删除的完整程序。
三、【源程序及运行结果】实验二单链表基本操作的实现与应用单链表单链表节点的类型定义如下:typedef int elemtype; //定义数据域的类型typedef struct linknode{ //定义节点类型elemtype data;struct linknode *next;} linknode;单链表的运算·create():创建单链表,由用户输入各节点data 域的值,以0表示输入结束,最后返回建立的单链表的头指针。
·disp(nodetype *h):输出单链表h的所有节点的data 域的值。
·len(nodetype *h):返回单链表h的长度。
·find(nodetype *h,int i):返回单链表h中第i个节点的指针。
数据结构实验报告实验1
数据结构实验报告实验1一、实验目的本次实验的主要目的是通过实际操作和编程实现,深入理解和掌握常见的数据结构,如线性表、栈、队列等,并能够运用所学知识解决实际问题。
二、实验环境本次实验使用的编程环境为Visual Studio 2019,编程语言为C++。
三、实验内容与步骤(一)线性表的实现与操作1、顺序表的实现定义一个固定大小的数组来存储线性表的元素。
实现插入、删除、查找等基本操作。
2、链表的实现定义链表节点结构体,包含数据域和指针域。
实现链表的创建、插入、删除、遍历等操作。
(二)栈的实现与应用1、栈的实现使用数组或链表实现栈的数据结构。
实现入栈、出栈、栈顶元素获取等操作。
2、栈的应用利用栈实现表达式求值。
(三)队列的实现与应用1、队列的实现使用循环数组或链表实现队列。
实现入队、出队、队头元素获取等操作。
2、队列的应用模拟银行排队系统。
四、实验结果与分析(一)线性表1、顺序表插入操作:在指定位置插入元素时,需要移动后续元素,时间复杂度为 O(n)。
删除操作:删除指定位置的元素时,同样需要移动后续元素,时间复杂度为 O(n)。
查找操作:可以直接通过索引访问元素,时间复杂度为 O(1)。
2、链表插入操作:只需修改指针,时间复杂度为 O(1)。
删除操作:同样只需修改指针,时间复杂度为 O(1)。
查找操作:需要遍历链表,时间复杂度为 O(n)。
(二)栈1、表达式求值能够正确计算简单的四则运算表达式,如 2 + 3 4。
对于复杂表达式,如(2 + 3) 4,也能得到正确结果。
(三)队列1、银行排队系统模拟了客户的到达、排队和服务过程,能够反映出队列的先进先出特性。
五、实验中遇到的问题及解决方法(一)线性表1、顺序表的空间浪费问题问题描述:当预先分配的空间过大而实际使用较少时,会造成空间浪费。
解决方法:可以采用动态分配空间的方式,根据实际插入的元素数量来调整存储空间。
2、链表的指针操作错误问题描述:在链表的插入和删除操作中,容易出现指针指向错误,导致程序崩溃。
数据结构实验一(完整版)
数据结构实验一:线性表实验报告#include <string.h>#include <ctype.h>#include <malloc.h> // malloc()等#include <limits.h> // INT_MAX等#include <stdio.h> // EOF(=^Z或F6),NULL#include <stdlib.h> // atoi()#include <io.h> // eof()#include <math.h> // floor(),ceil(),abs()#include <process.h> // exi t()#include <iostream.h> // cout,cin// 函数结果状态代码#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1// #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行typedef int Status; // Status是函数的类型,其值是函数结果状态代码,如OK等typedef int Boolean; // Boolean是布尔类型,其值是TRUE或FALSEtypedef int ElemType;#define LIST_INIT_SIZE 10 // 线性表存储空间的初始分配量#define LISTINCREMENT 2 // 线性表存储空间的分配增量struct SqListElemType *elem; // 存储空间基址int length; // 当前长度int listsize; // 当前分配的存储容量(以sizeof(ElemType)为单位)};/**********************************************************/ /* 顺序表示的线性表的基本操作(12个) *//**********************************************************/ Status InitList(SqList &L){ // 操作结果:构造一个空的顺序线性表---------------1L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L.elem)exit(OVERFLOW); // 存储分配失败L.length=0; // 空表长度为0L.listsize=LIST_INIT_SIZE; // 初始存储容量return OK;}Status DestroyList(SqList &L){ // 初始条件:顺序线性表L已存在。
数据结构实验一顺序表实验报告
数据结构实验一顺序表实验报告数据结构实验一顺序表实验报告一、实验目的顺序表是一种基本的数据结构,本次实验的目的是通过实现顺序表的基本操作,加深对顺序表的理解,并掌握顺序表的插入、删除、查找等操作的实现方法。
二、实验内容1. 实现顺序表的创建和初始化操作。
2. 实现顺序表的插入操作。
3. 实现顺序表的删除操作。
4. 实现顺序表的查找操作。
5. 实现顺序表的输出操作。
三、实验步骤1. 创建顺序表的数据结构,包括数据存储数组和记录当前元素个数的变量。
2. 初始化顺序表,将当前元素个数置为0。
3. 实现顺序表的插入操作:- 判断顺序表是否已满,若已满则输出错误信息。
- 将插入位置之后的元素依次后移一位。
- 将要插入的元素放入插入位置。
- 当前元素个数加一。
4. 实现顺序表的删除操作:- 判断顺序表是否为空,若为空则输出错误信息。
- 判断要删除的位置是否合法,若不合法则输出错误信息。
- 将删除位置之后的元素依次前移一位。
- 当前元素个数减一。
5. 实现顺序表的查找操作:- 遍历顺序表,逐个比较元素值与目标值是否相等。
- 若找到目标值,则返回该元素的位置。
- 若遍历完整个顺序表仍未找到目标值,则返回错误信息。
6. 实现顺序表的输出操作:- 遍历顺序表,逐个输出元素值。
四、实验结果经过实验,顺序表的各项操作均能正确实现。
在插入操作中,可以正确将元素插入到指定位置,并将插入位置之后的元素依次后移。
在删除操作中,可以正确删除指定位置的元素,并将删除位置之后的元素依次前移。
在查找操作中,可以正确返回目标值的位置。
在输出操作中,可以正确输出顺序表中的所有元素。
五、实验总结通过本次实验,我深入了解了顺序表的原理和基本操作,并通过实际编程实现了顺序表的各项功能。
在实验过程中,我遇到了一些问题,如如何判断顺序表是否已满或为空,如何处理插入和删除位置的合法性等。
通过查阅资料和与同学讨论,我解决了这些问题,并对顺序表的操作有了更深入的理解。
数据结构实验报告1线性表的顺序存储结构
数据结构实验报告1线性表的顺序存储结构一、实验目的本次实验的主要目的是深入理解线性表的顺序存储结构,并通过编程实现其基本操作,包括创建线性表、插入元素、删除元素、查找元素以及输出线性表等。
通过实际操作,掌握顺序存储结构的特点和优势,同时也了解其在不同情况下的性能表现。
二、实验环境本次实验使用的编程语言为C++,编译环境为Visual Studio 2019。
三、实验原理1、线性表的定义线性表是由 n(n≥0)个数据元素组成的有限序列。
在顺序存储结构中,线性表的元素存储在一块连续的存储空间中,通过数组来实现。
2、顺序存储结构的特点存储密度高,无需额外的指针来表示元素之间的关系。
可以随机访问表中的任意元素,时间复杂度为 O(1)。
插入和删除操作需要移动大量元素,平均时间复杂度为 O(n)。
四、实验内容及步骤1、定义线性表的数据结构```cppdefine MAX_SIZE 100 //定义线性表的最大长度typedef struct {int dataMAX_SIZE; //存储线性表元素的数组int length; //线性表的当前长度} SeqList;```2、初始化线性表```cppvoid InitList(SeqList L) {L>length = 0; //初始时线性表长度为 0}```3、判断线性表是否为空```cppbool ListEmpty(SeqList L) {return (Llength == 0);}```4、求线性表的长度```cppint ListLength(SeqList L) {return Llength;}```5、按位查找操作```cppint GetElem(SeqList L, int i) {if (i < 1 || i > Llength) {printf("查找位置不合法!\n");return -1;}return Ldatai 1;}```6、按值查找操作```cppint LocateElem(SeqList L, int e) {for (int i = 0; i < Llength; i++){if (Ldatai == e) {return i + 1;}}return 0; //未找到返回 0}```7、插入操作```cppbool ListInsert(SeqList L, int i, int e) {if (L>length == MAX_SIZE) {//表已满printf("表已满,无法插入!\n");return false;}if (i < 1 || i > L>length + 1) {//插入位置不合法printf("插入位置不合法!\n");return false;}for (int j = L>length; j >= i; j) {//移动元素L>dataj = L>dataj 1;}L>datai 1 = e; //插入元素L>length++;//表长加 1return true;}```8、删除操作```cppbool ListDelete(SeqList L, int i) {if (L>length == 0) {//表为空printf("表为空,无法删除!\n");return false;}if (i < 1 || i > L>length) {//删除位置不合法printf("删除位置不合法!\n");return false;}for (int j = i; j < L>length; j++){//移动元素L>dataj 1 = L>dataj;}L>length; //表长减 1return true;}```9、输出线性表```cppvoid PrintList(SeqList L) {for (int i = 0; i < Llength; i++){printf("%d ", Ldatai);}printf("\n");}```10、测试用例```cppint main(){SeqList L;InitList(&L);ListInsert(&L, 1, 10);ListInsert(&L, 2, 20);ListInsert(&L, 3, 30);ListInsert(&L, 4, 40);ListInsert(&L, 5, 50);printf("线性表的长度为:%d\n", ListLength(L));printf("查找第 3 个元素:%d\n", GetElem(L, 3));int loc = LocateElem(L, 30);if (loc) {printf("元素 30 的位置为:%d\n", loc);} else {printf("未找到元素 30\n");}ListDelete(&L, 3);printf("删除第 3 个元素后的线性表:");PrintList(L);return 0;}```五、实验结果及分析1、实验结果成功创建并初始化了线性表。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
一、实验目的1、学习线性表的顺序表示和实现,会进行顺序表的插入、删除、合并2、学习线性表的链式表示和实现,会进行链表的插入、删除、合并二、实验内容1、编程实现:(1)在顺序表ajcniydu的第三个位置插入p。
(2)删除顺序表ajcniydu第三个位置的元素。
2、编程实现将顺序表acdijtuy和cfklns合并。
3、编程实现:(1)在链表asdfghjkl的第四个位置插入z。
(2)删除顺序表asdfghjkl第四个位置元素。
4、编程实现两个有序链表adfi和cefi的合并。
三、实验步骤1.+2.代码:#include<stdio.h>#include<malloc.h>typedef char ElemType;typedef struct{ElemType *elem;int length;int listsize;}SqList;//定义结构体void InitList(SqList &L){L.elem=(ElemType*)malloc(10*sizeof(ElemType));L.length=0;L.listsize=10;}//初始化{printf("输入字符串:");int i=0;for(i;i<n;i++){scanf("%c",&L.elem[i]);L.length++;}} //赋值void Show(SqList L){int i=0;printf("字符串:");for(i;i<L.length;i++)printf("%c",L.elem[i]);printf("\n");}//显示int ListInsert(SqList &L, int i, ElemType e){ElemType *p;if (i < 1 || i > L.length+1)printf("插入位置不合法!\n");else{ElemType *q = &(L.elem[i-1]);for (p = &(L.elem[L.length-1]); p>=q; --p) *(p+1) = *p; *q = e;++L.length;}} //插入int ListDelete(SqList &L,int i){if(i > L.length||i<=0)printf("位置不合法\n");else{int j = i-1;for( j;j<L.length;j++)L.elem[j] = L.elem[j+1];L.length--;}} // 删除void Mergelist(SqList La,SqList Lb,SqList &Lc){ElemType *pa,*pb,*pc,*pa_last,*pb_last;pa = La.elem;pb = Lb.elem;pa_last = pa + La.length - 1;pb_last = pb + Lb.length - 1;Lc.listsize = Lc.length = La.length + Lb.length;pc = Lc.elem = (ElemType *)malloc(Lc.length*sizeof(ElemType));while(pa <= pa_last && pb <= pb_last){if(*pa >= *pb)*pc++ = *pa++;else*pc++ = *pb++;}while(pa <= pa_last)*pc++ = *pa++;while(pb <= pb_last)*pc++ = *pb++;}//合并int main(){SqList La;InitList(La);CreateList(La,8);ElemType e;int i;printf("输入插入位置及字符:");scanf("%d %c",&i,&e);ListInsert(La,i,e);Show(La);printf("\n");fflush(stdin);SqList Lb;InitList(Lb);CreateList(Lb,8);Show(Lb);printf("输入删除位置:");int j;scanf("%d",&j);ListDelete(Lb,j);Show(Lb);printf("\n");fflush(stdin);SqList L1,L2,L3;InitList(L1);InitList(L2);CreateList(L1,8);Show(L1);fflush(stdin);CreateList(L2,6);Show(L2);Mergelist(L1,L2,L3); Show(L3);}3.+4.代码:#include<stdio.h>#include<malloc.h>typedef char ElemType; typedef struct LNode{char a;ElemType data;struct LNode *next;}LNode,*LinkList;//定义结构体int count = 0;void Createlist(LinkList &L,int n){printf("输入字符串:");L = ( LinkList )malloc( sizeof(LNode) );L -> next = NULL;int i;LinkList p = ( LinkList)malloc( sizeof(LNode) );L = p;for( i = 0;i < n;i++){LinkList q = ( LinkList )malloc( sizeof(LNode) );scanf("%c",&q -> a);q -> next = NULL;p -> next = q;p = q;count ++;}} //创建链表void Show(LinkList L){LinkList p = ( LinkList )malloc( sizeof(LNode) );p = L -> next;printf("字符串为:");while( p ){printf("%c",p -> a);p = p -> next;}printf("\n");}//输出链表int ListInsert( LinkList &L,int n,char K){if( L ->next == NULL){printf("链表为空!\n");return 0;}else if(n > count + 1){printf("插入位置不合法!\n");return 0;}else{LinkList p = ( LinkList)malloc( sizeof (LNode));if( n == 1){p -> a = K;p -> next = L -> next;L -> next = p;}else if( n == count + 1){p = L -> next;while( p -> next )p = p -> next;LinkList q = ( LinkList )malloc( sizeof (LNode));p -> next = q;q -> a = K;q -> next = NULL;}else{int i;p = L;for( i = 1;i < n;i++)p = p -> next;LinkList q = ( LinkList )malloc( sizeof (LNode));q -> a = K;q -> next = p -> next;p -> next = q;}count ++;}}// 插入int ListDelete( LinkList &L,int n){if( L -> next == NULL){printf("链表为空!\n");return 0;}else if( n > count ){printf("删除位置不合法!\n");return 0;}else{LinkList p = ( LinkList )malloc( sizeof (LNode));p = L -> next;if( n == 1 ){L -> next = p -> next;free(p);}else{int i;for( i = 1;i < n - 1;i++)p = p -> next;if( n == count )p -> next = NULL;else{LinkList q = ( LinkList )malloc( sizeof (LNode));q = p -> next;p -> next = q -> next;free(q);}}}}//删除void MergeList(LinkList &La, LinkList &Lb, LinkList &Lc) {LinkList pa, pb, pc;pa = La->next; pb = Lb->next;Lc = pc = La;while (pa && pb) {if (pa->data <= pb->data) {pc->next = pa; pc = pa; pa = pa->next;}else { pc->next = pb; pc = pb; pb = pb->next; } }pc->next = pa ? pa : pb;free(Lb);} // 合并int main(){LinkList L1;Createlist(L1,9);Show(L1);char b;int i;printf("输入插入位置和插入元素:");scanf("%d %c",&i,&b);ListInsert(L1,i,b);Show(L1);fflush(stdin);printf("\n");LinkList L2;Createlist(L2,9);Show(L2);int j;printf("输入删除元素的位置:");scanf("%d",&j);ListDelete(L2,j);Show(L2);fflush(stdin);printf("\n");LinkList La;printf("输入需合并的两组字符串!\n");Createlist(La,4);Show(La);fflush(stdin);LinkList Lb;Createlist(Lb,4);Show(Lb);LinkList Lc;MergeList(La,Lb,Lc);Show(Lc);return 0;}文档。