实验一：线性表的存储结构定义及基本操作
实验01 线性表的基本操作
实验01 线性表的基本操作一、实验目的1. 了解线性表的结构特点及有关概念；2. 理解线性表的存储结构；3. 掌握顺序表及单链表的基本操作算法。
二、实验内容1、编写程序实现顺序表的各种基本运算：初始化、插入、删除、取表元素、求表长、输出表、销毁、判断是否为空表、查找元素。
在此基础上设计一个主程序完成如下功能：（1）初始化顺序表L；（2）依次在表尾插入a，b，c，d，e五个元素；（3）输出顺序表L；（4）输出顺序表L的长度；（5）判断顺序表L是否为空；（6）输出顺序表L的第4个元素；（7）输出元素c的位置；（8）在第3个位置上插入元素f，之后输出顺序表L；（9）删除L的第2个元素，之后输出顺序表L；（10）销毁顺序表L。
2、编写程序实现单链表的各种基本运算：初始化、插入、删除、取表元素、求表长、输出表、销毁、判断是否为空表、查找元素。
在此基础上设计一个主程序完成如下功能：（1）初始化单链表L；（2）依次在表尾插入a，b，c，d，e五个元素；（3）输出单链表L；（4）输出单链表L的长度；（5）判断单链表L是否为空；（6）输出单链表L的第4个元素；（7）输出元素c的位置；（8）在第3个位置上插入元素f，之后输出单链表L；（9）删除L的第2个元素，之后输出单链表L；（10）销毁单链表L。
三、实验要点及说明一．顺序表1.顺序表初始化:(1)为顺序表L动态分配一个预定大小的数组空间，使elem 指向这段空间的基地址。
(2)将表的当前长度设为0.2.顺序表的取值:(1)判断指定的位置序号i值是否合理（1<=i<=L.length），若不合理则返回ERROR.(2)若i值合理，则将i个数据元素L.elem[i]赋给参数e,通过e返回第i个数据元素的传值。
3.顺序表的查找:(1)从第一个元素起，依次和e相比较，若找到与e相等的元素L.elem[i]，则查找成功，返回该元素的序号i+1.(2)若查遍整个顺序表都没要找到，则查找失败，返回0.4．顺序表的插入:(1)判断插入位置i是否合法(i值的合法范围是1<=i<=n+1)，若不合法则返回值ERROR.(2)判断顺序表的存储空间是否已满，若满则返回值ERROR(3)将第n个至第i个位置的元素依次向后移动一个位置，空出第i个位置(i=n+1时无需移动)。
数据结构实验-实验指导书
实验一线性表操作一、实验目的1熟悉并掌握线性表的逻辑结构、物理结构。
2熟悉并掌握顺序表的存储结构、基本操作和具体的函数定义。
3熟悉VC++程序的基本结构，掌握程序中的用户头文件、实现文件和主文件之间的相互关系及各自的作用。
4熟悉VC++操作环境的使用以及多文件的输入、编辑、调试和运行的全过程。
二、实验要求1实验之前认真准备，编写好源程序。
2实验中认真调试程序，对运行结果进行分析，注意程序的正确性和健壮性的验证。
3不断积累程序的调试方法。
三、实验内容基本题:1对元素类型为整型的顺序存储的线性表进行插入、删除和查找操作。
加强、提高题：2、编写一个求解Josephus问题的函数。
用整数序列1, 2, 3, ……, n表示顺序围坐在圆桌周围的人。
然后使用n = 9, s = 1, m = 5，以及n = 9, s = 1, m = 0，或者n = 9, s = 1, m = 10作为输入数据，检查你的程序的正确性和健壮性。
最后分析所完成算法的时间复杂度。
定义JosephusCircle类，其中含完成初始化、报数出圈成员函数、输出显示等方法。
（可以选做其中之一）加强题：（1）采用数组作为求解过程中使用的数据结构。
提高题：（2）采用循环链表作为求解过程中使用的数据结构。
运行时允许指定任意n、s、m数值，直至输入n = 0退出程序。
实验二栈、队列、递归应用一、实验目的1熟悉栈、队列这种特殊线性结构的特性2熟练掌握栈、队列在顺序存储结构和链表存储结构下的基本操作。
二、实验要求1实验之前认真准备，编写好源程序。
2实验中认真调试程序，对运行结果进行分析，注意程序的正确性和健壮性的验证。
3不断积累程序的调试方法。
三、实验内容基本题（必做）：1分别就栈的顺序存储结构和链式存储结构实现栈的各种基本操作。
2、假设以带头结点的循环链表表示队列，并且只设一个指针指向对尾结点，不设头指针，试设计相应的置队空、入队和出队的程序。
加强题：3设线性表A中有n个字符，试设计程序判断字符串是否中心对称，例如xyzyx和xyzzyx都是中心对称的字符串。
数据结构实验报告-实验：1线性表的顺序存储和操作实现
}
for(inti=pos-1;i<length;i++)
if(listArray[i].equals(obj))returni+1;
return-1;
}
publicbooleanmodify(Object obj,intpos){
if(pos<1||pos>length){
List sort();
}
publicclasssequenceListimplementsList {
finalintmaxSize=10;
privateintlength;
privateObject[]listArray;
publicsequenceList(){//无参数的构造函数的定义
length=0;//线性表初始为空，即长度为0
System.out.println();
list2.preOrder();
System.out.println("线性表list2长度："+list2.size());
}
}
publicinterfaceList {
Object value(intpos);
booபைடு நூலகம்eanadd(Object obj,intpos);
int[] a={20,16,38,42,29};
for(inti=0;i<a.length;i++) list1.add(a[i], i+1);
intn1=(Integer)list1.remove(2);
list1.add(80, 3);
intn2=(Integer)list1.value(4);
数据结构实验报告1线性表的顺序存储结构
数据结构实验报告1线性表的顺序存储结构数据结构实验报告1线性表的顺序存储结构第一章引言线性表是计算机中最常见的数据结构之一，它是一种有序的数据元素集合，其中的数据元素之间具有一对一的关系。
线性表的存储结构有多种方式，其中顺序存储结构是最简单的一种，它使用一段连续的存储单元来存储线性表中的元素。
第二章顺序存储结构的定义顺序存储结构是将线性表中的元素按照其逻辑顺序依次存储在一块连续的存储空间中。
顺序存储结构的特点是可以快速地访问任意位置的元素，但插入和删除操作需要移动大量的元素。
第三章顺序存储结构的实现1.存储空间的分配顺序存储结构通常使用数组来实现，数组的长度应该大于等于线性表的长度，以防止溢出。
存储空间的分配可以使用静态分配或动态分配两种方式来实现。
2.线性表的初始化初始化线性表时，需要设置线性表的长度和当前元素的个数。
3.线性表的增删改查操作●插入操作：________在指定位置插入一个元素时，需要将插入位置之后的元素依次后移，给待插入的元素腾出位置。
●删除操作：________删除指定位置的元素时，需要将删除位置之后的元素依次前移，覆盖删除位置上的元素。
●修改操作：________修改指定位置的元素时，直接对该位置上的元素进行修改即可。
●查找操作：________根据指定的元素值，查找其在顺序存储结构中的位置。
4.线性表的遍历操作遍历操作可以按照顺序访问线性表中的每个元素，可以使用循环结构实现遍历操作。
第四章顺序存储结构的优缺点分析1.优点：________可以快速地访问任意位置的元素，节省存储空间。
2.缺点：________插入和删除操作需要移动大量的元素，不适用于频繁插入和删除的场景。
第五章实验过程和结果分析在本次实验中，我们以顺序存储结构为基础，实现了线性表的增删改查操作，并进行了遍历操作。
通过实验，我们发现顺序存储结构在查询操作上有较好的性能，但在插入和删除操作上的性能较差。
第六章附件本文档涉及的附件详见附件文件。
线性表的存储结构定义及基本操作
一、实验目的：. 掌握线性表的逻辑特征. 掌握线性表顺序存储结构的特点，熟练掌握顺序表的基本运算. 熟练掌握线性表的链式存储结构定义及基本操作. 理解循环链表和双链表的特点和基本运算. 加深对顺序存储数据结构的理解和链式存储数据结构的理解，逐步培养解决实际问题的编程能力二、实验内容：（一）基本实验内容（顺序表）：建立顺序表，完成顺序表的基本操作：初始化、插入、删除、逆转、输出、销毁, 置空表、求表长、查找元素、判线性表是否为空；1．问题描述：利用顺序表,设计一组输入数据（假定为一组整数），能够对顺序表进行如下操作：. 创建一个新的顺序表，实现动态空间分配的初始化；. 根据顺序表结点的位置插入一个新结点(位置插入)，也可以根据给定的值进行插入(值插入)，形成有序顺序表；. 根据顺序表结点的位置删除一个结点(位置删除)，也可以根据给定的值删除对应的第一个结点，或者删除指定值的所有结点(值删除)；. 利用最少的空间实现顺序表元素的逆转；. 实现顺序表的各个元素的输出；. 彻底销毁顺序线性表，回收所分配的空间；. 对顺序线性表的所有元素删除，置为空表；. 返回其数据元素个数；. 按序号查找，根据顺序表的特点，可以随机存取，直接可以定位于第i 个结点，查找该元素的值，对查找结果进行返回；. 按值查找，根据给定数据元素的值，只能顺序比较，查找该元素的位置，对查找结果进行返回；. 判断顺序表中是否有元素存在，对判断结果进行返回；. 编写主程序，实现对各不同的算法调用。
2．实现要求：对顺序表的各项操作一定要编写成为C（C++）语言函数，组合成模块化的形式，每个算法的实现要从时间复杂度和空间复杂度上进行评价；. “初始化算法”的操作结果：构造一个空的顺序线性表。
对顺序表的空间进行动态管理，实现动态分配、回收和增加存储空间；. “位置插入算法”的初始条件：顺序线性表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.数据元素之间具有一对一的关系，即除了第一个和一个数据元素外，其他数据元素都是首尾相连的。
2.线性表具有唯一的第一个元素和一个元素，分别称为表头和表尾。
3.线性表的长度是指表中数据元素的个数，长度为零的线性表称为空表。
三、线性表的分类根据线性表的存储方式，可以将线性表分为顺序存储结构和链式存储结构两大类。
1.顺序存储结构：顺序存储结构是将线性表中的数据元素按照逻辑顺序依次存放在一组地质连续的存储单元中。
顺序存储结构具有随机访问的特点，可以通过下标快速访问表中的任意一个元素。
顺序存储结构的线性表又可以分为静态顺序表和动态顺序表两种。
2.链式存储结构：链式存储结构是通过指针将线性表中的数据元素连接起来，形成一个链表。
链表中的每个节点包含一个数据元素和一个或多个指针，指向下一个或前一个节点。
链式存储结构具有动态性，可以根据需要动态地分配和释放节点空间。
链式存储结构的线性表又可以分为单向链表、双向链表和循环链表等。
四、线性表的基本操作线性表作为一种数据结构，具有一系列基本操作，包括：1.初始化：创建一个空的线性表。
2.插入：在线性表的指定位置插入一个数据元素。
3.删除：删除线性表中指定位置的数据元素。
4.查找：在线性表中查找具有给定关键字的数据元素。
5.更新：更新线性表中指定位置的数据元素。
6.销毁：释放线性表所占用的空间。
7.遍历：遍历线性表中的所有数据元素，进行相应的操作。
8.排序：对线性表中的数据元素进行排序。
9.合并：将两个线性表合并为一个线性表。
五、线性表的应用1.程序语言中的数组：数组是一种典型的顺序存储结构的线性表，常用于存储具有相同类型的数据元素。
数据结构实验一-线性表
数据结构实验⼀-线性表实验⼀线性表⼀、实验⽬的1、深刻理解线性结构的特点，以及在计算机内的两种存储结构。
2、熟练掌握线性表的顺序存储结构和链式存储结构，及其它们的基本操作，重点掌握查找、插⼊和删除等操作。
⼆、实验要求1、认真阅读程序，将未完成的代码补全（红⾊部分）。
2、上机调试，并运⾏程序。
3、保存和截图程序的运⾏结果，并结合程序进⾏分析。
三、实验内容和基本原理1、实验1.1 顺序表的操作利⽤顺序表存储⽅式实现下列功能（见参考程序1）：1）通过键盘输⼊数据建⽴⼀个线性表，并输出该线性表。
如，依次输⼊元素25,21,46,90,12,98。
2）根据屏幕菜单的选择，进⾏数据的插⼊、删除和查找，并在插⼊或删除数据后，再输出线性表。
如，在第2个位置上插⼊元素43，然后输出顺序表。
删除顺序表第4个元素，输出改变的顺序表。
3）在屏幕菜单中选择0，结束程序的运⾏。
基本原理：在顺序表的第i个位置上插⼊⼀个元素时，必须先将线性表的第i个元素之后的所有元素依次后移⼀个位置，以便腾空⼀个位置，在把新元素插⼊到该位置。
当要删除第i个元素时，只需将第i个元素之后的所有元素前移⼀个位置。
程序代码（蓝⾊为补充的语句）：//* * * * * * * * * * * * * * * * * * * * * * * *//*PROGRAM :顺序结构的线性表 *//*CONTENT :建⽴,插⼊,删除,查找 *//*编程语⾔： Visual c++ 6.0 *//* * * * * * * * * * * * * * * * * * * * * *#include#include#define MAXSIZE 20typedef int ElemType; //数据元素的类型typedef struct{ElemType a[MAXSIZE];int length;}SqList; //顺序存储的结构体类型SqList a,b,c;//函数声明void creat_list(SqList *L);void out_list(SqList L);void insert_sq(SqList *L,int i,ElemType e); ElemType delete_sq(SqList *L,int i);int locat_sq(SqList L,ElemType e);//主函数void main(){int i,k,loc;ElemType e,x;char ch;do {printf("\n\n\n");printf("\n 吴肖遥20151681310131");printf("\n 1.建⽴线性表");printf("\n 2.插⼊元素");printf("\n 3.删除元素");printf("\n 4.查找元素");printf("\n 0.结束程序运⾏");printf("\n =====================");printf("\n 请输⼊要执⾏的操作: ");scanf("%d",&k);switch(k){case 1:{creat_list(&a);out_list(a);}break;case 2:{printf("\n请输⼊插⼊位置： ",a.length+1); scanf("%d",&i);printf("请输⼊要插⼊的元素值： ");scanf("%d",&e);insert_sq(&a,i,e);out_list(a);}break;case 3:{printf("\n请输⼊要删除元素的位置： ",a.length); scanf("%d",&i);x=delete_sq(&a,i);out_list(a);if(x!=-1)printf("\n删除的元素为：%d\n",x);else printf("要删除的元素不存在！");}break;case 4:{printf("\n请输⼊要查找的元素值：");scanf("%d",&e);loc=locat_sq(a,e);if(loc==-1)printf("\n未找到指定元素！");elseprintf("\n已找到，元素的位置是: %d ",loc);}break;}/*switch*/}while(k!=0);printf("\n 按回车键，返回...\n");ch=getchar();}/*main*///建⽴线性表void creat_list(SqList *L){int i;printf("请输⼊线性表的长度: ");scanf("%d",&L->length);for(i=0;ilength;i++){printf("数据 %d =",i);scanf("%d",&(L->a[i]));}}//输出线性表void out_list(SqList L){int i;for(i=0;i<=L.length-1;i++)printf("%10d",L.a[i]);}//在线性表的第i个位置插⼊元素evoid insert_sq(SqList *L,int i,ElemType e){int j;if(L->length==MAXSIZE)printf("线性表已满!\n");else {if(i<1||i>L->length+1)printf("输⼊位置错!\n");else {for(j=L->length-1;j>=i-1;j--)L->a[j+1]=L->a[j];L->a[j+1]=e;/*将未完成的代码补全,提⽰：此处添加⼀条语句，将被删除的元素值赋给e*/ L->length++;}}}//删除第i个元素，返回其值ElemType delete_sq(SqList *L,int i){ElemType x;int j;if(L->length==0)printf("空表!\n");else if(i<1||i>L->length){printf("输⼊位置错！\n");x=-1;}else{x=L->a[i-1];for(j=i;j<=L->length-1;j++)L->a[j-1]=L->a[j];/*将未完成的代码补全,提⽰：此处添加⼀条语句，将被删除元素之后的元素左移。
实验一 线性表基本操作
{
printf("申请空间失败");
return ERORR;
}
s->number=i;
printf("请输入第%d个人的密码：",i);
scanf("%d",&s->password);
t->next=s;
t=s;
}
t->next=NULL;
return (OK);
}
int Josephus(LinkList H,int m)
p1=InsList(p,e);
show(p1);
}
运行结果：
分析：该程序一共有三个子函数：InitList(int r)初始化顺序表、InsList (SeqList *L,ElemType e)插入元素、show(SeqList *L)显示顺序表。主函数先得到数序表的长度r，把r传给初始化函数，经输入和排序得到一个顺序表，返回表的收地址L。输入一个待插入数e，再调用插入函数把它插入到该顺序表中（先用for循环通过比较找到该插入的位置，在用for循环把后面的元素都向后移一位，再把e插入，最后last++），返回首地址L。最后在调用显示函数，输出插入后的顺序表
printf("请输入从哪开始删除：");
scanf("%d",&i);
printf("请输入删除的位数：");
scanf("%d",&k);
p1= DelList(p,i,a,k);
show(p1);
}
运行结果：
分析：该函数有三个子函数：InitList(int r)初始化顺序表、DelList (SeqList *L,int i,ElemType a[],int k)删除元素、show(SeqList *L)显示顺序表。主函数先得到数序表的长度r，把r传给初始化函数，经输入和排序得到一个顺序表，返回表的收地址L。输入要删除的首位置i和删除的位数k，再调用删除函数把该顺序表中的相应元素删掉（先用for循环删除这k个元素，在用for循环把后面的元素向前移，最后last-k），返回首地址L。最后在调用显示函数，输出插入后的顺序表
数据结构实验报告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，则屏幕输出：第２个元素的值为 9；（4）选择查找，输入要查找的元素值 9，则屏幕输 出：要查找元素的序号为 2。
实习01_线性表的顺序存储和操作(有序表的合并)
实验一线性表的顺序存储和操作(有序表的合并)1.目的用顺序表(SqList)类型实现书上算法2.1和2.2,了解线性表及在计算机中的两类不同的存储结构;熟练掌握线性表的查找、插入和删除等算法并灵活运用这些算法。
2.要求用C语言编写程序,其中Lb={2,4,6,8,10} La={1,2,3,4,5},①算法2.1执行后,得到的new La = 1,2,3,4,5,6,8,10②修改Lb=2,6,8,9,11,15,20,并利用新生成的La,得到合并后的Lc,Lc= 1,2,2,3,4,5,6,6,8,8,9,10,11,15,203、预习要求:1、复习书上第20页的例2-1和例2-2;2、复习算法2.3,理解如何构造线性表;3、复习算法2.7,理解算法的执行步骤和含义;4、项目介绍:前面的课程已经学习了如何用C语言描述顺序表、如何初始化顺序表、以及如何在顺序表中插入和删除数据元素。
现在通过两个顺序表的合并的实验,加深对顺序表的理解,熟悉如何将逻辑上的数学模型转化为计算机能够理解的指令代码。
该实验是数据结构课程的第一个实验,实验的目标除了加深理解课堂内容外,还对学生的动手能力提出了更高的要求,锻炼学生动手的能力。
5、算法设计#include <stdio.h>#include <stdlib.h>#include <malloc.h># define TRUE 1# define ERROR 0# define OK 1# define OVERFLOW -2# define FALSE 0# define LIST_INIT_SIZE 10# define LISTINCREMENT 5void main(){List La,Lb,Lc;int j,b[7]={2,6,8,9,11,15,20};InitList(La); // 创建空表La。
如不成功,则会退出程序的运行for(j=1;j<=5;j++) // 在表La中插入5个元素,依次为1、2、3、4、5 ListInsert(La,j,j);printf("La= ");ListTraverse(La,printer); // 输出表La的内容InitList(Lb); // 创建空表Lbfor(j=1;j<=5;j++) // 在表Lb中插入5个元素,依次为2、4、6、8、10 ListInsert(Lb,j,2*j);printf("Lb= ");ListTraverse(Lb,printer); // 输出表Lb的内容Union(La,Lb); // 调用算法2.1,将Lb中满足条件的元素插入La(不改变Lb) printf("new La= ");ListTraverse(La,printer); // 输出新表La的内容ClearList(Lb); // 清空表Lbfor(j=1;j<=7;j++) // 在表Lb中重新依次插入数组b[]的7个元素ListInsert(Lb,j,b[j-1]);printf("Lb= ");ListTraverse(Lb,printer); // 输出表Lb的内容MergeList(La,Lb,Lc); // 调用算法2.2,生成新表Lc(不改变表La和表Lb)printf("Lc= ");ListTraverse(Lc,printer); // 输出表Lc的内容}6.小结线性表是软件设计中最基础的数据结构。
实验1线性表的基本操作
实验一线性表的基本操作一、线性结构的顺序表基本操作实验目的1.学会定义单链表的结点类型、线性表的顺序存储类型，实现C程序的基本结构，对线性表的一些基本操作和具体的函数定义。
2.掌握顺序表的基本操作，实现顺序表的插入、删除、查找以及求并集等运算。
3.掌握对多函数程序的输入、编辑、调试和运行过程。
实验要求1．预习C语言中结构体的定义与基本操作方法。
2．对顺序表的每个基本操作用单独的函数实现。
3．编写完整程序完成下面的实验内容并上机运行。
实验内容1．编写程序实现顺序表的下列基本操作：(1)初始化顺序表La。
(2)将La置为空表。
(3)销毁La。
(4)在La中插入一个新的元素。
(5)删除La中的某一元素。
(6)在La中查找某元素，若找到，则返回它在La中第一次出现的位置，否则返回0。
(7)打印输出La中的元素值。
2．（选做）编写程序完成下面的操作：(1)构造两个顺序线性表La和Lb，其元素都按值非递减顺序排列。
(2)实现归并La和Lb得到新的顺序表Lc，Lc的元素也按值非递减顺序排列。
(3)假设两个顺序线性表La和Lb分别表示两个集合A和B，利用union_Sq操作实现A=A∪B。
二、单链表基本操作(选做)实验目的1. 学会定义单链表的结点类型、线性表的链式存储类型，实现对单链表的一些基本操作和具体的函数定义，了解并掌握单链表的类定义以及成员函数的定义与调用。
2. 掌握单链表基本操作及两个有序表归并、单链表逆置等操作的实现。
实验要求1．预习C语言中结构体的定义与基本操作方法。
2．对单链表的每个基本操作用单独的函数实现。
3．编写完整程序完成下面的实验内容并上机运行。
实验内容1．编写程序完成单链表的下列基本操作：(1)初始化单链表La。
(2)在La中插入一个新结点。
(3)删除La中的某一个结点。
(4)在La中查找某结点并返回其位置。
(5)打印输出La中的结点元素值。
2．构造一个单链表L，其头结点指针为head，编写程序实现将L逆置。
数据结构实验报告1线性表的顺序存储结构
数据结构实验报告1线性表的顺序存储结构一、实验目的本次实验的主要目的是深入理解和掌握线性表的顺序存储结构，通过实际编程实现线性表的基本操作，如创建、插入、删除、查找和遍历等，从而提高对数据结构的理解和编程能力。
二、实验环境本次实验使用的编程语言是 C 语言，开发环境为 Visual Studio 2019。
三、实验原理线性表是一种最基本、最简单的数据结构，它是由 n（n≥0）个数据元素组成的有限序列。
在顺序存储结构中，线性表的元素存储在一块连续的存储空间中，逻辑上相邻的元素在物理位置上也相邻。
通过数组来实现顺序存储结构，可以方便地进行随机访问，但插入和删除操作的效率较低，因为可能需要移动大量元素。
四、实验内容及步骤1、定义线性表的数据结构｀｀｀cdefine MAXSIZE 100 ／／线性表的最大长度typedef struct ｛int dataMAXSIZE; ／／存储线性表元素的数组int length; ／／线性表的当前长度｝ SeqList;｀｀｀2、初始化线性表｀｀｀cvoid InitList(SeqList L) ｛L>length ＝ 0;｝｀｀｀3、判断线性表是否为空｀｀｀cint ListEmpty(SeqList L) ｛if （Llength ＝＝ 0) ｛return 1;｝ else ｛return 0;｝｝｀｀｀4、求线性表的长度｀｀｀cint ListLength(SeqList L) ｛return Llength;｝｀｀｀5、按位置查找元素｀｀｀cint GetElem(SeqList L, int i, int e) ｛if （i ＜ 1 ｜｜ i ＞ Llength) ｛return 0;｝e ＝ Ldatai 1;return 1;｝｀｀｀6、按值查找元素的位置｀｀｀cint LocateElem(SeqList L, int e) ｛int i;for （i ＝ 0; i ＜ Llength; i+＋）｛if （Ldatai ＝＝ e) ｛return i ＋ 1;｝｝return 0;｝｀｀｀7、插入元素｀｀｀cint ListInsert(SeqList L, int i, int e) ｛int j;if （L>length ＝＝ MAXSIZE) ｛／／表已满return 0;｝if （i ＜ 1 ｜｜ i ＞ L>length ＋ 1) ｛／／插入位置不合法return 0;｝if （i ＜＝ L>length) ｛／／插入位置不在表尾for （j ＝ L>length 1; j ＞＝ i 1; j) ｛L>dataj ＋ 1 ＝ L>dataj;｝｝L>datai 1 ＝ e;L>length+＋；return 1;｝｀｀｀8、删除元素｀｀｀cint ListDelete(SeqList L, int i, int e) ｛int j;if （L>length ＝＝ 0) ｛／／表为空return 0;｝if （i ＜ 1 ｜｜ i ＞ L>length) ｛／／删除位置不合法return 0;｝e ＝ L>datai 1;if （i ＜ L>length) ｛／／删除位置不在表尾for （j ＝ i; j ＜ L>length; j+＋）｛L>dataj 1 ＝ L>dataj;｝｝L>length;return 1;｝｀｀｀9、遍历线性表｀｀｀cvoid TraverseList(SeqList L) ｛int i;for （i ＝ 0; i ＜ Llength; i+＋）｛printf(＂％d ＂， Ldatai)；｝printf(＂＼n"）；｝｀｀｀五、实验结果与分析1、对创建的空线性表进行初始化操作，通过判断线性表是否为空的函数验证初始化是否成功。
实验一-线性表操作-实验报告
中国矿业大学计算机学院实验报告{cin>>y;if(y==1){cout<<"请输入插入位置和元素的值:"<<endl;cin>>m>>n;ListInsert_Sq(List,m,n);disp(List);}else if(y==2){cout<<"请输入要删除第几个元素:"<<endl;cin>>m;ListDelete_Sq(List,m,j);cout<<j<<endl;disp(List);}else{cout<<"请输入所要查找的元素:"<<endl;cin>>m;cout<<LocateElem_Sq(List,m)<<endl;}}cout<<endl;}运行结果：加强、提高题：2、编写一个求解Josephus问题的函数。
用整数序列1, 2, 3, ……, n表示顺序围坐在圆桌周围的人。
然后使用n = 9, s = 1, m = 5，以及n = 9, s = 1, m = 0，或者n = 9, s = 1, m = 10作为（2）提高：#include<iostream>using namespace std;typedef struct LNode{struct LNode *next;int a;}LNode,*LinkList;class JosephouCircle //定义一个类包括三个元素{public:void SetValue();void PickOut();private:int n;int s;int m;};void JosephouCircle::SetValue() //设置初值的大小{cout<<"请输入参加游戏的总人数:"<<endl;cin>>n;cout<<"请输入开始人的位置:"<<endl;cin>>s;JosephouCircle Jo1;Jo1.SetValue();Jo1.PickOut();return 0;}运行结果：四、实验体会与总结1、对于线性链表和顺序表都属于线性表问题，但是线性链表比顺序表要灵活，方便；2、线性表在做元素寻找的操作的时候，必须从头结点开始寻找。
实验1 线性表的基本操作
实验一线性表的基本操作一、实验目的（1）掌握线性表顺序存储和链式存储的方法及基本运算的实现。
（2）掌握将算法在VC++6.0语言环境下实现的过程。
二、实验准备（1）复习线性表的定义，掌握顺序存储、链式存储的方法及操作。
（2）复习C语言中指针与结构体的概念、定义方式。
（3）掌握链表的C语言的实现。
（4）实验的计算机中安装了Microsoft VC++ 6.0。
三、实验内容顺序表1）首先创建一个顺序表：从键盘读入一组整数（长度小于等于20），按输入顺序放入顺序表，输入以－1结束（注意－1不放到顺序表内）；将创建好的顺序表元素依次输出到屏幕上。
2）在已创建好的顺序表中插入一个元素：从键盘读入需插入的元素值和插入位置，调用插入函数完成插入操作；然后将顺序表元素依次输出到屏幕上。
3）在已创建好的顺序表中删除一个元素：从键盘读入欲删除的元素位置（序号），调用删除函数完成删除操作；然后将顺序表元素依次输出到屏幕上。
算法提示：➢需求分析：1.功能（1）建立一顺序表（2）显示顺序表中每个元素（3）在上述的顺序表中的指定位置插入指定的元素，并输出顺序表中所有数据。
（4）在上述的顺序表中的指定位置删除指定的元素，并输出顺序表中所有数据。
2．输入要求从键盘输入顺序表中所有数据，输入以－1结束（注意－1不放到顺序表内）；需插入的数据元素的位置、值；要删除的数据元素的位置（序号）。
3. 测试数据顺序表中所有数据：15，26，58，27，9插入的数据元素的位置、值：1，28；6，28；0，28要删除的数据元素的位置：3➢概要设计：1.数据结构：提示：相关常量和顺序表数据类型定义#define MAXNUM 20#define true 1#define false 0typedef struct{int data[MAXNUM];int length;}list_type;2．模块划分：a)建立顺序表的createlist函数；b)显示输出顺序中每个结点的数据的showlist函数；c)insertlist函数：插入函数。
【数据结构】线性表的基本操作
【数据结构】线性表的基本操作【数据结构】线性表的基本操作【一、概述】线性表是一种常见的数据结构，它是由一组具有相同特性的数据元素组成的有序序列。
线性表的基本操作包括插入、删除、查找和修改等操作，本文将对这些操作进行详细介绍。
【二、插入操作】插入操作是向线性表中某个位置插入一个新元素的操作。
插入操作包括头部插入、尾部插入和中间插入三种情况。
首先需要确定插入的位置，然后将插入位置后的元素依次向后移动一位，最后在插入位置处放入新元素。
1.头部插入：将新元素插入线性表的头部位置。
2.尾部插入：将新元素插入线性表的尾部位置。
3.中间插入：将新元素插入线性表的任意中间位置。
【三、删除操作】删除操作是从线性表中删除某个元素的操作。
删除操作包括删除头部元素、删除尾部元素和删除中间元素三种情况。
首先需要确定删除的位置，然后将删除位置后的元素依次向前移动一位，最后删除最后一个元素位置上的元素。
1.删除头部元素：删除线性表的头部元素。
2.删除尾部元素：删除线性表的尾部元素。
3.删除中间元素：删除线性表的任意中间位置的元素。
【四、查找操作】查找操作是在线性表中搜索某个元素的操作。
查找操作包括按值查找和按位置查找两种情况。
1.按值查找：根据给定的元素值，在线性表中搜索并返回该元素的位置。
2.按位置查找：根据给定的位置，返回该位置上的元素值。
【五、修改操作】修改操作是修改线性表中某个元素的值的操作。
需要先找到要修改的元素位置，然后将其值修改为新的值。
【附件】本文档涉及附件略。
【法律名词及注释】本文档所涉及的法律名词及注释略。
线性表的逻辑结构及其基本操作.
1<=i<=n
a1 a2 … ai … an
3.Байду номын сангаас顺序表的类定义
template<class Type>class Array { private: Type *elements; //数组元素 int ArraySize; //数组元素的个数 int MaxSize; //数组元素的最大个数 BOOL GetArray(); BOOL GetArray(Type *pa); };
4. 线性表的运算
(1) 置空表：建立一个空表； (2) 存 (3) 插 (4) 删 (6) 查 (7) 合 取：访问线性表的某个元素,使用或改变其值； 入：在第i个位置插入一个同类型的结点； 除：删除第i个结点； 找：在线性表中查找满足某种条件的结点； 并：将两个线性表合并成一个线性表；
(5) 求表长：求出线性表中结点的个数；
顺序存储结构的特点为： 1)表中逻辑上相邻的结点，存储在相邻的物理
位置上；2)可以随机存取表中的元素;3)存储密度 大，存储空间利用率高。
2. 线性表的地址计算：
设线性表的基地址为LOC(a1), ai的存储地址为： LOC(ai) = LOC(a1)＋（i－1）*k
1 2 i n a1 a2 … ai … an Loc(a1) Loc(a1)+k Loc(a1)+(i-1)*k
(8) 分
(9) 排
拆：将一个线性表分拆成多个线性表；
序：按某数据项的值递增或递减的顺序重新排列；
(10)显示，建立，读写盘等.
1
2 3 4
线性表的逻辑结构及其基本操作
线性表的顺序存储结构 线性表的链式存储结构 静态链表 应用实例
线性表及存储结构
线性表及存储结构线性表的定义和基本运算1. 线性表的逻辑定义(1) 线性表，Linear_List是最简单和最常⽤的⼀种数据结构。
(2) 线性表是由n个数据元素（结点）a1,a2,...,an组成的有限序列。
类⽐数学中的数列概念。
其中我们规定数组元素的个数n为该线性表的长度,size。
当n为零时，称为空表。
(3) ⾮空的线性表通常记为：(a1,a2,a3,...,an)，其中ai（1<=i<=n）表⽰线性表的其中⼀个结点。
(4) a1称为表的开始结点，⽆直接前继，有⼀个直接后继a2;an为表的终端结点，⽆直接后继，有⼀个直接前继an-1;其余元素ai(2<=i<=n-1)为内部元素，有前继ai-1,后继ai+1;结点与结点之间是线性的关系。
故称之为线性表。
1. 线性表的基本运算(1) 置空表initlist(L)，构造⼀个空的线性表；(2) 求表长listLength(L),返回线性表的长度；(3) 取元素getNode(L,i),1<=i<=n;(4) 按值查找 LocateNode(L,x),返回第⼀个为X的结点的位置，若表中不存在则返回0(5) 插⼊insert(L,i,x) 在L的i位置插⼊x，(6) 删除delete(L,i) 删除表中的第i个元素线性表的顺序存储和基本元素的实现1. 线性表的顺序存储(1) 线性表的顺序存储指的是将线性表的数据元素按其逻次序依次存⼊⼀组地址连续的存储单元中，⽤这种⽅式存储的线性表称为顺序表，例如数组。
(2) 假设每个结点的空间⼤⼩都⼀致，即数据类型⼀致，例如对于每个int来说，占⽤4个字节，32位。
设每个结点的空间⼤⼩为d，那么，⼀般来说，线性表中第i个元素的存储位置为：LOC(ai)=LOC(a1)+(i-1)*d (种树⽐喻)，其中ai的地址称为⾸地址或基地址。
(3) 因为在顺序表中任何⼀个元素的地址都可以通过计算确定，所以可以做到随机存储。
C++与数据结构 第一次上机实验——线性表
实验一线性表数据结构（C++语言描述）实验报告实验一线性表一、实验目的和要求：1、掌握线性表顺序存储结构和链式存储结构的基本思想；2、掌握顺序表和单链表的基本操作。
二、实验原理：1、线性表的定义：数据之间存在一对一的线性关系的数据结构的称为线性结构，也可称为线性表。
2、顺序存储结构：用一组连续的存储单元依次存储数据元素，数据元素之间的逻辑关系是由元素的存储的存储位置来表示的，通常用一维数组来表示。
顺序表的优点：存储密度大、空间利用率高、，无需为表中元素之间的逻辑关系而增加额外的存储空间。
顺序表的缺点：插入和删除操作需要移动大量的元素；表的容量难以确定；造成空间的“碎片”。
在程序设计语言中，通常用一维数组来表示表的存储区域。
假设用data[ListSize]来表示一段顺序表，其中ListSize是一个根据实际问题规模定义的足够大的整数，另外用一个实际变量length来表示当前实际元素的个数，表中的数据从data[0]开始依次存放，表空时length=0.3、链式存储结构：用一组任意的存储单元存储数据元素，数据元素之间的逻辑关系是用指针来表示的。
链式存储结构的优点：插入和删除操作方便省时。
链式存储结构的缺点：存储空间的开销大。
链式存储的方法是使用结点构造链。
每个结点分为数据域和指针域两部分组成。
数据域用来存放数据元素，指针域用来存放后继存储单元的地址。
三、实验内容1、对于给定的单链表L，设计一个算法，删除L中值为x的结点的直接前驱结点。
2、已知两个单链表LA和LB分别表示两个集合，其元素递增排列，设计算法求出LA和LB的交集C，要求C同样以递增的单链表形式存储。
四、实验设计：1、（1）伪算法：建立链表L；循环搜索数据值为x的前一结点，若已至表尾，且其值不为value，警告，退出程序；否则，重新拉链，将数值为x的结点的前一结点标记，将被标记的结点断开，回收被删除的结点的内存空间，将链表长度减1。
（2）实验代码：//对给定的链表L，设计一个算法，删除L中值为x的结点的直接前驱结点#include<stdlib.h>#include<iostream>using namespace std;class ListNode //建立结点类{public:char data;ListNode *link;ListNode(){link=NULL;}ListNode(int&item,ListNode *next=NULL){data=item;link=next;}};class List //建立链表类{public:List(){ListNode *q=new ListNode;first=last=q;}void Great(List L);voidInsertL(char zifu);void Print();charRemovevalue(char value);private:ListNode *first,*last;int length;};void List::Great(List L) //建立链表函数{char n;intl,i;cout<<"请输入链表的长度：";cin>>l;cout<<"请输入数据:";for(i=1;i<l+1;i++){ cin>>n;L.InsertL(n);}L.length++;}void List::InsertL(char zifu){ ListNode *newcode=new ListNode;newcode->data =zifu;newcode->link=NULL;if(first==NULL){first=newcode;last=newcode;}else last->link=newcode;last=newcode;}char List ::Removevalue(char value) //该函数实现删除值为x的结点的前一结点{ListNode *p=first,*q,*h;while(p->link!=NULL&&p->link->data!=value) {h=p;p=p->link; }if(p->link==NULL&&p->data!=value)return 0;q=h->link;h->link = q->link;delete q;length --;return value;}void List::Print() //打印链表{ListNode *p;p=first->link;while(p!=NULL){cout<<p->data<<" ";p=p->link;}cout<<endl;}int main(){char value;List a;a.Great(a);cout<<"请输入要删除的的数值；"; cin>>value;a.Removevalue(value);a.Print();system("PAUSE");}（3）、运行结果2、（1）伪算法：要实现此程序核心问题是寻找集合LA和LB的交集，并将其输出，设计思路：寻找LA的第i个结点，寻找LB的第j个结点，利用嵌套循环，实现链表LA的每一个结点都和LB的结点进行比较，将相等的元素输出到链表LD中；对链表LD中的元素进行去重，然后将链表中没有重叠的元素存入到链表LC中，将链表LC输出。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
操作结果：在带头结点的单链线性表 L 中，删除第 i 个元素,并由 e 返 回其值； . “输出算法”初始条件：链表 L 已存在；
操作结果：依次输出链表的各个结点的值； （三）扩展实验内容（顺序表）
3．关于实验内容要完成的操作，一般都以独立的算法出现，建立一个单链表的基本算
法文件,将各种不同算法组合在一个文件之中，存储为一个头文件如取名为：linklistAlgo.h， 后凡涉及到要使用本文件中的单链表算法，一定要在你的文件的前面加上一条#include “linklistAlgo.h” 即可，实现的算法函数，如 ListInit_Link、ListInsert_Link、ListDelete_Link、 ListTraverse_Link、PriorElem_Link、NextElem_Link、GetElem_Link、MergeList_Link 等；
操作结果：将所有在线性表 Lb 中但不在 La 中的数据元素插入到 La 中； . “有序合并算法”的初始条件： 已知线性表 La 和 Lb 中的数据元素按值非递减排列；
操作结果：归并 La 和 Lb 得到新的线性表 Lc,Lc 的数据元素也按值非递减 排列； （四）扩展实验内容（链表） 1．问题描述：
操作结果: 若 cur_e 是 L 的数据元素,且不是第一个,则用 pre_e 返回它的 前驱； . “求后继算法”初始条件: 线性表 L 已存在；
操作结果: 若 cur_e 是 L 的数据元素,且不是最后一个,则用 next_e 返回它 的后继； . “两个有序链表的合并算法”初始条件: 线性表单链线性表 La 和 Lb 的元素按值非递减排 列； 操作结果:归并 La 和 Lb 得到新的单链表。
2．对于类型定义，由于每一种数据结构的定义都不一样，因此要进行专门的类型定义， 也可以将数据结构的定义组合成为一个文件，存储为一个头文件（如线性表的顺序存储结构 定义取名为 seqlistDef. h），只需建立一次，以后凡涉及到关于顺序表操作的相关内容，一定 要在你的文件的前面加上一条#include “seqlistDef. h” 即可，无需重复进行顺序存储结构的 定义。
. 按序号查找，根据顺序表的特点，可以随机存取，直接可以定位于第 i 个结点，查找该 元素的值，对查找结果进行返回； . 按值查找，根据给定数据元素的值，只能顺序比较，查找该元素的位置，对查找结果进行 返回； . 判断顺序表中是否有元素存在，对判断结果进行返回； . 编写主程序，实现对各不同的算法调用。 2．实现要求：
对链表的各项操作一定要编写成为 C（C++）语言函数，组合成模块化的形式，还要针 对每个算法的实现从时间复杂度和空间复杂度上进行评价。 . “初始化算法”的操作结果：构造一个空的线性表 L，产生头结点,并使 L 指向此头结点； . “建立链表算法” 初始条件：空链存在；
操作结果：选择逆位序或正位序的方法，建立一个单链表，并且返回完 成的结果； . “链表（位置）插入算法”初始条件：已知单链表 L 存在；
操作结果：在 L 中第 i 个位置之前插入新的数据元素 e，L 的长度加 1； . “位置删除算法”的初始条件：顺序线性表 L 已存在，1≤i≤ListLength(L) ；
操作结果：删除 L 的第 i 个数据元素，并用 e 返回其值，L 的长度减 1 ； . “逆转算法”的初始条件：顺序线性表 L 已存在；
其他基本操作还有销毁链表、将链表置为空表、求链表的长度、获取某位置结点的内容、 搜索结点。 1． 问题描述：
利用线性表的链式存储结构,设计一组输入数据（假定为一组整数），能够对单链表进行 如下操作： . 初始化一个带表头结点的空链表； . 创建一个单链表是从无到有地建立起一个链表，即一个一个地输入各结点数据，并建立 起前后相互链接的关系。又分为逆位序(插在表头)输入 n 个元素的值和正位序(插在表尾)输 入 n 个元素的值； . 插入结点可以根据给定位置进行插入（位置插入），也可以根据结点的值插入到已知的链 表中（值插入），且保持结点的数据按原来的递增次序排列，形成有序链表。 . 删除结点可以根据给定位置进行删除（位置删除），也可以把链表中查找结点的值为搜索 对象的结点全部删除（值删除）； . 输出单链表的内容是将链表中各结点的数据依次显示，直到链表尾结点； . 编写主程序，实现对各不同的算法调用。 其它的操作算法描述略。 2．实现要求：
操作结果：返回 L 中数据元素值为 e 的元素位置； . “判表空算法”初始条件：顺序线性表 L 已存在；
操作结果：若 L 为空表，则返回 TRUE，否则返回 FALSE； 分析: 修改输入数据，预期输出并验证输出的结果，加深对有关算法的理解。
(二）基本实验内容（链表）：
建立单链表，完成链表（带表头结点）的基本操作：建立链表、插入、删除、查找、输 出、求前驱、求后继、两个有序链表的合并操作。
3．关于实验内容要完成的操作，一般都以独立的算法出现，关于某类数据结构的各种 不同算法函数组合在一个文件之中，存储为一个头文件（如取名为 seqlistAlgo. h），以后凡 涉 及 到 要 使 用 本 文 件 中 的 顺 序 表 算 法 ， 一 定 要 在 你 的 文 件 的 前 面 加 上 一 条#include “seqlistAlgo. h” 即可，无需重复定义类似的算法，就象使用系统函数一样，只需进行函数原 型的声明即可。
【说明 1】――顺序表的定义与操作 1．可以将这三部分组合在一个文件中，也可以按照项目的方式（多个不同的文件组合
在一起，共同完成一个功能）进行组织（本课程的实验强烈推荐这种形式 ），如将本课程后 续所有算法几乎都要使用的常量定义（#define）和系统函数原型定义(#include)声明组合成 一个文件，存储为一个头文件（取名为 pubuse. h），只需建立一次，以后凡涉及到相关的内 容，只需在你的文件的前面加上一条#include “pubuse. h” 即可，无需重复输入。
实验一：线性表的存储结构定义及基本操作（必做：基本 2 学时，扩
展4 学时）
一、实验目的：
. 掌握线性表的逻辑特征 . 掌握线性表顺序存储结构的特点，熟练掌握顺序表的基本运算 . 熟练掌握线性表的链式存储结构定义及基本操作 . 理解循环链表和双链表的特点和基本运算 . 加深对顺序存储数据结构的理解和链式存储数据结构的理解，逐步培养解决实际问题 的编程能力
查前驱元素、查后继元素、顺序表合并等. 1．问题描述： . 根据给定元素的值，求出前驱元素； . 根据给定元素的值，求出后继元素； . 对已建好的两个顺序表进行合并操作，若原线性表中元素非递减有序排列,要求合并后的 结果还是有序(有序合并）；对于原顺序表中元素无序排列的合并只是完成 A=A∪B（无序合 并)，要求同样的数据元素只出现一次。
. 修改主程序，实现对各不同的算法调用。 2．实现要求： . “查前驱元素算法” 初始条件：顺序线性表 L 已存在 ；
操作结果：若数据元素存在且不是第一个，则返回前驱，否则操作失败； . “查后继元素算法” 初始条件：顺序线性表 L 已存在 ；
操作结果：若数据元素存在且不是最后一个，则返回后继，否则操作失败； . “无序合并算法”的初始条件：已知线性表 La 和 Lb；
4．还应包含一个 main 函数，作为整个程序的执行入口处，定义测试的数据，完成各种 算法的调用执行，对算法的执行过程和结果进行判断和输出控制，存储为一个源文件（如取 名为 seqlistUse. cpp）。
5．为了对实际问题更加通用和适应，在算法中使用的数据类型为 ElemType，为了与实 际数据类型一致，一般要将 ElemType 用 typedef 重定义：如实际问题中顺序表的每个元素 是整型，则使用 typedef int ElemType； 定义语句；如实际问题中顺序表的每个元素是单 精度实数的话，使用 typedef float ElemType； 定义语句。 【说明 2】――链表的定义与操作
. 求前驱结点是根据给定结点的值，在单链表中搜索其当前结点的后继结点值为给定的值， 将当前结点返回； . 求后继结点是根据给定结点的值，在单链表中搜索其当前结点的值为给定的值，将后继结 点返回； . 两个有序链表的合并是分别将两个单链表的结点依次插入到第 3 个单链表中，继续保持结 点有序； 2．实现要求： . “求前驱算法”初始条件: 线性表 L 已存在；
操作结果：依次对 L 的每个数据元素进行交换，为了使用最少的额外 空间，对顺序表的元素进行交换； . “输出算法”的初始条件：顺序线性表 L 已存在；
操作结果：依次对 L 的每个数据元素进行输出； . “销毁算法”初始条件：顺序线性表 L 已存在；
操作结果：销毁顺序线性表 L； . “置空表算法”初始条件：顺序线性表 L 已存在；
二、实验内容：
（一）基本实验内容（顺序表）： 建立顺序表，完成顺序表的基本操作：初始化、插入、删除、逆转、输出、销毁, 置空
表、求表长、查找元素、判线性表是否为空； 1．问题描述：利用顺序表,设计一组输入数据（假定为一组整数），能够对顺序表进行如下 操作： . 创建一个新的顺序表，实现动态空间分配的初始化； . 根据顺序表结点的位置插入一个新结点(位置插入)，也可以根据给定的值进行插入(值插 入)，形成有序顺序表； . 根据顺序表结点的位置删除一个结点(位置删除)，也可以根据给定的值删除对应的第一个 结点，或者删除指定值的所有结点(值删除)； . 利用最少的空间实现顺序表元素的逆转； . 实现顺序表的各个元素的输出； . 彻底销毁顺序线性表，回收所分配的空间； . 对顺序线性表的所有元素删除，置为空表； . 返回其数据元素个数；
1．根据一个完整的 C 语言组成，将实验内容组合成如上所述的三个组成部分，功能清 晰明了，其常量定义和常用系统函数原型声明的文件“pubuse.h”代码复用，不需另行建立。