实验一 线性表操作实验题目
实验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时无需移动)。
实验一 线性表的应用
voidInitializeSource(SourceTp *source);
voidSeqInsertVote(VoteTp *vote,inti,ElemTp x);
intSeqLocate(VoteTp v,ElemTp x);
}
}
voidInitializeVote(VoteTp *vote)
{
vote->len=0;
}
voidInitializeSource(SourceTp *Source)
{/*初始化备选数表Source，在表中放入1～3 6共3 6个数，将表长置为36 */
inti;
for(i=1;i<=NN;i++)
#defineMM 7
#defineNN 36
typedefintElemTp;
typedefstruct
{ ElemTp elem[MM+1];
intlen;
} VoteTp;
typedefstruct
{ ElemTp elem[NN+1];
intlen;
} SourceTp;
SourceTp source;
判断中奖情况，就是先初始化猜对号码个数为0，再依次用中奖号码表中的每个号码，在一张彩票号码表中查找，若有，猜对号码个数加1。处理完毕，猜对号码个数即可反映中奖情况。
3．解决方案
(1)彩票号码表、备选数表的存储结构类型定义
#define MM 7/*彩票中号码的个数*/
#define NN 36/*选数的个数*/
备选数表的初始化，备选数表初始状态含有1～36这36个数，元素间的顺序没有意义。
实验一：线性表应用
实验报告学院（系）名称：计算机与通信工程学院 姓名**学号 ********专业计算机科学与技术班级 2015级*班 实验项目实验一：线性表应用课程名称 数据结构与算法 课程代码 0661013 实验时间2017年3月9日第一节实验地点 7-219 考核标准 实验过程 25分程序运行 20分回答问题15分 实验报告30分 特色 功能5分考勤违纪情况 5分 成绩成绩栏其它批改意见: 教师签字：考核内容 评价在实验课堂中的表现，包括实验态度、编写程序过程等内容等。
□功能完善,□功能不全□有小错□无法运行○正确 ○基本正确○有提示○无法回答○完整 ○较完整○一般 ○内容极少 ○无报告○有 ○无 ○有 ○无一、实验目的? （1）将多项式各项的系数和指数分别存在A、B两个链表的中。
? （2）用指针Pa、Pb分别指向连个链表的首元素。
? （3）遍历两个链表，比较各元素的指数，若相同则相加减，将结果插入新表中，若不相等则将指数较小的插入新表中，继续向后遍历，直到其中一个链表到达表尾。
? （4）将另一表中的剩余元素按指数大小顺序全部插入到新表中。
? （5）新表中的元素按规定格式输出既为相加或相减后的多项式。
? 3、?? （1）通过构造函数创建单链表? （2）通过循环变量temp找到第一个链表的尾部设为p。
? （3）使p的next指向第二个链表的第一个元素? （4）将连接后的两链表输出? 4、? （1）用两个变量minZ,maxZ分别存储输入的最小值和最大值? （2）遍历整个单链表，将小于minZ和大于maxZ的节点删除? （3）输出操作后的单链表? 算法的实现和测试结果：包括算法运行时的输入、输出，实验中出现的问题及解决办法等? 出现问题? 无法返回操作后的单链表? 解决办法? 经老师直到后，在相关函数前面加*成功返回操作后的单链表? 1、3、4、? 算法时间复杂度分析? 1、O(1表长度+2表长度)---------------可视为O(n)? 3、O(1表长度+2表长度)---------------可视为O(n)? 4、O(n)?四、收获与体会线性表分为顺序表和链表，其中顺序表已相当熟悉，主要练了新接触的链表，感觉现在才真正体会到指针的魅力之处。
实验一线性表的基本操作
实验⼀线性表的基本操作⼀、线性结构的顺序表基本操作实验⽬的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逆置。
《软件技术基础》实验指导
说明每个实验题目含有一个main函数和一些函数, 与实验题目相关的基本运算的函数定义和main函数定义的代码在附录以及对应的文件夹中给出, 供上机实验参考使用。
对于每个题目, 只需要根据题目要求设计算法, 补充函数定义, 然后对程序进行编译、调试。
实验一线性表一、实验目的1．熟悉线性表的顺序和链式存储结构2．掌握线性表的基本运算3．能够利用线性表的基本运算完成线性表应用的运算二、实验内容设有一个线性表E={e1, e2, …, en-1, en}, 设计一个算法, 将线性表逆置, 即使元素排列次序颠倒过来, 成为逆线性表E’={ en , en-1 , …, e2 , e1 }, 要求逆线性表占用原线性表空间, 并且用顺序表和单链表两种方法表示, 分别用两个程序来完成。
（文件夹: 顺序表逆置、单链表逆置）已知由不具有头结点的单链表表示的线性表中, 含有三类字符的数据元素（字母、数字和其他字符）, 试编写算法构造三个以循环链表表示的线性表, 使每个表中只含有同一类的字符, 且利用原表中的结点空间, 头结点可另辟空间。
（文件夹: 分解单链表）实验二栈和队列一、实验目的1．熟悉栈和队列的顺序和链式存储结构2．掌握栈和队列的基本运算3．能够利用栈和队列的基本运算完成栈和队列应用的运算二、实验内容1．设单链表中存放有n个字符, 试编写算法, 判断该字符串是否有中心对称的关系, 例如xyzzyx是中心对称的字符串。
（提示: 将单链表中的一半字符先依次进栈, 然后依次出栈与单链表中的另一半字符进行比较。
）（文件夹: 判字符串中心对称）假设以数组sequ[m]存放循环队列的元素, 同时设变量rear和quelen 分别指示循环队列中队空的条件：sq->quelen==0；队满的条件：sq->quelen==m。
（文件夹：循环队列）实验三串一、实验目的1．熟悉串的顺序存储结构2．掌握串的基本运算及应用二、实验内容1. 串采用顺序存储结构, 编写朴素模式匹配算法, 查找在串中是否存在给定的子串。
数据结构实验一线性表的顺序
数据结构实验一线性表的顺序存储结构实验一：线性表的顺序存储结构实验学时：2验证实验类型：、实验目的：1.熟练掌握线性表的基本操作在顺序存储和链式存储上的实现；2.以线性表的各种操作（建立、插入、删除等）的实现为重点；3.掌握线性表的动态分配顺序存储结构的定义和基本操作的实现；二、实验内容：1•输入一组整型数据，建立顺序表。
2•实现该线性表的删除。
3.实现该线性表的插入。
4.实现线性表中数据的显示。
5.实现线性表数据的查找和定位5、编写一个主函数,调试上述算法。
三、实验原理、方法和手段1•根据实验内容编程，上机调试、得出正确的运行程序。
2.编译运行程序，观察运行情况和输出结果3.写出实验报告（包括源程序和运行结果)。
四、实验条件运行Visual C++的微机一台五、实验步骤(程序清单)：(一)、程序代码：#include "stdafx.h"#include <iostream>using namespace std;typedef int elemtype;struct list{elemtype *p;int size;int maxsize;};void buildlist(list &a, int b) /* 建立顺序表*/{if (b<=0){cout« "数据有误"<<endl;}a.p= new elemtype[b];if (a.p==NULL){coutvv "动态可分配的空间用完，退出运行！" vvendl;}a.size=0;a.maxsize=b;}void clearlist(list &a) /* 清空线性表*/{if (a.p!=NULL){delete []a.p;a.p=NULL;}a.maxsize =0;a.size=0;}bool insertlist(list &a, int pos,elemtype b) /*向线性表中按给定的位置插入一个元素*/ int i;if (pos<=0||pos-1>a.size){cout« "位置无效"《endl;return false ;}if (a.maxsize<=a.size){a.p=(elemtype*)realloc(a.p,2*a.maxsize * sizeof (b));a.maxsize=2*a.maxsize;}for ( i=a.size;i>=pos;i--)a.p[i]=a.p[i-1];a.p[i]=b;a.size++;return true ;}bool deletelist(list &a, int pos) /*向线性表中按给定的位置删除一个元素*/{if (a.size==0){coutvv "线性表为空，删除无效！" vvendl;return false ;}if (pos<=0||pos>a.size){coutvv "位置无效"vvendl;return false ;}for (int i=pos-1;iva.size-1;i++)a.p[i]=a.p[i+1];a.size--;if (float (a.size)va.maxsize*0.4&&a.maxsize>10){a.p=(elemtype*)realloc(a.p,a.maxsize*0.5* sizeof (*(a.p)));a.maxsize=a.maxsize*0.5;}return true ;}bool getlist(list a, int pos,elemtype &item) /* 得到线性表中指定位置的元素*/{if (posv=0||pos>a.size){cout« "位置无效"《endl;return false ;} item=a.p[pos-1]; return true ;}int findlist(list a,elemtype b) /*从线性表中查找具有给定值的第个元素*/{for (int i=O;i<a.size;i++)if (a.p[i]==b)return i+1;return 0;}void display(list a) /*线性表中数据的显示*/{coutvv "顺序表元素个数为："vva.size <<endl<< "所占内存单元为："vva.maxsize* sizeof (*(a.p)) <<'字节"vvendlvv"数据为：";for (int i=0;iva.size;i++)coutvva.p[i]vv " ";coutvvendl;}void main(){list L;int i=10;int pos;elemtype a,b,c;buildlist(L,5);for (int j=0;jv10;j++){insertlist(L,j+1,i);i--;}display(L);coutvvendl;coutvv " 一、插入操作："vvendl;coutvv "位置：";cin»pos;coutvv "数据：";cin>>a;if (insertlist(L,pos,a))coutvv "插入成功"vvendl;elsecout« "插入失败"《endl;display(L);cout<<endl;coutvv "二、删除操作："vvendl;coutvv "位置：";cin»pos;if (deletelist(L,pos))coutvv "删除成功"vvendl;elsecoutvv "删除失败"vvendl;display(L);coutvvendl;coutvv "三、定位操作："vvendl;coutvv "位置："；cin»pos;if (getlist(L,pos,b))coutvv "该位置数据为"vvbvvendl;elsecoutvv "定位失败"vvendl;coutvv "四、查找操作："vvendl;coutvv "数据：";cin>>c;if (findlist(L,c))coutvv "线性表中第一个等于该数据的位置为"vvfindlist(L,c)vvendl;elsecoutvv "线性表中没有等于该数据的元素"vvendl;clearlist(L);}(二)、程序运行结果六、实验分析与总结：通过本次实验，我发现了自己身上很多的不足：1•不知道什么时候才需要将函数的返回类型弄成bool类型；2•在编写函数体的时候，对排除非法情况考虑不周；3•对申请、追加及删除动态空间的语法不熟悉；4.没有思路对算法进行优化，例如，不知道怎样将所申请的动态空间适当缩小或放大。
数据结构-实验一 线性表操作
实验一线性表操作
（一）实验内容
单链表的创建、合并和输出。
（二）实验目的
1.熟悉用Visual C++进行程序设计的方法。
2.掌握单链表的创建、查找、插入和合并等运算。
（三）实验题目
本实验要求实现以下功能：
1.从键盘输入顺序任意的5个整数，按有序插入的要求生成第一个有序
单链表，将该链表输出显示。
2.再从键盘输入顺序任意的5个整数，按有序插入的要求生成第二个有
序单链表，将该链表输出显示。
3.将这两个有序单链表合并成一个有序单链表，要求使用两个单链表
的原有空间进行合并，将生成的有序单链表输出显示。
（四）实验仪器设备
1.学生每个一台PC机
2.已安装环境。
实验一 线性表操作实验题目
实验一线性表操作实验目的：(1)掌握在顺序、链式存储结构上实现线性表的各种基本运算。
(2)重点掌握单链表的基本操作及应用。
(3)学会综合运用C语言中函数、指针、结构体等知识进行编程。
本次实验中，下列实验项目选做一。
1、顺序表的综合操作[问题描述]设计算法，实现线性结构上的顺序表的建立以及元素的查找、插入、删除等操作。
[基本要求及提示]（1）从键盘输入10个整数，建立顺序表。
（2）从键盘输入1个整数，在顺序表中查找该结点的位置。
若找到，输出结点的位置；若找不到，则显示“找不到”。
（3）从键盘输入2个整数，一个表示欲插入的位置i，另一个表示欲插入的数值x，将x插入在对应位置上，输出顺序表所有结点值，观察输出结果。
（4）从键盘输入1个整数，表示欲删除结点的位置，输出顺序表所有结点值，观察输出结果。
（5）要求程序通过一个主菜单进行控制，在主菜单界面通过选择菜单项的序号来调用各功能函数。
2、线性表的逆置[问题描述]（1）以顺序存储结构实现线性表的就地逆置。
（2）以链式存储结构实现线性表的就地逆置。
注：线性表的就地逆置就是在原表的存储空间内将线性表（a1,a2,a3,…,an）逆置为（an，an-1，…，a2，a1）。
[基本要求及提示]（1）从键盘输入10个整数，建立顺序表。
（2）实现顺序表逆置，并将结果输出。
（3）从键盘输入10个整数，建立链表。
（4）实现链表逆置，并将结果输出。
（5）要求程序通过一个主菜单进行控制，在主菜单界面通过选择菜单项的序号来调用各功能函数。
也可以将顺序表和链表上的操作分开，做成两个程序。
3、线性表的元素分类[问题描述]已知线性表中元素均为正整数，设计算法将其调整为前后两部分，前边均为奇数，后边均为偶数。
即实现线性表的元素的分类。
[基本要求及提示]（6）从键盘输入10个整数，建立顺序表。
（7）实现顺序表上的元素分类，并输出结果。
（8）从键盘输入10个整数，建立链表。
（9）实现链表的元素分类，并输出结果。
实验线性表
实习一线性表的维护
以下题目选做1题，也可以两题都做。
题目1：
[问题描述]
以链式结构的有序表表示某商厦家电部的库存模型。
当有提货或进货的业务要求是，需要对该有序表及时进行维护。
[基本要求]
链式结构的有序表的结点结构的数据域应包括家电名称、品牌型号、单价及数量、以结点中单价值的非减序列体现着有序性。
日常的维护操作应包括初始化、创建表、插入、删除、更新数据、打印、查询。
[测试数据]
可以取彩电、冰箱和洗衣机的数据为模型，例如“彩电、TCL超平29寸、¥2100、234台”作为一个数据元素。
[实现提示]
链式结构的有序表可以利用有序表类型，数据域可以选用结构类型。
创建表的操作应用包含两种不同的工作方式，即手工输入和程序自动创建(预定的数据)。
查询操作会涉及到组合询问。
［问题讨论］
实现组合查询可作为该练习更进一步的要求。
为适应组合查询的业务需要，应为每一组数据配置一个内部的编号作为关键字，。
题目2：
[问题描述]。
实验一 线性表基本操作
{
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.实验目的：（1）掌握顺序表的基本操作的实现方法。
（2）应用顺序表的基本操作算法实现集合A=AUB算法。
（3）掌握链式线性表的基本操作的实现方法。
（4）利用链表的基本操作算法实现集合A=A∩B算法。
2.实验内容：2.1 编写一个程序algo1-1.cpp，实现顺序表的各种基本运算，并在此基础上设计一个主函数完成如下功能：（1）初始化顺序表L；（2）依次插入a，b，c，d，e元素；（3）输出顺序表L；（4）输出顺序表L长度；（5）判断顺序表L是否为空；（6）输出顺序表L的第3个元素；（7）输出元素‘a’的位置；（8）在第4个元素位置上插入‘f’元素；（9）输出顺序表L；（10）删除L的第3个元素；（11）输出顺序表L；（12）释放顺序表L。
2.2编写一个程序algo1-2.cpp，可利用以上基本操作算法，实现A=AUB算法。
2.3编写一个程序algo1-3.cpp，实现单链表的各种基本运算，并在此基础上设计一个主程序exp1-2.cpp完成如下功能：（1）初始化单链表H；（2）依次插入a，b，c，d，e元素；（3）输出单链表H；（4）输出单链表H长度；（5）判断单链表H是否为空；（6）输出单链表H的第3个元素；（7）输出元素‘a’的位置；（8）在第4个元素位置上插入‘f’元素；（9）输出单链表H；（10）删除H的第3个元素；（11）输出单链表H；（12）释放单链表H。
2.4 编写一个程序algo1-4.cpp，可利用以上基本操作算法，实现递增有序的两个单链表A、B的交集运算A=A∩B。
二、栈和队列——上机实验题1.实验目的：（1）掌握顺序栈和链栈的各种基本运算（2）掌握循环队列的各种基本运算（3）利用栈先进后出的特点，解决一些实际问题。
2.实验内容：2.1编写一个程序algo2-1.cpp，实现顺序栈的各种基本运算，并在此基础上设计一个主函数完成如下功能：（1）初始化顺序栈S；（2）判断栈S是否非空；（3）依次进栈元素a，b，c，d，e；（4）判断栈S是否非空；（5）输出栈的长度；（6）输出从栈顶到栈底元素；（7）元素出栈，输出出栈序列；（8）判断栈S是否非空；（9）释放栈。
数据结构实验一：线性表的应用
数据结构实验报告实验一线性表的应用一、实验目的：1．掌握线性表的两种存储结构及实现方式；2．熟练掌握顺序表和链表的建立、插入和删除的算法。
二、实验要求：1．C完成算法设计和程序设计并上机调试通过。
2．撰写实验报告，提供实验结果和数据。
3．写出算法设计小结和心得。
三、实验内容：1．用顺序表表示集合，编写程序以实现集合的交、并、差运算。
2．设带头结点的单链表ha和hb中结点数据域值按从小到大顺序排列，且各自链表内无重复的结点，要求：（1）建立两个按升序排列的单链表ha和hb。
（2）将单链表ha合并到单链表hb中，且归并后的hb链表内无重复的结点，结点值仍保持从小到大顺序排列。
（3）输出合并后单链表hb中每个结点的数据域值。
四、程序源代码：1.#include<stdio.h>#include<stdlib.h>#define LIST_INIT_CAPACITY 100 typedef int ElementType;typedef struct List{ElementType elem[LIST_INIT_CAPACITY]; int nLength;}SqList;void init(struct List*L)//初始化顺序表{if(L)L->nLength=0;}int visit(SqList*L,ElementType e)//遍历顺序表{for(int i=0;i<L->nLength;i++){if(L->elem[i]==e){return 0;break;}elsecontinue;return 1;}}SqList*jiao(SqList*L1,SqList*L2,SqList*L3)//求两个集合的交集{int n=0;for(int i=0;i<L1->nLength;i++){for(int j=0;j<L2->nLength;i++){if(L1->elem[i]==L2->elem[j]){L3->elem[n]=L1->elem[i];n++;}elsecontinue;}}printf("集合的交集：\n");return L3;}SqList*bing(SqList*L1,SqList*L2,SqList*L3)//求两个集合的并集{int j=0;for (int i=0;i<L1->nLength;i++){if (visit(L2,L1->elem[i])){L3->elem[j]=L1->elem[i];L3->nLength++;j++;}elsecontinue;}printf("集合的并集：\n");return L3;}SqList*cha(SqList*L1,SqList*L2,SqList*L3)//求两个集合的差集{int j=0;for(int i=0;i<L1->nLength;i++){if(visit (L2,L1->elem[i])){L3->elem[j]=L1->elem[i];j++;L3->nLength++;}elsecontinue;}printf("集合的差集：\n");return L3;}void show(SqList *list)//显示线性表元素{for (int i=0;i<list->nLength;i++){printf(" %d",list->elem[i]);}printf("\n");}void main(){SqList*list1,*list2,*list3;list1=(SqList*)malloc(sizeof(SqList));list2=(SqList*)malloc(sizeof(SqList));list3=(SqList*)malloc(sizeof(SqList));init(list1);init(list2);init(list3);intstr1[6]={1,2,3,4,5,6},str2[7]={1,3,4,5,7,9,10};for(int i=0;i<6;i++){list1->elem[i]=str1[i];list1->nLength=i+1;}for(i=0;i<7;i++){list2->elem[i]=str2[i];list2->nLength++;}printf("初始集合：\n");show(list1);show(list2);list3=jiao(list1,list2,list3);show(list3);init(list3);list3=bing(list1,list2,list3);show(list3);init(list3);list3=cha(list1,list2,list3);show(list3);}2.#include <stdio.h>#include<stdlib.h>typedef int ElementType;typedef struct ListNode{ElementType data;struct ListNode *next;}sLinkList;sLinkList*create(ElementType i)//创建接点{sLinkList *p;p=(sLinkList*)malloc(sizeof(sLinkList));if(!p)exit(0);elsep->data=i;return p;}void anotherorder(sLinkList*head){sLinkList*P;P=head->next;if(head!=NULL)//头指针不为空{while (P->next!=NULL){sLinkList*q;//p的后继指针sLinkList*t;q=P->next;t=P->next->next;q->next=head->next;head->next=q;P->next=t;}}}void print(sLinkList*head)//输出链表{if(head==NULL){exit(0);}sLinkList*p=head->next;while(p!=NULL){printf("%4d",p->data);p=p->next;}printf("\n");}void hebing(sLinkList *p,sLinkList *q,sLinkList *l)//将两个链表合并{ sLinkList*z;q=q->next;l=l->next;while(q!=NULL&&l!=NULL){if(q->data>l->data){z=create(l->data);p->next=z;z->next=NULL;p=z;l=l->next;}elseif(q->data<l->data){z=create(q->data);p->next=z;z->next=NULL;p=z;q=q->next;}elseif(q->data==l->data){for(int i=0;i<2;i++){z=create(q->data);p->next=z;z->next=NULL;p=z;}q=q->next;l=l->next;}}if(q==NULL){while (l!=NULL){z=create(l->data);p->next=z;z->next=NULL;p=z;l=l->next;}}if(l==NULL){while (q!=NULL){z=create(q->data);p->next=z;z->next=NULL;p=z;q=q->next;}}printf("合并后：\n");}void deletelist(sLinkList*p)//删除多余元素节点{if(p!=NULL)p=p->next;sLinkList*q;//中间指针while (p!=NULL){int i=p->data;sLinkList*head=p;while (head->next!=NULL){if(i==head->next->data){q=head->next;head->next=q->next;free(q);}elsehead=head->next;}p=p->next;}printf("最终结果：\n");}void main(){sLinkList *ha; ha=(sLinkList*)malloc(sizeof(ListNode)); if(ha!=NULL)//判空{ha->next=NULL;ha->data=-1;}sLinkList *p;sLinkList *q=ha;int a[5]={2,4,6,8,10};for (int i=0;i<5;i++){p=create(a[i]);q->next=p;p->next=NULL;q=p;}printf("初始：\n");print(ha);sLinkList *hb;hb=(sLinkList*)malloc(sizeof(ListNode)); if(hb!=NULL)//判空{hb->next=NULL;hb->data=-1;}q=hb;int b[6]={1,4,5,8,9,10};for (i=0;i<6;i++){p=create(b[i]);q->next=p;p->next=NULL;q=p;}print(hb);//构建ha,hbsLinkList *hc;hc=(sLinkList*)malloc(sizeof(ListNode)); hebing(hc,ha,hb);print(hc);deletelist(hc);print(hc);}五、测试结果：1.2.六、小结（包括收获、心得体会、存在的问题及解决问题的方法、建议等）经过这次实验，我对线性表的两种形式顺序表和链表有了进一步的了解，对线性表之间的运算及线性表的简单应用有了更深的体会。
数据结构实验线性表
数据结构实验报告实验名称：实验一线性表——题目1学生姓名：王海洋班级： 2018211107学号：2018210191日期： 2019年3月22日1.实验要求实验目的：熟练掌握线性表的基本操作，包括：创建、插入、删除、查找、输出、求长度、合并等运算，以及各类操作在顺序存储结构和链式存储结构上的实现。
实验内容：根据线性表的抽象数据类型的定义，选择下面任一种链式结构实现线性表，并完成线性表的基本功能。
线性表存储结构（五选一）：1、带头结点的单链表2、不带头结点的单链表3、循环链表4、双链表5、静态链表线性表的基本功能：1、构造：使用头插法、尾插法两种方法2、插入：要求建立的链表按照关键字从小到大有序3、删除4、查找5、获取链表长度6、销毁7、其他：可自行定义编写测试main()函数测试线性表的正确性。
2.程序分析2.1 存储结构链表的具体存储表示为：①用一组任意的存储单元来存放线性表的结点（这组存储单元既可以是连续的，也可以是不连续的）② 链表中结点的逻辑次序和物理次序不一定相同。
为了能正确表示结点间的逻辑关系，在存储每个结点值的同时，还必须存储指示其后继结点的地址信息（称为指针）链表的结点结构┌──┬──┐│data│next│└──┴──┘data 域--存放结点值的数据域next 域--存放结点的直接后继的地址（位置）的指针域（链域）地址 内存单元1000H头指针 1020H 1080H 10C0H2.2 关键算法分析1、关键算法：1：头插法自然语言描述：a:在堆中建立新结点b:将a[i]写入到新结点的数据域c:修改新结点的指针域d:修改头结点的指针域。
将新结点加入链表中伪代码描述a:Node <T> * s=new Node <T>b:s->data=a[i]c:s->next=front->next;d:front->next=s2：尾插法自然语言描述：a:在堆中建立新结点：b:将a[i]写入到新结点的数据域：c:将新结点加入到链表中d:修改修改尾指针伪代码描述a:Node <T> * s=new Node <T>b:s->data=a[i]c:r->next=s;d:r=s3：析构/删除函数自然语言描述：a:新建立一个指针，指向头结点b:判断要释放的结点是否存在，c:暂时保存要释放的结点d:移动a中建立的指针e:释放要释放的指针伪代码描述a:Node <T> * p=frontb:while(p)c:front=pd:p=p->nexte:delete front4：按位查找函数自然语言描述：a:初始化工作指针p和计数器j，p指向第一个结点，j=1b:循环以下操作，直到p为空或者j等于1b1：p指向下一个结点b2：j加1c:若p为空，说明第i个元素不存在，抛出异常d:否则，说明p指向的元素就是所查找的元素，返回元素地址伪代码描述a:Node <T> * p=front->next;j=1;b:while(p&&j!=1)b1:p=p->nextb2:j++c:if(!p) throw ”error”d:return p5：按位查找函数自然语言描述：a:初始化工作指针p和计数器j，p指向第一个结点，j=1b:循环以下操作，找到这个元素或者p指向最后一个结点 b1：判断p 指向的结点是不是要查找的值，如果是，返回j，否则p指向下一个结点，并且j的值加一c:如果找到最后一个结点还没有找到要查找的元素，返回查找失败信息伪代码描述a:Node <T> * p=front->next;j=1;b:while(p)b1: if(p->next==x) return jp=p->nextj++c:return “error”6：插入函数自然语言描述：a:在堆中建立新结点b:将要插入的结点的数据写入到新结点的数据域c:修改新结点的指针域d:修改前一个指针的指针域，使其指向新插入的结点的位置伪代码描述a:Node <T> * s=new Node <T>;b:s-data=p->datac:s->next=p->nextd:p->next=se:p->data=x7：删除函数自然语言描述：a:从第一个结点开始，查找要删除的位数i前一个位置i-1的结点b:设q指向第i个元素c:将q元素从链表中删除d:保存q元素的数据e:释放q元素伪代码描述a:q=p->nextb:p->next=q->nextc:x=q->datad:delete q8：遍历打印函数自然语言描述：a:判断该链表是否为空链表，如果是，报错b:如果不是空链表，新建立一个temp指针c:将temp指针指向头结点d:打印temp指针的data域e:逐个往后移动temp指针，直到temp指针的指向的指针的next域为空伪代码描述If front->next==NULLThrow ”an empty list ”Node<T>* temp=front->next;while(temp->next){ cout<<temp->data<<" ";temp=temp->next;}9：获取链表长度函数自然语言描述：a:判断该链表是否为空链表，如果是，输出长度0b:如果不是空链表，新建立一个temp指针，初始化整形数n为0c:将temp指针指向头结点d:判断temp指针指向的结点的next域是否为空，如果不是，n加一，否则return n e: 使temp指针逐个后移，重复d操作，直到temp指针指向的结点的next域为0，返回n 伪代码描述int n=0if ront->next==NULLn=0;else{ Node<T>* temp=front->next;while(temp->next)n++;temp=temp->next;}return n;2、代码详细分析：（1）从第一个结点开始，查找节点，使它的数据比x大，设p指向该结点：while (x>p->data) { p=p->next;}（2）新建一个节点s，把p的数据赋给s：s->data=p->data;（3）把s加到p后面：s->next=p->next; p->next=s;（4）p节点的数据用x替换：p->data=x;示意图如图所示3、关键算法的时间复杂度：O（1)3.程序运行结果程序截图4.总结1.调试时出现的问题及解决的方法：（1）刚开始时用NULL置空最后一个节点的指针域，发现调试时出现NULL未声明的情况。
《数据结构(Java版)》课程实验选题
《数据结构（Java版）》课程实验选题实验一线性表的基本操作实验范围为第2章，任务是验证教材中的线性表类及其基本操作，设计实现指定操作的算法，并做算法分析。
“实验目的和要求”已由教材实验2给出。
要求使用Java语言，采用泛型类，算法效率为一次遍历。
实验题目及分配如下（按班级名单序号依次选取）。
以下各题对带头结点的单链表进行操作，方法声明见实验2。
（1）判断单链表是否包含另一条单链表的所有结点，即判断无序的子集。
（2）返回从单链表指定位置开始、长度为n的子表，深拷贝。
（3）以深拷贝方式在单链表的指定位置插入另一条单链表，集合并运算。
（4）以深拷贝方式在单链表最后添加另一条单链表的所有结点。
（5）删除单链表从指定位置开始、长度为n的子表。
（6）返回由两条单链表中元素值相同的所有结点组成的单链表对象，集合交运算。
（7）删除当前单链表中那些也包含在list链表中的所有结点，集合差运算。
（8）判断单链表是否包含与另一条单链表匹配的子表，BF模式匹配算法。
（9）将单链表中所有与sourcelist匹配的子表替换为destlist子表，包含BF模式匹配算法。
以下各题对带头结点的循环单链表进行操作：（10）比较两条循环单链表是否相等。
（11）判断循环单链表是否包含另一条循环单链表的所有结点。
（12）返回从循环单链表指定位置开始、长度为n的子表，深拷贝。
（13）实现循环单链表深拷贝功能。
（14）由单链表构造循环单链表，深拷贝。
（15）以深拷贝方式在循环单链表的指定位置插入另一条循环单链表，集合并运算。
（16）以深拷贝方式在循环单链表最后添加另一条循环单链表的所有结点。
（17）删除循环单链表从指定位置开始、长度为n的子表。
（18）返回由两条循环单链表中元素值相同的所有结点组成的循环单链表对象，集合交运算。
（19）删除循环单链表中那些也包含在指定另一条循环单链表中的所有结点，集合差运算。
（20）判断循环单链表是否包含与另一条循环单链表匹配的子表。
实验一线性表操作实验报告
实验一_线性表操作_实验报告实验一：线性表操作一、实验目的1.理解线性表的基本概念和特点。
2.掌握线性表的基本操作，包括插入、删除、查找等。
3.通过实验，提高动手能力和解决问题的能力。
二、实验原理线性表是一种较为常见的数据结构，它包含零个或多个数据元素，相邻元素之间有前后关系。
线性表具有以下特点：1.元素之间一对一的顺序关系。
2.除第一个元素外，每个元素都有一个直接前驱。
3.除最后一个元素外，每个元素都有一个直接后继。
常见的线性表有数组、链表等。
本实验主要针对链表进行操作。
三、实验步骤1.创建链表：首先创建一个链表，并给链表添加若干个节点。
节点包括数据域和指针域，数据域存储数据，指针域指向下一个节点。
2.插入节点：在链表中插入一个新的节点，可以选择在链表的头部、尾部或中间插入。
3.删除节点：删除链表中的一个指定节点。
4.查找节点：在链表中查找一个指定数据的节点，并返回该节点的位置。
5.遍历链表：从头节点开始，依次访问每个节点的数据。
四、实验结果与分析1.创建链表结果：我们成功地创建了一个链表，每个节点都有数据域和指针域，数据域存储数据，指针域指向下一个节点。
2.插入节点结果：我们成功地在链表的头部、尾部和中间插入了新的节点。
插入操作的时间复杂度为O(1)，因为我们只需要修改指针域即可。
3.删除节点结果：我们成功地删除了链表中的一个指定节点。
删除操作的时间复杂度为O(n)，因为我们可能需要遍历整个链表才能找到要删除的节点。
4.查找节点结果：我们成功地在链表中查找了一个指定数据的节点，并返回了该节点的位置。
查找操作的时间复杂度为O(n)，因为我们可能需要遍历整个链表才能找到要查找的节点。
5.遍历链表结果：我们成功地遍历了整个链表，并访问了每个节点的数据。
遍历操作的时间复杂度为O(n)，因为我们可能需要遍历整个链表。
通过本次实验，我们更加深入地理解了线性表的基本概念和特点，掌握了线性表的基本操作，包括插入、删除、查找等。
数据结构--实验报告_线性表的基本操作备用
实验目的实验内容和要求源代码顺序表的代码单链表的代码测试结果顺序表的测试结果单链表的测试结果五、心得体会实验一线性表的基本操作及其应用一、实验目的1.帮助读者复习C++语言程序设计中的知识。
2.熟悉线性表的逻辑结构。
3.熟悉线性表的基本运算在两种存储结构上的实现。
4.掌握顺序表的存储结构形式及其描述和基本运算的实现。
5.熟练掌握动态链表结构及有关算法的设计二、实验内容题目一: 顺序表的基本操作[问题描述]实现顺序表的建立、求长度, 取元素、修改元素、插入、删除等顺序表的基本操作。
[基本要求]（1）依次从键盘读入数据, 建立带头结点的顺序表；（2）输出顺序表中的数据元素（3）求顺序表的长度；（4）根据指定条件能够取元素和修改元素；（5）实现在指定位置插入和删除元素的功能。
（6）根据算法, 将两个有序的顺序表合并成一个有序顺序表。
[测试数据] 由学生任意指定。
题目二: 单链表的基本操作[问题描述]实现带头结点的单链表的建立、求长度, 取元素、修改元素、插入、删除等单链表的基本操作。
[基本要求]（1）依次从键盘读入数据, 建立带头结点的单链表；（2）输出单链表中的数据元素（3）求单链表的长度；（4）根据指定条件能够取元素和修改元素；（5）实现在指定位置插入和删除元素的功能。
（6）根据算法, 将两个有序的单链表合并成一个有序单链表。
[测试数据]由学生任意指定。
三、源代码顺序表的基本操作#include<iostream>using namespace std;#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;typedef int ElemType;#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef struct { //结构体ElemType *elem;int length;int listsize;}SqList;SqList Lx;Status InitList_Sq(SqList &L) //分配空间{ L.elem=new ElemType[LIST_INIT_SIZE];if(!L.elem)exit(OVERFLOW);L.length =0;L.listsize=LIST_INIT_SIZE;return OK;}Status ListInsert(SqList &L,int i,ElemType e) //插入新元素{ int *q,*p;ElemType *newbase;if(i<1 || i>L.length+1) return ERROR;if(L.length>=L.listsize){ newbase=new ElemType[L.listsize+LISTINCREMENT];if(!newbase) exit(OVERFLOW);L.elem=newbase;L.listsize+=LISTINCREMENT;}q=&(L.elem[i-1]);for (p=&(L.elem[L.length-1]);p>=q;--p)*(p+1)=*p;*q=e;++L.length;return OK;}Status Listlength(SqList L) //长度{ int *p=L.elem; //判断线形表是否存在while(p){ return (L.length); }}Status GetElem(SqList L, int i,ElemType &e) //取元素{ if(i<1 || i>L.length)return ERROR;else{ e=L.elem[i-1];return e;}}void MergeList(SqList La,SqList Lb,SqList &Lc) //合并{ ElemType ai,bj;InitList_Sq(Lc);int i=1,j=1,k=0;int La_len,Lb_len;La_len=Listlength(La);Lb_len=Listlength(Lb);while((i<=La_len)&&(j<=Lb_len)){ GetElem(La,i,ai);GetElem(Lb,j,bj);if(ai<=bj){ ListInsert(Lc,++k,ai);++i; }else{ ListInsert(Lc,++k,bj);++j; }}while(i<=La_len){ GetElem(La,i++,ai);ListInsert(Lc,++k,ai);}while(j<=Lb_len){ GetElem(Lb,j++,bj);ListInsert(Lc,++k,bj);}}void show(SqList L,int i) //显示{ int j;ElemType k;cout<<"顺序表显示如下:"<<endl;for(j=0;j<i-1;j++){ k=L.elem[j];cout<<k<<"->"; }if(j==i-1 && i>0){ k=L.elem[j]; cout<<k; }cout<<endl;}void create(SqList &L,int n) //输入元素{ int e;for(int i=0;i<n;i++){ cin>>e;L.elem[i]=e;L.length=i+1; }}Status ListDelete_Sq(SqList &L,int i,ElemType &e) //删除{ ElemType *p, *q;if(i<1 || i>L.length) return ERROR;p=&(L.elem[i-1]);e=*p;q=L.elem+L.length-1;for(++p;p<=q;++p) *(p-1)=*p;--L.length;return OK;}Status Listxiugei(SqList &L,int i,ElemType &e) //修改{ if(i<1 || i>L.length)return ERROR;else{ L.elem[i-1]=e;return OK; }}void shuru(SqList &L1) //顺序表的创建{ int a;InitList_Sq(L1);cout<<"请输入顺序表的长度: ";cin>>a;cout<<"请输入顺序表的元素(共"<<a<<"个)"<<endl;create(L1,a);show(L1,a);}void chaxun(SqList &L1) //取第i个位置的元素{ int j;ElemType e1;cout<<"请选择所要取出元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误, 请重新输入"<<endl;cout<<"请选择所要取出元素的位置:";cin>>j; }GetElem(L1,j,e1);cout<<"取出的元素为:"<<e1<<endl; }void xiugai(SqList &L1) //修改第i个位置的元素{ int a;int j; ElemType e1;a=L1.length;cout<<"请选择所要修改元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误, 请重新输入"<<endl;cout<<"请选择所要修改元素的位置:";cin>>j; }cout<<"要修改成的元素:";cin>>e1;Listxiugei(L1,j,e1);cout<<"修改后的顺序表数据:"<<endl;show(L1,a);}void shanchu(SqList &L1) //删除顺序表里的元素{ int a;int j; ElemType e1;a=L1.length;cout<<"请选择所要删除元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误, 请重新输入"<<endl;cout<<"请选择所要删除元素的位置:";cin>>j; }ListDelete_Sq(L1,j,e1);cout<<"修改后的顺序表数据:"<<endl;show(L1,a-1);}void charu(SqList &L1) //插入元素到顺序表里{ int a; int j; ElemType e1;a=L1.length;cout<<"请选择所要插入元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误, 请重新输入"<<endl;cout<<"请选择所要插入元素的位置:";cin>>j; }cout<<"要插入的元素:";cin>>e1;ListInsert(L1,j,e1);cout<<"修改后的顺序表数据:"<<endl;show(L1,a+1);}void hebing(SqList &L3) //合并两个顺序表{ SqList L1,L2;int a,b;InitList_Sq(L1); InitList_Sq(L2);cout<<"请输入第一个有序表的长度: "; cin>>a;cout<<"请输入第一个有序表的元素(共"<<a<<"个)"<<endl;create(L1,a);show(L1,a);cout<<"请输入第二个有序表的长度: "; cin>>b;cout<<"请输入第二个有序表的元素(共"<<b<<"个)"<<endl;create(L2,b);show(L2,b);MergeList(L1,L2,L3);cout<<"合并后的有序表如下: "; show(L3,a+b);}void main() //主菜单{ int choice;for(;;){ cout<<" 顺序表的基本操作"<<endl;cout<<" 1.顺序表的创建"<<endl;cout<<" 2.顺序表的显示"<<endl;cout<<" 3.顺序表的长度"<<endl;cout<<" 4.取第i个位置的元素"<<endl;cout<<" 5.修改第i个位置的元素"<<endl;cout<<" 6.插入元素到顺序表里"<<endl;cout<<" 7.删除顺序表里的元素"<<endl;cout<<" 8.合并两个顺序表"<<endl;cout<<" 9.退出系统"<<endl;cout<<"请选择: ";cin>>choice;switch(choice){ case 1: shuru(Lx);break;case 2: show(Lx,Lx.length);break;case 3: cout<<"顺序表的长度:"<<Listlength(Lx)<<endl;break;case 4: chaxun(Lx);break;case 5: xiugai(Lx);break;case 6: charu(Lx);break;case 7: shanchu(Lx);break;case 8: hebing(Lx);break;case 9: cout<<"退出系统!"<<endl;exit(0);break;default : cout<<"输入有误, 请重新选择"<<endl;break; } }}单链表的基本操作#include<iostream>using namespace std;#define true 1#define false 0#define ok 1#define error 0#define overflow -2typedef int Status;typedef int ElemType;typedef struct LNode //存储结构{ ElemType data;struct LNode *next;}LNode,*LinkList;void CreateList(LinkList &L,int n) //尾插法创建单链表{ LinkList p;L=new LNode;L->next=NULL; //建立一个带头结点的单链表LinkList q=L; //使q指向表尾for(int i=1;i<=n;i++){ p=new LNode;cin>>p->data;p->next=NULL;q->next=p;q=p; }}Status GetElem(LinkList L,int i,ElemType &e)//取第i个元素{ LinkList p=L->next;int j=1;while(p&&j<i){ p=p->next;++j; }if(!p||j>i) return error; //第i个元素不存在e=p->data;return ok;}Status LinkInsert(LinkList &L,int i,ElemType e) //插入{ LinkList p=L;int j=0;while(p&&j<i-1){ p=p->next;++j; } //寻找第i-1个结点if(!p||j>i-1)return error; //i小于1或者大于表长加1 LinkList s=new LNode; //生成新结点s->data=e;s->next=p->next; //插入L中p->next=s;return ok;}Status ListDelete(LinkList &L,int i,ElemType &e) // 删除{ LinkList p=L;LinkList q;int j=0;while(p->next&&j<i-1){ //寻找第i个结点, 并令p指向其前驱p=p->next;++j; }if(!(p->next)||j>i-1) return error; //删除位置不合理q=p->next;p->next=q->next; //删除并释放结点e=q->data;delete(q);return ok;}void MergeList(LinkList &La,LinkList &Lb,LinkList &Lc){ //合并两个顺序链表LinkList pa,pc,pb;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;delete(Lb);}void show(LinkList L) //显示{ LinkList p;p=L->next;while(p){ cout<<p->data<<"-->";p=p->next; }cout<<endl;}int Length(LinkList L,int i) //表长{ i=0;LinkList p=L->next;while(p){ ++i;p=p->next; }return i;}void xiugai(LinkList L) //修改{ int i,j=1;ElemType k;ElemType e,m;LinkList p=L->next;cout<<"请输入要修改的元素位置(0<i<length):";cin>>i;GetElem(L,i,e);cout<<"该位置的元素:"<<e<<endl;cout<<"修改后的元素值:";cin>>k;while(p&&j<i){ p=p->next;++j; }m=p->data;p->data=k;cout<<"修改后的单链表显示如下:"<<endl;show(L);}void hebing() //合并两个单链表{ int a,b;LinkList La,Lb,Lc;cout<<"请输入第一个有序链表的长度:"<<endl;cin>>a;cout<<"请输入第一个有序链表的元素共（"<<a<<"个）: "<<endl;CreateList(La,a);show(La);cout<<"请输入第二个有序链表的长度:"<<endl;cin>>b;cout<<"请输入第二个有序链表的元素共（"<<b<<"个）: "<<endl;CreateList(Lb,b);show (Lb);MergeList(La,Lb,Lc);cout<<"合并后的有序链表如下: "<<endl;show(Lc);}void main() //主函数{ int select;int x;ElemType y;LinkList list;for(;;){ cout<<" 单链表的基本操作"<<endl;cout<<" 1.单链表的创建"<<endl;cout<<" 2.单链表的显示"<<endl;cout<<" 3.单链表的长度"<<endl;cout<<" 4.取第i个位置的元素"<<endl;cout<<" 5.修改第i个位置的元素"<<endl;cout<<" 6.插入元素到单链表里"<<endl;cout<<" 7.删除单链表里的元素"<<endl;cout<<" 8.合并两个单链表"<<endl;cout<<" 9.退出系统"<<endl;cout<<"请选择:";cin>>select;switch(select){ case 1:cout<<"请输入单链表的长度:"<<endl;cin>>x;cout<<"请输入"<<x<<"个元素"<<endl;CreateList(list,x);break;case 2: cout<<"单链表显示如下:"<<endl;show(list);break;case 3: int s;cout<<"单链表的长度为:"<<Length(list,s)<<endl;break;case 4: cout<<"请选择所要取出元素的位置:";cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误, 请重新输入"<<endl;cout<<"请选择所要取出元素的位置:";cin>>x; }GetElem(list,x,y);cout<<"该位置的元素为:"<<y<<endl;break;case 5: xiugai(list); break;case 6: cout<<"请选择要插入的位置:"; cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误, 请重新输入"<<endl;cout<<"请选择所要插入元素的位置:";cin>>x; }cout<<"要插入的元素值:";cin>>y;LinkInsert( list,x,y);cout<<"插入后单链表显示如下:"<<endl;show(list);break;case 7: cout<<"请选择要删除的位置:"; cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误, 请重新输入"<<endl;cout<<"请选择所要删除元素的位置:";cin>>x; }ListDelete(list,x,y);cout<<"要删除的元素值:"<<y<<endl;cout<<"删除后的单链表显示如下:"<<endl;show(list);break;case 8: hebing();break;case 9: exit(0);break;default : cout<<"输入有误, 请重新输入"<<endl;break;}}}四、测试结果顺序表的测试结果单链表的测试结果五、心得体会当听到老师说写数据结构实验报告时, 我有点惊讶, 才学了不到一个月, 就要写实验报告。
实验一 线性表相关操作
实验一线性表的相关操作班级：13计科4班学号：20132599 姓名：周强飞实验目的：通过实验题的上机实践，帮助学生掌握线性表的基本操作在两种存储结构上算法的实现，特别是链表的操作和应用作为重点。
实验内容：实验1.1 顺序表的操作【问题描述】利用顺序存储方式实现下列功能：根据键盘输入数据建立一个线性表；然后根据屏幕菜单的选择，可以进行数据的插入、删除、查找以及输出线性表的长度，并在插入或删除线性表数据后，再输出线性表；最后在屏幕菜单中选择0，即可结束程序的运行。
【基本要求】试对顺序表编写实现上述操作的算法并上机编写代码，要求算法尽可能高效。
【提示及分析】当我们要在顺序表的第i个位置上插入一个元素时，必须先将先将一个线性表的第i个元素之后的所有元素依次后移一个位置，再把新元素插到该位置。
当要删除第i个元素时，也只需要将第i个元素之后的所有元素前移一个位置。
【算法及算法描述】//顺序表的存储结构#define LIST_INIT_SIZE 10 // 线性表存储空间的初始分配量#define LIST_INCREMENT 2 // 线性表存储空间的分配增量Typedef struct{ElemType *elem; // 存储空间基址int length; // 当前长度int listsize; // 当前分配的存储容量(以sizeof(ElemType)为单位)}SqList;//初始化顺序表void InitList(SqList &L){ // 操作结果：构造一个空的顺序线性表LL.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L.elem)exit(OVERFLOW); // 存储分配失败L.length=0; // 空表长度为0L.listsize=LIST_INIT_SIZE; // 初始存储容量}//顺序表的插入操作Status ListInsert(SqList &L,int i,ElemType e){ // 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)+1// 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1ElemType *newbase,*q,*p;if(i<1||i>L.length+1) // i值不合法return ERROR;if(L.length>=L.listsize) // 当前存储空间已满,增加分配{if(!(newbase=(ElemType*)realloc(L.elem,(L.listsize+LIST_INCREMENT)*sizeof(ElemType)))) exit(OVERFLOW); // 存储分配失败L.elem=newbase; // 新基址L.listsize+=LIST_INCREMENT; // 增加存储容量}q=L.elem+i-1; // q为插入位置for(p=L.elem+L.length-1;p>=q;--p) // 插入位置及之后的元素右移*(p+1)=*p;*q=e; // 插入e++L.length; // 表长增1return OK;}//线性表的删除操作Status ListDelete(SqList &L,int i,ElemType &e){ // 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)// 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1ElemType *p,*q;if(i<1||i>L.length) // i值不合法return ERROR;p=L.elem+i-1; // p为被删除元素的位置e=*p; // 被删除元素的值赋给eq=L.elem+L.length-1; // 表尾元素的位置for(++p;p<=q;++p) // 被删除元素之后的元素左移*(p-1)=*p;L.length--; // 表长减1return OK;}//线性表的定位操作int LocateElem(SqList L,ElemType e,Status(*compare)(ElemType,ElemType)){ // 初始条件：顺序线性表L已存在，compare()是数据元素判定函数(满足为1，否则为0) // 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。
实验1 线性表(部分题目)
实验1 线性表
（以下是部分题目）
实验要求：
使用Visual C++ 2005开发环境，完成以下习题。
1. 按照课本第
2.2节定义的线性表结构，完成对线性表结构的定义，以及对线性表的各种基本运算的实现（每种基本运算用一个函数来实现）。
基本运算包括：初始化InitList运算、求表长Length运算、插入新节点Insert 运算、删除节点Delete运算、定位（按值查找）Locate运算、读表元Get运算。
并且在main函数中分别调用以上各种基本运算的函数来使用，以证明其功能已实现。
实验效果展示可参考以下截图（也可自行设计，能展示清楚即可）。
此题的源程序保存为2_a1.cpp。
2. 一个顺序表中存放字符（只有数字字符和英文字符），编写算法删除所有的数字字符。
此题的源程序保存为2_a2.cpp。
3.未完，待续……。
实验提交要求：
1.每位同学的文件必须严格按照题目的要求对文件进行命名，否则按不提交作
业处理。
2.每位同学的作业放在一个文件夹中提交，只需提交源文件(后缀名是.cpp的文
件)，文件夹按以下格式命名：
“班内序号_姓名_实验1”
例如：03_陈嘉瑞_实验1
3.实验完成后，提交到指定服务器。
服务器地址：
ftp://10.5.1.5用户名和密码都是：we
请提交到服务器的“作业→数据结构→实验1”文件夹中以各自班级名称命名的文件夹内。
（请认清楚班级名称提交，切勿提交到其他班的文件夹中。
）4.本次实验提交的截止日期是2011年9月日。
数据结构实验一 线性表的操作与应用
长春大学计算机学院网络工程专业数据结构实验报告实验名称：实验一线性表的操作与应用班级：网络四班姓名：刘虹秀学号：041440406实验地点：教室日期：2015-3-27一、实验目的：1．掌握线性表的两类存储结构（顺序存储结构和链式存储结构）的描述方法。
2．掌握在顺序结构中实现查找、插入、删除操作的基本方法。
3．掌握在各种链表结构中实现查找、插入、删除操作的基本方法。
二、实验内容、要求和环境：注：将完成的实验报告重命名为：班级+学号+姓名+（实验一），（如：041340538张三（实验一）），发邮件到：ccujsjzl@。
提交时限：本次实验后24小时之内。
阅读程序，完成填空，并上机运行调试。
1、线性表的顺序存储结构的定义及其基本操作。
建立顺序表，完成顺序表的基本操作：初始化、插入、删除、输出、销毁, 置空表、求表长、查找元素、判线性表是否为空。
(1) 文件1：pubuse. h 是公共使用的常量定义和系统函数调用声明。
#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> /* exit() *//* 函数结果状态代码*/#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1typedef int Status; /* Status 是函数的类型,其值是函数结果状态代码，如OK 等*/typedef int Boolean; /* Boolean 是布尔类型,其值是TRUE 或FALSE */(2) 文件2：seqlistDef. h 进行线性表的动态分配顺序存储结构的表示#define LIST_INIT_SIZE 10 /* 线性表存储空间的初始分配量*/#define LISTINCREMENT 2 /* 线性表存储空间的分配增量*/typedef struct{Elem Type *elem; /* 存储空间基址*/int length; /* 当前长度*/int listsize; /* 当前分配的存储容量) */}SqList;(3)文件3：seqlistAlgo. h 进行线性表顺序存储结构的基本实验算法定义Status ListInit_Sq(SqList &L){ /* 操作结果：构造一个空的顺序线性表*/L. elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L. elem)exit(OVERFLOW); /* 存储分配失败*/L. length=0; /* 空表长度为0 */L. listsize=LIST_INIT_SIZE; /* 初始存储容量*/return OK;}Status ListInsert_Sq(SqList &L,int i,ElemType e){ /* 初始条件：顺序线性表L 已存在，1≤i≤ListLength(L)+1 *//* 操作结果：在L 中第i 个位置之前插入新的数据元素e，L 的长度加1 */ ElemType *newbase,*q,*p;if(i<1||i>L. length+1) /* i 值不合法*/return ERROR;if(L. length>=L. listsize) /* 当前存储空间已满,增加分配*/{newbase=(ElemType *)realloc(L. elem,(L.istsize+LISTINCREMENT)*sizeof(ElemType));if(!newbase)exit(OVERFLOW); /* 存储分配失败*/L. elem=newbase; /* 新基址*/L. listsize+=LISTINCREMENT; /* 增加存储容量*/}q=L.elem+i-1; ; /* q 为插入位置*/for(p=L. elem+L. length-1;p>=q;--p) /* 插入位置及之后的元素右移*/*(p+1)=*p;*q=e; ; /* 插入e */++L.length ; /* 表长增1 */return OK;}Status ListDelete_Sq(SqList &L,int i,ElemType *e){ /* 初始条件：顺序线性表L 已存在，1≤i≤ListLength(L) *//* 操作结果：删除L 的第i 个数据元素，并用e 返回其值，L 的长度减1 */ElemType *p,*q;if(i<1||i>L. length) /* i 值不合法*/return ERROR;p=L.elem+i-1 ; /* p 为被删除元素的位置*/*e=*p; /* 被删除元素的值赋给e */q=L. elem+L. length-1; /* 表尾元素的位置*/for(++p;p<=q;++p) /* 被删除元素之后的元素左移*/*(p-1)=*p; ;L.length--; ; /* 表长减1 */return OK;}Status ListPrint_Sq(SqList L){ /* 初始条件：顺序线性表L 已存在*//* 操作结果：依次对L 的数据元素输出*/int i;printf("\n");for(i=0;i<L. length;i++)printf("%d ", L. elem[i]);return OK;}/* 还有一些算法，同学们自己补充完整*/(4)文件4：seqlistUse. cpp 进行线性表顺序存储结构的基本算法验证。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验一线性表操作实验目的：(1)掌握在顺序、链式存储结构上实现线性表的各种基本运算。
(2)重点掌握单链表的基本操作及应用。
(3)学会综合运用C语言中函数、指针、结构体等知识进行编程。
本次实验中，下列实验项目选做一。
1、顺序表的综合操作[问题描述]设计算法，实现线性结构上的顺序表的建立以及元素的查找、插入、删除等操作。
[基本要求及提示]（1）从键盘输入10个整数，建立顺序表。
（2）从键盘输入1个整数，在顺序表中查找该结点的位置。
若找到，输出结点的位置；若找不到，则显示“找不到”。
（3）从键盘输入2个整数，一个表示欲插入的位置i，另一个表示欲插入的数值x，将x插入在对应位置上，输出顺序表所有结点值，观察输出结果。
（4）从键盘输入1个整数，表示欲删除结点的位置，输出顺序表所有结点值，观察输出结果。
（5）要求程序通过一个主菜单进行控制，在主菜单界面通过选择菜单项的序号来调用各功能函数。
2、线性表的逆置[问题描述]（1）以顺序存储结构实现线性表的就地逆置。
（2）以链式存储结构实现线性表的就地逆置。
注：线性表的就地逆置就是在原表的存储空间内将线性表（a1,a2,a3,…,an）逆置为（an，an-1，…，a2，a1）。
[基本要求及提示]（1）从键盘输入10个整数，建立顺序表。
（2）实现顺序表逆置，并将结果输出。
（3）从键盘输入10个整数，建立链表。
（4）实现链表逆置，并将结果输出。
（5）要求程序通过一个主菜单进行控制，在主菜单界面通过选择菜单项的序号来调用各功能函数。
也可以将顺序表和链表上的操作分开，做成两个程序。
3、线性表的元素分类[问题描述]已知线性表中元素均为正整数，设计算法将其调整为前后两部分，前边均为奇数，后边均为偶数。
即实现线性表的元素的分类。
[基本要求及提示]（6）从键盘输入10个整数，建立顺序表。
（7）实现顺序表上的元素分类，并输出结果。
（8）从键盘输入10个整数，建立链表。
（9）实现链表的元素分类，并输出结果。
（10）要求程序通过一个主菜单进行控制。
也可以将顺序表和链表上的操作分开，做成两个程序。
（11）要求程序的时间复杂度为O(n)，空间复杂度为O(1)。
4、线性表的有序合并[问题描述]已知有两个非递减的线性表，设计算法将其有序合并为一个线性表，元素值是非递增排序。
[基本要求及提示]（1）从键盘输入两个非递减的整数序列，建立两个非递减的顺序表L1,L2。
（2）将顺序表L1,L2有序合并，结果非递增，输出合并后的结果。
（3）从键盘输入两个非递减的整数序列，建立两个非递减的链表L3,L4。
（4）将链表L3,L4有序合并，结果非递增，输出合并后的结果（采用头插法）。
（5）要求程序通过一个主菜单进行控制。
也可以将顺序表和链表上的操作分开，做成两个程序。
（6）要求程序的时间复杂度为O(n)，空间复杂度为O(1)。
5、链表的综合操作[问题描述]设计算法，实现线性结构上的链表的建立、元素的查找、插入、删除等操作。
[基本要求及提示]（1）从键盘输入10个字符以$结束，建立链表。
（2）从键盘输入1个序号，在链表中查找该结点的位置。
若找到，输出结点的位置；若找不到，则显示“找不到”。
（3）从键盘输入1个整数，表示欲插入的位置i，再输入一个字符x，将x插入在i 位置上，输出链表所有结点值，观察输出结果。
（4）从键盘输入一个整数，表示欲删除结点的位置，删除该结点，然后输出链表所有结点值，观察输出结果。
（5）要求程序通过一个主菜单进行控制，在主菜单界面通过选择菜单项的序号来调用各功能函数。
6、在顺序表上删除自第i个开始的k个元素[问题描述]建立一个非空的值域为整数的顺序表，从键盘输入i和k的值，编程实现删除自第i 个元素开始的k个元素。
[基本要求]（1）建立长度至少为10的顺序表；（2）从键盘输入两个整数i和k，进行删除运算，删除成功显示“OK”，不成功显示“ERROR”。
注意讨论i和k的合法性。
（3）显示顺序表的内容；（4）要求程序通过一个主菜单进行控制，在主菜单界面通过选择菜单项的序号来调用各功能函数。
7、在顺序表上删除所有值为item的数据元素[问题描述]建立一个非空的值域为整数的顺序表，从键盘输入一个整数item，编程实现删除表中所有值为item的数据元素。
[基本要求]（1）建立长度至少为10的顺序表；（2）从键盘输入一个整数item，删除表中所有与item相同的元素，删除成功显示“OK”，不成功显示“ERROR”。
（3）显示顺序表的内容；（4）要求程序通过一个主菜单进行控制，在主菜单界面通过选择菜单项的序号来调用各功能函数。
8、在顺序表上删除所有值相等的多余元素[问题描述]建立一个非空的值域为整数的顺序表，编程实现删除表中值相等的多余元素。
[基本要求]（1）建立长度至少为10的顺序表；（2）删除表中值相等的多余元素。
（3）显示顺序表的内容；9、在单链表上，删除所有值在[mink,maxk]内元素[问题描述]建立一个非空的值域为整数的表头结点的单链表，从键盘输入两个整数mink，naxk；编程实现删除表中值域大于等于mink，同时小于等于maxk的数据元素。
[基本要求]（1）建立长度至少为10的单链表；（2）删除单链表中表中，值域大于等于mink，同时小于等于maxk的结点。
（3）显示单链表的内容；（4）要求程序通过一个主菜单进行控制，在主菜单界面通过选择菜单项的序号来调用各功能函数。
10、查找单链表倒数第k个结点[问题描述]设有一个值域为整数有头结点的非空单链表，从键盘输入正整数k；在不改变链表的前提下，请设计一个尽可能高效的算法，查找链表中倒数第k个位置的结点，若查找成功，输出该节点的数据域的值，并返回1，否则显示“ERROR”，并返回0。
[基本要求及提示]（1）编写非空的值域为整数的单链表的建立函数；（2）设工作指针p和q，当p从首节点开始沿链向前走到第k个节点（参考教材P50-2.8算法）；此时使q指向首节点q=L->next；如此q与p是相距k个节点两个指针；再一同向前走，当p走到表尾时，q即指向倒数第k个结点。
11、在无头结点的循环链表上，删除s结点之前驱结点[问题描述]假设有一个循环链表的长度大于1，数据域为整数，且表中既无头结点也无头指针。
已知s为指向链表的某一结点的指针，试编写程序在循环链表中删除s的前驱结点。
[基本要求及提示]（1）编写建立无头结点循环链表函数，也无头指针，返回该循环链表的某结点的指针（可以是尾指针）；（2）编写删除s结点的前驱结点函数，while(p->next->next!=s)p=p->next;（3）编写输出链表函数；（4）要求程序通过一个主菜单（1.建立；2.删除；3.输出；4.退出）调用各功能函数。
12、单链表上元素的分类[问题描述]已知单链表表示的线性表中含有三类字符（如字母字符、数字字符和其他字符），试编写程序来构造三个以循环链表表示的线性表，使每个表中只含有某一类的字符，且利用原表中的节点空间，作为这三个表的结点空间，头结点可以另辟空间。
[基本要求及提示]（1）编写建立无头结点尾指针标识的循环链表函数；（2）从键盘输入一个整数key，编写删除链表中值域等于key的结点的前驱结点函数。
（3）编写显示单链表的内容函数；（4）要求程序通过一个主菜单进行控制，在主菜单界面通过选择菜单项的序号来调用各功能函数。
13、双向链表的综合操作[问题描述]设计算法，实现双向链表的建立、元素的查找、插入、删除等操作。
[基本要求及提示]（1）从键盘输入10个整数以-999结束，建立数据域为整数的双向链表。
（2）从键盘输入1个序号，在双向链表中查找该结点的位置。
若找到，输出结点的位置；若找不到，则显示“找不到”。
（3）从键盘输入两个整数，一个表示欲插入的位置i，另一个表示欲插入的数值x，将x插入在i位置上，输出链表所有结点值，观察输出结果。
（4）从键盘输入一个整数，表示欲删除结点的位置，删除该结点，然后输出链表所有结点值，观察输出结果。
（5）要求程序通过一个主菜单进行控制，在主菜单界面通过选择菜单项的序号来调用各功能函数。
14、单链表按给定规则合并[问题描述]设线性表A=（a1,a2,…，am）,B=（b1,b2,…，bn）,试编写一个按下列规则合并A，B 为线性表C的算法，使得C=（a1,b1,a2,b2,…，am,bm,bm+1,…，bn）或C=（a1,b1,a2,b2,…，an,bn,an+1,…，am）线性表C均以单链表为存储结构，C表利用A，B表的节点空间构成。
链表的长度均为显示存储。
[基本要求及提示]（1）首先编写单链表的初始化函数、单链表创建函数及输出函数。
（2）再编写合并函数。
（3）在主函数中调用其它函数进行调试运行。
15、多项式的奇偶项的分解[问题描述]将一个用循环链表表示的稀疏多项式分解成两个多项式，使这两个多项式各自仅含有奇数项或偶数项，并要求用原链表中的结点空间来构成这两个循环链表。
[基本要求及提示]（1）首先编写循环链表的初始化函数、循环单链表创建函数（P63-2.21）及输出函数。
（2）再编写分解函数。
（3）在主函数中调用其它函数进行调试运行。
16、给定x值，求多项式P(x)的值[问题描述]多项式P(x)采用单链表存储，参见教材的类型定义，写一个算法，对给定x值，求多项式P(x)的值。
[基本要求及提示]（1）首先编写单链表的初始化函数、单链表创建函数及输出函数。
（2）再编写求值函数，提示求出每一个结点的值，进行累加。
提示：结点p的值：p->coef*pow(x,p->exp)。
（3）在主函数中调用其它函数进行调试运行。
17、单链表转换[问题描述]已知有单链表（a1,a2,…，an），n为偶数，要求写出一个时间复杂度为O（n），辅助空间为O（1）的算法，将上述单链表转换成（an,an-2,…，a2,a1,a3,…，an-1）。
参见教材P75图2.24.[基本要求及提示]（1）首先编写单链表的初始化函数、单链表创建函数及输出函数。
（2）再编写转换函数。
提示：指针p扫描单链表，依次将第2，4，6…，n结点删除，同时头插到本链表上。
p=L->next;while(p->next!=NULL){s=p->next;p->next=s->next; s->next=L->next;L->next=s; p=p->next;}（3）在主函数中调用其它函数进行调试运行。