实验一 线性表基本操作的编程实现

实验一线性表的基本操作实现及其应用一、实验目的1、熟练掌握线性表的基本操作在两种存储结构上的实现。

2、会用线性链表解决简单的实际问题。

二、实验内容题目一、该程序的功能是实现单链表的定义和操作。

该程序包括单链表结构类型以及对单链表操作的具体的函数定义和主函数。

其中，程序中的单链表（带头结点）结点为结构类型，结点值为整型。

单链表操作的选择以菜单形式出现，如下所示：please input the operation：1.初始化2.清空3.求链表长度4.检查链表是否为空5.检查链表是否为满6.遍历链表（设为输出元素）7.从链表中查找元素8.从链表中查找与给定元素值相同的元素在表中的位置9.向链表中插入元素 10. 从链表中删除元素其他键退出。

其中黑体部分必做题目二、约瑟夫环问题：设编号为1，2，3，……，n的n(n>0)个人按顺时针方向围坐一圈，每个人持有一个正整数密码。

开始时任选一个正整数做为报数上限m，从第一个人开始顺时针方向自1起顺序报数，报到m时停止报数，报m的人出列，将他的密码作为新的m值，从他的下一个人开始重新从1报数。

如此下去，直到所有人全部出列为止。

令n最大值取30。

要求设计一个程序模拟此过程，求出出列编号序列。

struct node(一)1．进入选择界面后，先选择7，进行插入：2.选择4，进行遍历，结果为：3.选择2，得出当前链表长度.4.选择3，得出当前链表为.5.选择分别选择5、6进行测试.6.选择8，分别按位置和元素值删除.7.选择9，或非1-8的字符，程序结束.(二) 实验总结通过这次实验，我对线性链表有了更深的理解，深入明白了线性存储结构与链式存储结构在内存存储的不同特点，同时我还学会了用这些知识实际解决一些问题，能够更加熟练地将算法转化为实际程序。

同时，在写程序和调试程序的过程中，学会了一些书写技巧和调试技巧，这对于自己能在短时间高效的写出正确地程序有很大作用。

四、主要算法流程图及程序清单 1. 主要算法流程图：(1) 从单链表表中查找与给定元素值相同的元素在链表中的位置p=p->nextp&&!(p->data==xtrue调用函数，传入参数L ，xp=L->next2.程序清单：#include<iostream> using namespace std; #include<>#include<>/* 预处理命令 */#define OK 1;#define ERROR 0;#define OVERFLOW -1;/* 单链表的结点类型 */typedef struct LNode{int data;struct LNode *next;}LNode,*LinkedList;/*初始化单链表*/LinkedList LinkedListInit(){空"<<endl;cout<<"\t\t\t"<<"2.求链表长度"<<endl;cout<<"\t\t\t"<<"3.检查链表是否为空"<<endl;cout<<"\t\t\t"<<"4.遍历链表"<<endl;cout<<"\t\t\t"<<"5.从链表中查找元素 "<<endl;cout<<"\t\t\t"<<"6.从链表中查找与给定元素值相同的元素在表中的位置"<<endl;cout<<"\t\t\t"<<"7.向链表中插入元素"<<endl;cout<<"\t\t\t"<<"8.从链表中删除元素"<<endl;cout<<"\t\t\t"<<"9.退出"<<endl;}/*主函数*/int main(){链表长度case 2:{cout<<"\t\t\t链表长度为："<<LinkedListLength(L)<<endl;getch();}break;查链表是否为空case 3:{if (!LinkedListEmpty(L)){cout<<"\t\t\t链表不为空！"<<endl;}else{cout<<"\t\t\t链表为空！"<<endl;}getch();}break;历链表case 4:{LinkedListTraverse(L);getch();}break;链表中查找元素case 5:{cout<<"\t\t\t请输入要查询的位置i：";int j;cin>>j;if (LinkedListGet(L,j)){cout<<"\t\t\t位置i的元素值为："<<LinkedListGet(L,j)->data<<endl;}else{cout<<"\t\t\ti大于链表长度！"<<endl;}getch();}break;链表中查找与给定元素值相同的元素在表中的位置case 6:{cout<<"\t\t\t请输入要查找的元素值：";int b;cin>>b;if (LinkedListGet1(L,b)){cout<<"\t\t\t要查找的元素值位置为："<<LinkedListGet1(L,b)<<endl;cout<<"\t\t\t要查找的元素值内存地址为："<<LinkedListLocate(L,b)<<endl;}else{cout<<"\t\t\t该值不存在！"<<endl;}getch();}break;链表中插入元素case 7:{cout<<"\t\t\t请输入要插入的值：";int x; cin>>x;cout<<"\t\t\t请输入要插入的位置：";int k; cin>>k;if(LinkedListInsert(L,k,x)){cout<<"\t\t\t插入成功！"<<endl;}else{cout<<"\t\t\t插入失败！"<<endl;}getch();}break;链表中删除元素case 8:{cout<<"\t\t\t1.按位置删除"<<endl;cout<<"\t\t\t2.按元素删除"<<endl;int d;cout<<"\t\t请选择：";cin>>d;switch(d){case 1:{cout<<"\t\t\t请输入删除位置：";cin>>d;int y;if (LinkedListDel(L,d,y)){cout<<"\t\t\t"<<y<<"被删除！"<<endl;}else{cout<<"\t\t\t删除失败！"<<endl;}}break;case 2:{cout<<"\t\t\t请输入删除元素：";int y;cin>>y;if (LinkedListDel(L,y)){cout<<"\t\t\t"<<y<<"被删除！"<<endl;}else{cout<<"\t\t\t删除失败！"<<endl;}}}getch();}break;}}return 1;}题二约瑟夫环问题算法、思想为了解决这一问题，可以先定义一个长度为30（人数）的数组作为线性存储结构，并把该数组看成是一个首尾相接的环形结构，那么每次报m的人，就要在该数组的相应位置做一个删除标记，该单元以后就不再作为计数单元。

实验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：线性表（顺序表的实现）一、实验项目名称顺序表基本操作的实现二、实验目的掌握线性表的基本操作在顺序存储结构上的实现。

三、实验基本原理顺序表是由地址连续的的向量实现的，便于实现随机访问。

顺序表进行插入和删除运算时，平均需要移动表中大约一半的数据元素，容量难以扩充四、主要仪器设备及耗材Window 11、Dev-C++5.11五、实验步骤1.导入库和一些预定义:2.定义顺序表:3.初始化:4.插入元素:5.查询元素：6.删除元素:7.销毁顺序表:8.清空顺序表:9.顺序表长度:10.判空:11.定位满足大小关系的元素(默认小于):12.查询前驱:13.查询后继:14.输出顺序表15.归并顺序表16.写测试程序以及主函数对顺序表的每一个操作写一个测试函数，然后在主函数用while+switch-case的方式实现一个带菜单的简易测试程序，代码见“实验完整代码”。

实验完整代码:#include <bits/stdc++.h>using namespace std;#define error 0#define overflow -2#define initSize 100#define addSize 10#define compareTo <=typedef int ElemType;struct List{ElemType *elem;int len;int listsize;}L;void init(List &L){L.elem = (ElemType *) malloc(initSize * sizeof(ElemType)); if(!L.elem){cout << "分配内存失败！";exit(overflow);}L.len = 0;L.listsize = initSize;}void destroy(List &L){free(L.elem);L.len = L.listsize = 0;}void clear(List &L){L.len = 0;}bool empty(List L){if(L.len == 0) return true;else return false;}int length(List L){return L.len;}ElemType getElem(List L,int i){if(i < 1 || i > L.len + 1){cout << "下标越界！";exit(error);}return L.elem[i - 1];}bool compare(ElemType a,ElemType b) {return a compareTo b;}int locateElem(List L,ElemType e) {for(int i = 0;i < L.len;i++){if(compare(L.elem[i],e))return i;}return -1;}int check1(List L,ElemType e){int idx = -1;for(int i = 0;i < L.len;i++)if(L.elem[i] == e)idx = i;return idx;}bool check2(List L,ElemType e){int idx = -1;for(int i = L.len - 1;i >= 0;i--)if(L.elem[i] == e)idx = i;return idx;}int priorElem(List L,ElemType cur_e,ElemType pre_e[]) {int idx = check1(L,cur_e);if(idx == 0 || idx == -1){string str = "";str = idx == 0 ? "无前驱结点" : "不存在该元素";cout << str;exit(error);}int cnt = 0;for(int i = 1;i < L.len;i++){if(L.elem[i] == cur_e){pre_e[cnt ++] = L.elem[i - 1];}}return cnt;}int nextElem(List L,ElemType cur_e,ElemType next_e[]){int idx = check2(L,cur_e);if(idx == L.len - 1 || idx == - 1){string str = "";str = idx == -1 ? "不存在该元素" : "无后驱结点";cout << str;exit(error);}int cnt = 0;for(int i = 0;i < L.len - 1;i++){if(L.elem[i] == cur_e){next_e[cnt ++] = L.elem[i + 1];}}return cnt;}void insert(List &L,int i,ElemType e){if(i < 1 || i > L.len + 1){cout << "下标越界！";exit(error);}if(L.len >= L.listsize){ElemType *newbase = (ElemType *)realloc(L.elem,(L.listsize + addSize) * sizeof(ElemType));if(!newbase){cout << "内存分配失败！";exit(overflow);}L.elem = newbase;L.listsize += addSize;for(int j = L.len;j > i - 1;j--)L.elem[j] = L.elem[j - 1];L.elem[i - 1] = e;L.len ++;}void deleteList(List &L,int i,ElemType &e){if(i < 1 || i > L.len + 1){cout << "下标越界！";exit(error);}e = L.elem[i - 1];for(int j = i - 1;j < L.len;j++)L.elem[j] = L.elem[j + 1];L.len --;}void merge(List L,List L2,List &L3){L3.elem = (ElemType *)malloc((L.len + L2.len) * sizeof(ElemType)); L3.len = L.len + L2.len;L3.listsize = initSize;if(!L3.elem){cout << "内存分配异常";exit(overflow);}int i = 0,j = 0,k = 0;while(i < L.len && j < L2.len){if(L.elem[i] <= L2.elem[j])L3.elem[k ++] = L.elem[i ++];else L3.elem[k ++] = L2.elem[j ++];}while(i < L.len)L3.elem[k ++] = L.elem[i ++];while(j < L2.len)L3.elem[k ++] = L2.elem[j ++];}bool visit(List L){if(L.len == 0) return false;for(int i = 0;i < L.len;i++)cout << L.elem[i] << " ";cout << endl;return true;}void listTraverse(List L){if(!visit(L)) return;}void partion(List *L){int a[100000],b[100000],len3 = 0,len2 = 0; memset(a,0,sizeof a);memset(b,0,sizeof b);for(int i = 0;i < L->len;i++){if(L->elem[i] % 2 == 0)b[len2 ++] = L->elem[i];elsea[len3 ++] = L->elem[i];}for(int i = 0;i < len3;i++)L->elem[i] = a[i];for(int i = 0,j = len3;i < len2;i++,j++) L->elem[j] = b[i];cout << "输出顺序表:" << endl;for(int i = 0;i < L->len;i++)cout << L->elem[i] << " ";cout << endl;}//以下是测试函数------------------------------------void test1(List &list){init(list);cout << "初始化完成!" << endl;}void test2(List &list){if(list.listsize == 0)cout << "线性表不存在!" << endl;else{int len;ElemType num;cout << "选择插入的元素数量：" << endl;cin >> len;cout << "依次输入要插入的元素：" << endl;for(int i = 1;i <= len;i++){cin >> num;insert(list,i,num);}cout << "操作成功！" << endl;}}void test3(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{cout << "请输入要返回的元素的下标" << endl;int idx;cin >> idx;cout << "线性表中第" << idx << "个元素是：" << getElem(L,idx) << endl;}}void test4(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{int idx;ElemType num;cout << "请输入要删除的元素在线性表的位置" << endl;cin >> idx;deleteList(L,idx,num);cout << "操作成功！" << endl << "被删除的元素是：" << num << endl; }}void test5(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{destroy(L);cout << "线性表已被销毁" << endl;}}void test6(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{clear(L);cout << "线性表已被清空" << endl;}}void test7(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else cout << "线性表的长度现在是：" << length(L) << endl;}void test8(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else if(empty(L))cout << "线性表现在为空" << endl;else cout << "线性表现在非空" << endl;}void test9(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{ElemType num;cout << "请输入待判定的元素:" << endl;cin >> num;cout << "第一个与目标元素满足大小关系的元素的位置：" << locateElem(L,num) << endl;}}void test10(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{ElemType num,num2[initSize / 2];cout << "请输入参照元素:" << endl;cin >> num;int len = priorElem(L,num,num2);cout << num << "的前驱为：" << endl;for(int i = 0;i < len;i++)cout << num2[i] << " ";cout << endl;}}void test11(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{ElemType num,num2[initSize / 2];cout << "请输入参照元素:" << endl;cin >> num;int len = nextElem(L,num,num2);cout << num << "的后继为：" << endl;for(int i = 0;i < len;i++)cout << num2[i] << " ";cout << endl;}}void test12(List list){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{cout << "输出线性表所有元素:" << endl;listTraverse(list);}}void test13(){if(L.listsize == 0)cout << "初始线性表不存在!" << endl; else{List L2,L3;cout << "初始化一个新线性表" << endl;test1(L2);test2(L2);cout << "归并两个线性表" << endl;merge(L,L2,L3);cout << "归并成功!" << endl;cout << "输出合并后的线性表" << endl;listTraverse(L3);}}void test14(){partion(&L);cout << "奇偶数分区成功!" << endl;}int main(){std::ios::sync_with_stdio(false);cin.tie(0),cout.tie(0);int op = 0;while(op != 15){cout << "-----------------menu--------------------" << endl;cout << "--------------1：初始化------------------" << endl;cout << "--------------2：插入元素----------------" << endl;cout << "--------------3：查询元素----------------" << endl;cout << "--------------4：删除元素----------------" << endl;cout << "--------------5：销毁线性表--------------" << endl;cout << "--------------6：清空线性表--------------" << endl;cout << "--------------7：线性表长度--------------" << endl;cout << "--------------8：线性表是否为空----------" << endl;cout << "--------------9：定位满足大小关系的元素--" << endl;cout << "--------------10：查询前驱---------------" << endl;cout << "--------------11：查询后继---------------" << endl;cout << "--------------12：输出线性表-------------" << endl;cout << "--------------13：归并线性表-------------" << endl;cout << "--------------14：奇偶分区---------------" << endl;cout << "--------------15: 退出测试程序-----------" << endl;cout << "请输入指令编号:" << endl; if(!(cin >> op)){cin.clear();cin.ignore(INT_MAX,'\n');cout << "请输入整数!" << endl;continue;}switch(op){case 1:test1(L);break;case 2:test2(L);break;case 3:test3();break;case 4:test4();break;case 5:test5();break;case 6:test6();break;case 7:test7();break;case 8:test8();break;case 9:test9();break;case 10:test10();break;case 11:test11();break;case 12:test12(L);break;case 13:test13();break;case 14:test14();break;case 15:cout << "测试结束！" << endl;default:cout << "请输入正确的指令编号！" << endl;}}return 0;}六、实验数据及处理结果1.初始化:2.插入元素3.查询元素（返回的是数组下标，下标从0开始）4.删除元素（位置从1开始）5.销毁顺序表6.清空顺序表7.顺序表长度（销毁或清空操作前）8.判空（销毁或清空操作前）9.定位满足大小关系的元素（销毁或清空操作前）说明：这里默认找第一个小于目标元素的位置且下标从0开始，当前顺序表的数据为:1 4 2 510.前驱（销毁或清空操作前）11.后继（销毁或清空操作前）12.输出顺序表（销毁或清空操作前）13.归并顺序表（销毁或清空操作前）七、思考讨论题或体会或对改进实验的建议通过本次实验，我掌握了定义线性表的顺序存储类型，加深了对顺序存储结构的理解，进一步巩固和理解了顺序表的基本操作，如建立、查找、插入和删除等。

HUBEI UNIVERSITY OF AUTOMOTIVE TECHNOLOGY
数据结构
实验报告
实验项目实验一实验类别基础篇
学生姓名宋大超学生学号201501149 完成日期2016-10-9
指导教师袁科
实验成绩评阅日期
评阅教师
实验一线性表基本操作的编程实现
【实验目的】
线性表基本操作的编程实现
要求：
线性表基本操作的编程实现（2学时，验证型），掌握线性表的建立、遍历、插入、删除等基本操作的编程实现，也可以进一步编程实现查找、逆序、排序等操作，存储结构可以在顺序结构或链表结构中任选，可以完成部分主要功能，也可以用菜单进行管理完成大部分功能。

还鼓励学生利用基本操作进行一些更实际的应用型程序设计。

【实验性质】
验证性实验（学时数：2H）
【实验内容】
把线性表的顺序存储和链表存储的数据插入、删除运算其中某项进行程序实现。

建议实现键盘输入数据以实现程序的通用性。

为了体现功能的正常性，至少要编制遍历数据的函数。

【注意事项】
1.开发语言：使用C。

2.可以自己增加其他功能。

实验⼀线性表的基本操作⼀、线性结构的顺序表基本操作实验⽬的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．掌握数据结构中的一些基本概念。

数据、数据项、数据元素、数据类型和数据结构，以及它们之间的关系。

2．了解数据的逻辑结构和数据的存储结构之间的区别与联系；数据的运算与数据的逻辑结构的关系。

3．掌握顺序表和链表的基本操作：插入、删除、查找以及表的合并等运算。

4．掌握运用C语言上机调试线性表的基本方法。

二、实验条件1．硬件：一台微机2．软件：操作系统和C语言系统三、实验方法确定存储结构后，上机调试实现线性表的基本运算。

四、实验内容1．建立顺序表，基本操作包括：初始化，建立一个顺序存储的链表，输出顺序表，判断是否为空，取表中第i个元素，定位函数（返回第一个与x相等的元素位置），插入，删除。

2．建立单链表，基本操作包括：初始化，建立一个链式存储的链表，输出顺序表，判断是否为空，取表中第i个元素，定位函数（返回第一个与x相等的元素位置），插入，删除。

3．假设有两个按数据元素值非递减有序排列的线性表A和B，均以顺序表作为存储结构。

编写算法将A表和B表归并成一个按元素值非递增有序（允许值相同）排列的线性表C。

（可以利用将B中元素插入A中，或新建C表）4．假设有两个按数据元素值非递减有序排列的线性表A和B，均以单链表作为存储结构。

编写算法将A表和B表归并成一个按元素值递减有序（即非递增有序，允许值相同）排列的线性表C。

五、附源程序及算法程序流程图1.源程序（1）源程序(实验要求1和3)#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef struct arr{int * elem;int length;int listsize;}Sqlist;void menu(); //菜单void InitList(Sqlist *p); // 创建线性表void ShowList(Sqlist *p); // 输出顺序线性表void ListDelete(Sqlist *p,int i,int &e); // 在顺序线性表中删除第i个元素，并用e返回其值void ListInsert(Sqlist *p); // 在顺序线性表中第i个元素前插入新元素evoid ListEmpty(Sqlist *p); // 判断L是否为空表void GetList(Sqlist *p,int i,int &e); // 用e返回L中第i个数据元素的值void ListInsert(Sqlist *p,int i,int e);bool compare(int a,int b);void LocateElem(Sqlist *L,int e); // 在顺序线性表L中查找第1个值与e满足compare()d元素的位序void MergeList_L(Sqlist *La,Sqlist *Lb); // 归并void main(){Sqlist La;Sqlist Lb;int n,m,x;menu();scanf("%d",&n);while(n){switch(n){case 0: ; break;case 1:InitList(&La);break;case 2:ListEmpty(&La);break;case 3:printf("请输入插入的位序:\n");scanf("%d",&m);printf("请出入要插入的数:\n");scanf("%d",&x);ListInsert(&La,m,x);break;case 4:printf("请输入删除元素的位序:\n");scanf("%d",&m);ListDelete(&La,m,x);printf("删除的元素为:%d\n",x);break;case 5:printf("请输入要找的与线性表中相等的数:\n");scanf("%d",&m);LocateElem(&La,m);break;case 6:printf("请输入查找的位序:\n");scanf("%d",&m);GetList(&La,m,x);printf("La中第%d个元素的值为%d\n",m,x);break;case 7:ShowList(&La);break;case 8:InitList(&Lb);break;case 9:MergeList_L(&La,&Lb);printf("归并成功!");break;}menu();scanf("%d",&n);}}/*菜单*/void menu(){printf("********************\n\n");printf(" 0.退出\n\n");printf(" 1.创建线性表La\n\n");printf(" 2.判断La是否为空表\n\n");printf(" 3.插入元素(La)\n\n");printf(" 4.删除元素(La)\n\n");printf(" 5.定位元素(La)\n\n");printf(" 6.取元素(La)\n\n");printf(" 7.输出线性表\n\n");printf(" 8.创建线性表Lb\n\n");printf(" 9.归并为一个线性表La\n\n");printf("********************\n\n");}/*创建顺序线性表L*/void InitList(Sqlist *L){int n;int i=0;L->elem=(int *)malloc(LIST_INIT_SIZE*sizeof(int));if(NULL==L->elem)printf("储存分配失败!\n");else{L->length=0;L->listsize=LIST_INIT_SIZE;printf("输入顺序表a:\n");scanf("%d",&n);while(n){L->elem[i]=n;i++;L->length++;L->listsize=L->listsize-4;scanf("%d",&n);}}}/*输出顺序线性表*/void ShowList(Sqlist *p){int i;if(0==p->length)printf("数组为空!\n");elsefor(i=0;i<p->length;i++)printf("%d ",p->elem[i]);printf("\n");}/*判断L是否为空表*/void ListEmpty(Sqlist *p)if(0==p->length)printf("L是空表!\n");elseprintf("L不是空表!\n");}/*在顺序线性表中第i个元素前插入新元素e */void ListInsert(Sqlist *p,int i,int e){int *newbase;int *q1;int *q2;while(i<1||i>p->length+1){printf("您输入的i超出范围!\n请重新输入要插入的位置\n:");scanf("%d",&i);}if(p->length>=p->listsize){newbase=(int *)realloc(p->elem,(p->listsize+LISTINCREMENT)*sizeof(int));if(!newbase)exit(0);else{p->elem=newbase;p->listsize+=LISTINCREMENT;}}q1=&(p->elem[i-1]);for(q2=&(p->elem[p->length-1]);q2>=q1;--q2)*(q2+1)=*q2;*q1=e;++p->length;}/*/在顺序线性表中删除第i个元素，并用e返回其值*/void ListDelete(Sqlist *p,int i,int &e){int *q1,*q2;while(i<1||i>p->length){printf("您输入的i超出范围!请重新输入:");scanf("%d",&i);}q1=&(p->elem[i-1]);e=*q1;q2=p->elem+p->length-1;for(++q1;q1<=q2;++q1)*(q1-1)=*q1;--p->length;}/*对比a与b相等*/bool compare(int a,int b){if(a==b)return 1;elsereturn 0;}/*在顺序线性表L中查找第1个值与e满足compare()d元素的位序*/ void LocateElem(Sqlist *L,int e){int i=1;int *p;p=L->elem;while(i<=L->length && !compare(*p++,e))++i;if(i<=L->length)printf("第1个与e相等的元素的位序为%d\n",i);elseprintf("没有该元素!\n");}/*用e返回L中第i个数据元素的值*/void GetList(Sqlist *p,int i,int &e){Sqlist *p1;p1=p;e=p1->elem[i-1];}/* 已知顺序线性表La和Lb是元素按值非递减排列*//* 把La和Lb归并到La上,La的元素也是按值非递减*/void MergeList_L(Sqlist *La,Sqlist *Lb){int i=0,j=0,k,t;int *newbase;Sqlist *pa,*pb;pa=La;pb=Lb;while(i<pa->length && j<pb->length){if(pa->elem[i] >= pb->elem[j]){if(pa->listsize==0){newbase=(int*)realloc(pa->elem,(pa->listsize+LISTINCREMENT)*sizeof(int));if(!newbase)exit(0);}for(k=pa->length-1; k>=i; k--)pa->elem[k+1]=pa->elem[k];pa->length++;pa->elem[i]=pb->elem[j];i++;j++;}elsei++;}while(j<pb->length){if( pa->listsize < pb->length-j ){newbase=(int*)realloc(pa->elem,(pa->listsize+LISTINCREMENT)*sizeof(int));if(!newbase)exit(0);}for(j;j<pb->length;j++,i++){pa->elem[i]=pb->elem[j];pa->length++;}}for(i=0;i<pa->length/2;i++){t=pa->elem[i];pa->elem[i]=pa->elem[pa->length-i-1];pa->elem[pa->length-i-1]=t;}}（2）源程序(实验要求2和4)#include<stdio.h>#include<malloc.h>#include<stdlib.h>typedef struct LNode{int data;struct LNode *next;}LNode, *LinkList;void menu();LinkList InitList();void ShowList(LinkList L);void ListDelete(LinkList L,int i,int &e);void ListEmpty(LinkList L);void GetList(LinkList L,int i,int &e);void ListInsert(LinkList L,int i,int e);bool compare(int a,int b);void LocateElem(LinkList L,int e);LinkList MergeList_L(LinkList La,LinkList Lb);int total=0;void main(){LinkList La;LinkList Lb;La=(LinkList)malloc(sizeof(struct LNode));La->next=NULL;Lb=(LinkList)malloc(sizeof(struct LNode));Lb->next=NULL;int n;int m;int x;menu();scanf("%d",&n);while(n){switch(n){case 0: ; break;case 1:La->next=InitList();break;case 2:ListEmpty(La);break;case 3:printf("请输入要插入到第几个节点前:\n");scanf("%d",&m);printf("请输入插入的数据:\n");scanf("%d",&x);ListInsert(La,m,x);break;case 4:printf("请输入删除元素的位序:\n");scanf("%d",&m);ListDelete(La,m,x);printf("删除的元素为:%d\n",x);break;case 5:printf("请输入要找的与线性表中相等的数:\n");scanf("%d",&m);LocateElem(La,m);break;case 6:printf("请输入查找的位序:\n");scanf("%d",&m);GetList(La,m,x);printf("La中第%d个元素的值为%d\n",m,x);break;case 7:ShowList(La);break;case 8:Lb->next=InitList();break;case 9:La=MergeList_L(La,Lb);printf("归并成功\n");break;}menu();scanf("%d",&n);}}void menu(){printf("********************\n\n");printf(" 0.退出\n\n");printf(" 1.创建线性表La\n\n");printf(" 2.判断是否为空表\n\n");printf(" 3.插入元素\n\n");printf(" 4.删除元素\n\n");printf(" 5.定位元素\n\n");printf(" 6.取元素\n\n");printf(" 7.输出线性表\n\n");printf(" 8.创建线性表Lb\n\n");printf(" 9.归并两线性表\n\n");printf("********************\n\n");}// 创建链式线性表LLinkList InitList(){int count=0;LinkList pHead=NULL;LinkList pEnd,pNew;pEnd=pNew=(LinkList)malloc(sizeof(struct LNode));printf("请输入数据:\n");scanf("%d",&pNew->data);while(pNew->data){count++;if(count==1){pNew->next=pHead;pEnd=pNew;pHead=pNew;}else{pNew->next=NULL;pEnd->next=pNew;pEnd=pNew;}pNew=(LinkList)malloc(sizeof(struct LNode));printf("请输入数据:\n");scanf("%d",&pNew->data);}free(pNew);total=total+count;return pHead;}// 判断L是否为空表void ListEmpty(LinkList L){if(NULL==L->next)printf("此表为空表!\n");elseprintf("此表不为空表!\n");}// 在链式线性表中第i个元素前插入新元素e void ListInsert(LinkList L,int i,int e){LinkList p;LinkList s;p=L;int j=0;while(p&&j<i-1){p=p->next;++j;}if(!p||j>i-1)printf("不存在您要找的节点!\n");else{s=(LinkList)malloc(sizeof(int));s->data=e;s->next=p->next;p->next=s;printf("插入节点成功!\n");}}// 输出链式线性表void ShowList(LinkList L){LinkList p;p=L->next;if(p==NULL)printf("此表为空表!\n");elsewhile(p){printf("%d ",p->data);p=p->next;}printf("\n");}// 在链式线性表中删除第i个元素，并用e返回其值void ListDelete(LinkList L,int i,int &e){LinkList p;LinkList q;p=L;int j=0;while(p->next && j<i-1){p=p->next;++j;}if(!(p->next)||j>i-1)printf("没有找到要删除的位置!");else{q=p->next;p->next=q->next;e=q->data;free(q);}}// 用e返回L中第i个数据元素的值void GetList(LinkList L,int i,int &e){LinkList p;p=L->next;int j=0;while(p->next && j<i-1){p=p->next;++j;}if(!(p)||j>i-1)printf("没有找到要查找的位置!");elsee=p->data;}// 对比a与b相等bool compare(int a,int b){if(a==b)return 1;elsereturn 0;}// 在链式线性表L中查找第1个值与e满足compare()d元素的位序void LocateElem(LinkList L,int e){int i=0;LinkList p;p=L;while(p->next && !compare(p->data,e)){p=p->next;i++;}if(NULL==p->next){if(0==compare(p->data,e))printf("没有该元素!\n");elseprintf("第1个与e相等的元素的位序为%d\n",i);}elseif(compare(p->data,e))printf("没有该元素!\n");}LinkList MergeList_L(LinkList La,LinkList Lb){int i,j,k;LinkList pa_1,pb_1,pa_2,pb_2,pc,pd;pa_1=La->next;pc=pa_2=La;pb_1=pb_2=Lb->next;if(pa_1->data > pb_1->data){pc=pa_2=Lb;pa_1=Lb->next;pb_1=pb_2=La->next;}while(pa_1 && pb_1){if(pa_1->data >= pb_1->data){pa_2->next=pb_1;pb_2=pb_1->next;pb_1->next=pa_1;pb_1=pb_2;pa_2=pa_2->next;}else{pa_1=pa_1->next;pa_2=pa_2->next;}}if(pb_1)pa_2->next=pb_1;pd=(LinkList)malloc(sizeof(struct LNode));pd->next=NULL;pa_2=pd;k=total;for(i=0;i<total;i++){pa_1=pc->next;for(j=1;j<k;j++)pa_1=pa_1->next;pb_1=(LinkList)malloc(sizeof(struct LNode));pa_2->next=pb_1;pa_2=pa_2->next;pa_2->data=pa_1->data;k--;}pa_2->next=NULL;return pd;}2.流程图(实验要求1和3)图1 主函数流程图图2创建线性表La流程图图3判断La是否为空表流程图图4 插入元素(La)流程图图5删除元素(La)流程图图6定位元素(La)流程图图7取元素(La)流程图图8输出线性表流程图图9输出线性表流程图流程图(实验要求2和4)图10主函数流程图图11创建线性表La流程图图12判断是否为空表流程图图13插入元素流程图图14删除元素流程图图15定位元素流程图图图16取元素流程图图17创建Lb流程图图18归并两表流程图六、运行结果1. (实验要求1和3)点击运行，首先出现的是菜单界面，选择菜单选项进行操作，如图所示。

数据结构--实验报告线性表的基本操作数据结构--实验报告线性表的基本操作一、引言本实验报告旨在通过实际操作，掌握线性表的基本操作，包括初始化、插入、删除、查找等。

线性表是最基本的数据结构之一，对于理解和应用其他数据结构具有重要的作用。

二、实验目的1·了解线性表的定义和基本特性。

2·掌握线性表的初始化操作。

3·掌握线性表的插入和删除操作。

4·掌握线性表的查找操作。

5·通过实验巩固和加深对线性表的理解。

三、线性表的基本操作1·初始化线性表线性表的初始化是将一个线性表变量设置为空表的过程。

具体步骤如下：（1）创建一个线性表的数据结构，包括表头指针和数据元素的存储空间。

（2）将表头指针指向一个空的数据元素。

2·插入元素插入元素是向线性表中指定位置插入一个元素的操作。

具体步骤如下：（1）判断线性表是否已满，如果已满则无法插入元素。

（2）判断插入位置是否合法，如果不合法则无法插入元素。

（3）将插入位置及其后面的元素都向后移动一个位置。

（4）将待插入的元素放入插入位置。

3·删除元素删除元素是从线性表中删除指定位置的元素的操作。

具体步骤如下：（1）判断线性表是否为空，如果为空则无法删除元素。

（2）判断删除位置是否合法，如果不合法则无法删除元素。

（3）将删除位置后面的元素都向前移动一个位置。

（4）删除最后一个元素。

4·查找元素查找元素是在线性表中查找指定元素值的操作。

具体步骤如下：（1）从线性表的第一个元素开始，逐个比较每个元素的值，直到找到目标元素或遍历完整个线性表。

（2）如果找到目标元素，则返回该元素的位置。

（3）如果未找到目标元素，则返回找不到的信息。

四、实验步骤1·初始化线性表（1）定义线性表的数据结构，包括表头指针和数据元素的存储空间。

（2）将表头指针指向一个空的数据元素。

2·插入元素（1）判断线性表是否已满。

实验一线性表基本操作的编程实现【实验目的】线性表基本操作的编程实现要求：线性表基本操作的编程实现（2学时，验证型），掌握线性表的建立、遍历、插入、删除等基本操作的编程实现，也可以进一步编程实现查找、逆序、排序等操作，存储结构要求是链表存储结构（顺序存储结构建议作为课外实验完成），可以依次完成主要功能来体现功能的正确性，用菜单进行管理完成大部分功能，要求可以重复运行。

还鼓励学生利用基本操作进行一些更实际的应用型程序设计。

【实验性质】验证性实验（学时数：2H）【实验内容】1.线性表的链表存储，实现数据插入、删除运算。

为了体现功能的正常性，同时要编制数据输入函数和遍历函数，数据输入最好同时提供计算机自动产生数据。

2.其他建议改进的功能或细节：存储结构修改为循环链表、双向链表、循环双向链表等。

原始数据从文本文件读入。

结果存入文本文件【注意事项】1.开发语言：使用C++，不能使用C。

至于是否使用对象，初期可以不用，但是建议尽量尽快使用对象。

2.可以自己增加其他功能。

3．如果是自己开发的，请在程序界面上注明 ***原创。

如果是参考他人或改编他人的，则注明：*** 参考他人版。

希望大家诚实对待自己的努力。

如果有小组，版权页上写上全组人员。

4.在实验报告中也应该如实写出哪些程序功能是自己编的，哪些是参考别人的。

5.初始成绩全部学生都是不及格，然后逐步通过提交更好的版本来刷新成绩。

实验当日仅仅是不及格变为及格。

之后通过班长全班学生提交源代码，为了方便，建议把程序做成一个cpp。

之后在实验后的三天时间内提交实验报告。

过时不候。

结合实验当时的检测，实验后源代码的检测，实验报告的书写给出当次的成绩。

分为五级制。

程序提交在实验之后的三天里可以刷新。

但是一般不应该超过二次。

提交的程序必须要语法正确的。

目前由于老师的审查平台是c++6.0，所以为了统一起见，不接受其他平台的开发系统。

程序名一律类似为：T423-2-17-翁靖凯-链表实验程序.cpp所有信息之间为中横线。

数据结构--实验报告线性表的基本操作线性表的基本操作实验报告1.引言线性表是最基本的数据结构之一，它可以用来存储一系列具有相同数据类型的元素。

本实验旨在通过实践掌握线性表的基本操作，包括插入、删除、查找和修改元素等。

本文档将详细介绍实验所需的步骤和操作方法。

2.实验目的1.掌握线性表的插入和删除操作。

2.理解线性表的查找和修改元素的方法。

3.熟悉线性表的基本操作在算法中的应用。

3.实验环境本实验使用编程语言/软件名称作为开发环境，具体要求如下：________●操作系统：________操作系统名称和版本●编程语言：________编程语言名称和版本4.实验步骤4.1 初始化线性表在程序中创建一个空的线性表，用于存储元素。

实现方法：________具体的初始化方法和代码示例 4.2 插入元素在线性表中指定位置插入一个新元素。

实现方法：________具体的插入元素方法和代码示例 4.3 删除元素删除线性表中指定位置的元素。

实现方法：________具体的删除元素方法和代码示例 4.4 查找元素在线性表中查找指定元素的位置。

实现方法：________具体的查找元素方法和代码示例 4.5 修改元素修改线性表中指定位置的元素值。

实现方法：________具体的修改元素方法和代码示例5.实验结果在完成上述步骤后，我们得到了一个可以进行插入、删除、查找和修改元素的线性表。

具体操作结果如下：________●插入元素操作结果：________插入元素的具体操作结果●删除元素操作结果：________删除元素的具体操作结果●查找元素操作结果：________查找元素的具体操作结果●修改元素操作结果：________修改元素的具体操作结果6.实验总结通过本次实验，我们深入理解了线性表的基本操作，并且掌握了这些操作的实现方法。

线性表在实际应用中十分常见，熟练掌握线性表的操作对于开发高效的算法和数据结构具有重要意义。

实验一--线性表基本操作的编程实现实验一线性表基本操作的编程实现【实验目的】线性表基本操作的编程实现要求：线性表基本操作的编程实现（2学时，验证型），掌握线性表的建立、遍历、插入、删除等基本操作的编程实现，也可以进一步编程实现查找、逆序、排序等操作，存储结构可以在顺序结构或链表结构中任选，可以完成部分主要功能，也可以用菜单进行管理完成大部分功能。

还鼓励学生利用基本操作进行一些更实际的应用型程序设计。

【实验性质】验证性实验（学时数：2H）【实验内容】把线性表的顺序存储和链表存储的数据插入、删除运算其中某项进行程序实现。

建议实现键盘输入数据以实现程序的通用性。

为了体现功能的正常性，至少要编制遍历数据的函数。

【注意事项】1.开发语言：使用C。

2.可以自己增加其他功能。

【思考问题】1.线性表的顺序存储和链表存储的差异？优缺点分析？2.那些操作引发了数据的移动？3.算法的时间效率是如何体现的？4.链表的指针是如何后移的？如何加强程序的健壮性？【参考代码】（以下内容，学生任意选择一个完成即可）（一）利用顺序表完成一个班级学生课程成绩的简单管理1、预定义以及顺序表结构类型的定义(1) #include<stdio.h>#include<conio.h>#define ListSize 100 //根据需要自己设定一个班级能够容纳的最大学生数(2) typedef struct stu{int num; //学生的学号char name[10]; //学生的姓名float physics; //物理成绩float math; //数学成绩float english; //英语成绩}STUDENT; //存放单个学生信息的结构体类型typedef struct List{STUDENT stu[ListSize]; //存放学生的数组定义，静态分配空间int length; //记录班级实际学生个数}LIST; //存放班级学生信息的顺序表类型2、建立班级的学生信息void listcreate(LIST *Li,int m) //m为该班级的实际人数{int i;Li->length=0;for(i=1; ;i++) //输入m个学生的所有信息{printf("请输入第%d位学生的信息:\n",i);printf("学号=");scanf("%d",&Li->stu[i].num); //输入第i个学生的学号printf("姓名=");scanf("%s",&Li->stu[i].name); //输入第i个学生的姓名printf("物理成绩=");scanf("%f",&Li->stu[i].physics); //输入第i 个学生的物理成绩printf("数学成绩=");scanf("%f",&Li->stu[i].math); //输入第i个学生的数学成绩printf("英语成绩=");scanf("%f",&Li->stu[i].english); //输入第i 个学生的英语成绩; //学生人数加1}}3、插入一个学生信息int listinsert(LIST *Li,int i) //将学生插入到班级Li的第i个位置。