数据结构线性表实验报告

合集下载

数据结构实验报告-线性表(顺序表实现)

实验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.归并顺序表（销毁或清空操作前）七、思考讨论题或体会或对改进实验的建议通过本次实验，我掌握了定义线性表的顺序存储类型，加深了对顺序存储结构的理解，进一步巩固和理解了顺序表的基本操作，如建立、查找、插入和删除等。

数据结构实验报告——线性表

实验报告：线性表的基本操作实验1：实现顺序表各种基本运算的算法一、实验目的学会并运用顺序表存储结构及各种运算。

二、实验环境VC++6.0三、实验准备(1) 复习课件中理论知识(2)练习课堂所讲的例子四、实验内容编写一个程序实现SqList.cpp,实现顺序表基本运算，并在此基础上设计个主程序exp1.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;五、实验步骤1、构造一个空的线形表并分配内存空间Status InitList_Sql(SqList &L){L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L.elem) exit(OVERFLOW);L.length=0; L.listsize=LIST_INIT_SIZE; return OK; }2、求线性表的长度Status ListLength(SqList L) {return L.length; }3、线性表清空void ClearList(SqList &L){ L.length = 0; }4、在顺序线形表 L 中第 i 个位置之前插入新的元素 eStatus ListInsert_Sq(SqList &L,int i,ElemType e)5、查找'm'在顺序表中的位序e = 'm'; i = LocateElem_Sq(L,e);printf("元素 m 在顺序表中的位序是：%d\n",i);6、在第4个位置上插入f元素printf("（在第 4 个元素位置上插入 f 元素\n");ListInsert_Sq(L,4,'f');7、删除第 3 个元素printf("（删除顺序表 L 中第 3 个元素:"); ListDelete_Sq(L, 3, e);printf("被删除的第 3 个元素值是：%c",e);8、重新申请空间ElemType*newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof( ElemType)); if(!newbase) exit(OVERFLOW);L.elem=newbase;新的存储空间基址 L.listsize+=LISTINCREMENT;9、初始化并插入元素InitList_Sql(L); printf("依次插入 a,b,c,d,e 元素\n");10、输出顺序表、释放顺序表printf("输出顺序表 L:"); ListTraverse(L); printf("（释放顺序表L\n"); DestroyList(L);六、实验总结通过该实验的学习，对课堂内容再次巩固，对顺序表也有了更深的了解。

数据结构线性表试验报告（最终定稿）

数据结构线性表试验报告（最终定稿）第一篇：数据结构线性表试验报告线性表上机实习1、实验目的（1）熟悉将算法转换为程序代码的过程。

（2）了解顺序表的逻辑结构特性，熟练掌握顺序表存储结构的C 语言描述方法。

（3）熟练掌握顺序表的基本运算：查找、插入、删除等，掌握顺序表的随机存取特性。

（4）了解线性表的链式存储结构，熟练掌握线性表的链式存储结构的C语言描述方法。

（5）熟练掌握线性链表（单链表）的基本运算：查找、插入、删除等，能在实际应用中灵活选择适当的链表结构。

2、实验要求（1）熟悉顺序表的插入、删除和查找。

（2）熟悉单链表的插入、删除和查找。

3、实验内容: ① 顺序表（1）抽象数据类型定义typedef struct {TypeData data[maxsize];//容量为maxsize的静态顺手表int n;//顺序表中的实际元素个数}SeqList;//静态顺序表的定义在本次实验中，首先建立一个空的静态顺序表，然后键盘输入数据存入表中，然后进入菜单选择界面，通过不同的数字输入，实现对顺序表，删除，插入，查找，显示等操作。

（2）存储结构定义及算法思想在顺序表结构体的定义中，typedef int TypeData 为整型，存储结构如下：for(n=0;ncout<<“请输入线性表数据”<cin>>L.data[n];//顺序将数据存入顺序表}//其他存储与此类似，都是直接赋值与数组的某一位插入版块子函数：void insert(SeqList &L)//插入数据 {int a,b,c,k;cout<<“请输入插入的数及其插入的位置”<cin>>a>>b;if(b<=0||b>(L.n+1)){cout<<“不能在该位置插入”<k=L.data[b-1];L.data[b-1]=a;c=L.n;L.n=L.n+1;while(c>b){L.data[c]=L.data[c-1];c--;//通过循环，实现插入位置后的数据挨个往后移动一位}L.data[b]=k;} 顺序表的插入与删除操作类似，在插入与删除后，都要循环调整后面数组的每一位元素，同时记录数据元素的长度的标示符也要跟着改变。

数据结构线性表实验报告

数据结构线性表实验报告数据结构线性表实验报告1.简介本实验报告旨在介绍数据结构中线性表的实现和应用。

线性表是一种重要的数据结构，它的特点是数据元素之间存在一对一的前后关系，且具有唯一的起点和终点。

本实验通过实现线性表的基本操作，加深对线性表的理解，并通过实例应用展示线性表在实际问题中的应用。

2.实验环境本次实验采用的是编程语言C，并搭配使用一些常用的开发工具和库。

具体环境如下：________●操作系统：________Windows 10●编程语言：________C●开发工具：________Visual Studio Code●辅助库：________Stdio.h、stdlib.h、conio.h3.实验内容3.1 线性表的定义和基本操作3.1.1 线性表的定义线性表是由n（n ≥ 0）个数据元素组成的有限序列，数据元素之间存在一对一的前后关系。

3.1.2 线性表的基本操作●初始化线性表：________创建一个空的线性表。

●插入元素：________在指定位置插入一个新的元素。

●删除元素：________删除指定位置的元素。

●查找元素：________根据值或位置查找指定元素。

●修改元素：________根据位置修改指定元素的值。

●清空线性表：________将线性表中的所有元素清空。

3.2 线性表的顺序存储结构3.2.1 顺序存储结构的定义顺序存储结构是指使用一段连续的存储空间，依次存储线性表中的元素。

3.2.2 顺序存储结构的实现●初始化顺序表：________创建一个空的顺序表，并指定最大容量。

续元素依次后移。

●删除元素：________删除指定位置的元素，并将后续元素依次前移。

●查找元素：________根据值或位置查找指定元素，并返回其位置或值。

●修改元素：________根据位置修改指定元素的值。

●清空顺序表：________将顺序表中的所有元素清空。

●扩容：________当顺序表容量不足时，自动进行扩容。

数据结构实验报告线性表

数据结构实验报告线性表数据结构实验报告：线性表引言数据结构是计算机科学中非常重要的一个概念，它是用来组织和存储数据的一种方式。

线性表是数据结构中最基本的一种，它是由n个数据元素组成的有限序列。

在本次实验中，我们将对线性表进行深入研究，并进行实验验证。

实验目的1. 了解线性表的基本概念和特性2. 掌握线性表的顺序存储结构和链式存储结构3. 熟练掌握线性表的基本操作：插入、删除、查找等4. 通过实验验证线性表的操作和性能实验内容1. 学习线性表的基本概念和特性2. 熟悉线性表的顺序存储结构和链式存储结构3. 实现线性表的基本操作：插入、删除、查找等4. 对线性表的操作进行性能测试和分析实验步骤1. 学习线性表的基本概念和特性，包括线性表的定义、顺序存储结构和链式存储结构等2. 实现线性表的基本操作：插入、删除、查找等3. 设计实验用例，对线性表的操作进行性能测试4. 对实验结果进行分析和总结实验结果1. 实现了线性表的顺序存储结构和链式存储结构2. 实现了线性表的基本操作：插入、删除、查找等3. 对线性表的操作进行了性能测试，并得出了相应的性能数据4. 对实验结果进行了分析和总结，得出了相应的结论结论通过本次实验，我们深入了解了线性表的基本概念和特性，掌握了线性表的顺序存储结构和链式存储结构，熟练掌握了线性表的基本操作，并对线性表的性能进行了测试和分析。

这些都为我们进一步深入学习和应用数据结构打下了坚实的基础。

总结数据结构是计算机科学中非常重要的一部分，线性表作为数据结构中最基本的一种，对我们学习和应用数据结构具有重要的意义。

通过本次实验，我们对线性表有了更深入的了解，并且掌握了相关的操作和性能测试方法，这将为我们今后的学习和应用提供很大的帮助。

(完整版)数据结构线性表的应用实验报告

实验报告课程名称____数据结构上机实验__________ 实验项目______线性表的应用 ____________实验仪器________PC机___________________系别_____电子信息与通信学院___专业________ ___班级/学号______ __学生姓名______ ___________实验日期_______________________成绩_______________________指导教师_______________________实验一.线性表的应用1.实验目的：掌握线性链表的存储、运算及应用。

利用链表实现一元多项式计算。

2.实验内容：1)编写函数，实现用链表结构建立多项式；2)编写函数，实现多项式的加法运算；3)编写函数，实现多项式的显示；4)测试：编写主函数，它定义并建立两个多项式，显示两个多项式，然后将它们相加并显示结果。

变换测试用的多项式，检查程序的执行结果。

选做内容：修改程序，选择实现以下功能：5)多项式求值：编写一个函数，根据给定的x值计算并返回多项式f(x)的值。

测试该函数（从终端输入一个x的值，调用该函数并显示返回结果）。

6)多项式相减：编写一个函数，求两个多项式相减的多项式。

7)多项式相乘：编写一个函数，求两个多项式的乘积多项式。

3.算法说明：1)多项式的建立、显示和相加算法见讲义。

可修改显示函数，使输出的多项式更符合表达规范。

2)多项式减法：同次项的系数相减（缺项的系数是0）。

例如a(x)=-5x2+2x+3，b(x)= -4x3+3x，则a(x)-b(x)=4x3-5x2-x+3。

提示：a(x)-b(x) = a(x)+(-b(x))。

3)多项式乘法：两个多项式的相乘是“系数相乘，指数相加”。

算法思想是用一个多项式中的各项分别与另一个多项式相乘，形成多个多项式，再将它们累加在一起。

例如，a(x)=-5x2+2x+3，b(x)=-4x3+3x，则a(x)*b(x) = (-4x3)*(-5x2+2x+3)+(3x)*(-5x2+2x+3)= (20x5-8x4-12x3) + (-15x3+6x2+9x) =20x5-8x4-27x3+6x2+9x。

数据结构实验报告线性表

数据结构实验报告线性表数据结构实验报告：线性表引言：数据结构是计算机科学中的重要概念，它涉及到如何组织和存储数据，以及如何有效地操作和管理这些数据。

线性表是数据结构中最基本的一种，它是一种有序的数据元素集合，其中的元素之间存在着一对一的关系。

一、线性表的定义和特点线性表是由n个数据元素组成的有限序列，其中n为表的长度。

这些数据元素可以是相同类型的，也可以是不同类型的。

线性表中的数据元素按照一定的顺序排列，并且每个数据元素都有唯一的前驱和后继。

线性表的特点有以下几个方面：1. 数据元素之间是一对一的关系，即每个数据元素只有一个直接前驱和一个直接后继。

2. 线性表中的元素是有序的，每个元素都有一个确定的位置。

3. 线性表的长度是有限的，它的长度可以是0，也可以是任意正整数。

二、线性表的实现方式线性表可以使用不同的数据结构来实现，常见的实现方式有数组和链表。

1. 数组实现线性表：数组是一种连续存储的数据结构，它可以用来存储线性表中的元素。

数组的优点是可以快速访问任意位置的元素，但是插入和删除操作需要移动其他元素，效率较低。

2. 链表实现线性表：链表是一种非连续存储的数据结构，它通过指针将线性表中的元素链接起来。

链表的优点是插入和删除操作简单高效，但是访问任意位置的元素需要遍历链表，效率较低。

三、线性表的基本操作线性表的基本操作包括插入、删除、查找和修改等。

1. 插入操作：插入操作用于向线性表中插入一个新元素。

具体步骤是先将插入位置后面的元素依次后移，然后将新元素插入到指定位置。

2. 删除操作：删除操作用于从线性表中删除一个元素。

具体步骤是先将删除位置后面的元素依次前移，然后将最后一个元素删除。

3. 查找操作：查找操作用于在线性表中查找指定元素。

具体步骤是从线性表的第一个元素开始逐个比较，直到找到匹配的元素或者到达线性表的末尾。

4. 修改操作：修改操作用于修改线性表中的某个元素的值。

具体步骤是先查找到要修改的元素，然后将其值更新为新值。

数据结构线性表实验报告

数据结构线性表实验报告数据结构线性表实验报告实验目的：本次实验主要是为了学习和掌握线性表的基本操作和实现方式。

通过实验，我们可以加深对线性表的理解，并能够熟悉线性表的基本操作。

实验设备与环境：本次实验所需的设备包括计算机和编程环境。

我们选择使用C语言来实现线性表的操作，并在Visual Studio Code编程软件中进行编写和调试。

实验内容：1.线性表的定义和基本操作1.1 线性表的定义：线性表是一种有序的数据结构，其中的元素按照一定的顺序存储，可以插入、删除和访问元素。

1.2 线性表的基本操作：1.2.1 初始化线性表：创建一个空的线性表。

1.2.2 判断线性表是否为空：判断线性表是否不含有任何元素。

1.2.3 获取线性表的长度：返回线性表中元素的个数。

1.2.4 在线性表的指定位置插入元素：在线性表的第i个位置插入元素x，原第i个及其之后的元素依次后移。

1.2.5 删除线性表中指定位置的元素：删除线性表中第i个位置的元素，原第i+1个及其之后的元素依次前移。

1.2.6 获取线性表中指定位置的元素：返回线性表中第i个位置的元素的值。

1.2.7 清空线性表：将线性表中的元素全部删除，使其变为空表。

2.线性表的顺序存储结构实现2.1 线性表的顺序存储结构：使用数组来实现线性表的存储方式。

2.2 线性表的顺序存储结构的基本操作：2.2.1 初始化线性表：创建一个指定长度的数组，并将数组中的每个元素初始化为空值。

2.2.2 判断线性表是否为空：判断线性表的长度是否为0。

2.2.3 获取线性表的长度：返回线性表数组的长度。

2.2.4 在线性表的指定位置插入元素：将要插入的元素放入指定位置，并将原位置及其之后的元素依次后移。

2.2.5 删除线性表中指定位置的元素：将指定位置的元素删除，并将原位置之后的元素依次前移。

2.2.6 获取线性表中指定位置的元素：返回指定位置的元素的值。

2.2.7 清空线性表：将线性表数组中的每个元素赋空值。

数据结构线性表实验报告

数据结构线性表实验报告数据结构线性表实验报告引言：数据结构是计算机科学中的一个重要概念，它研究如何组织和存储数据，以便能够高效地访问和操作。

线性表是数据结构中最基本的一种，它是一种有序的数据元素集合，其中的元素之间存在一对一的关系。

本次实验旨在通过实际操作线性表，加深对数据结构的理解，并掌握基本的线性表操作。

实验目的：1. 理解线性表的概念和特点；2. 掌握线性表的基本操作，如插入、删除、查找等；3. 熟悉线性表的顺序存储结构和链式存储结构；4. 分析不同存储结构的优缺点。

实验内容：1. 实现线性表的顺序存储结构顺序存储结构是将线性表的元素按照其逻辑顺序依次存放在一块连续的存储空间中。

我们可以使用数组来实现顺序存储结构。

首先，定义一个固定大小的数组作为线性表的存储空间，然后通过数组的下标来访问和操作线性表中的元素。

在插入和删除元素时，需要移动其他元素的位置，以保持线性表的有序性。

2. 实现线性表的链式存储结构链式存储结构是将线性表的元素存储在一系列的结点中，每个结点包含一个数据元素和一个指向下一个结点的指针。

通过将各个结点用指针连接起来，形成一个链表。

在插入和删除元素时，只需要修改相邻结点之间的指针，而不需要移动其他元素的位置。

实验步骤：1. 实现顺序存储结构的线性表首先，定义一个固定大小的数组，用于存储线性表的元素。

然后，实现插入、删除、查找等基本操作。

在插入元素时，需要判断线性表是否已满，如果已满则需要扩容。

在删除元素时，需要判断线性表是否为空，如果为空则无法删除元素。

通过实现这些基本操作，可以对线性表进行增删查改等操作。

2. 实现链式存储结构的线性表首先，定义一个结点类，包含一个数据元素和一个指向下一个结点的指针。

然后，通过将各个结点用指针连接起来，形成一个链表。

实现插入、删除、查找等基本操作。

在插入元素时，需要找到插入位置，并修改相邻结点之间的指针。

在删除元素时，需要找到待删除元素的前一个结点，并修改前一个结点的指针。

线性表实验报告

线性表实验报告一、实验目的本次实验的主要目的是深入理解线性表的基本概念和操作，通过实际编程实现线性表的存储和基本运算，掌握线性表在数据结构中的应用，提高对数据结构的理解和编程能力。

二、实验环境本次实验使用的编程语言为C+＋，开发工具为Visual Studio 2019。

三、实验原理线性表是一种最基本、最简单的数据结构，它是由 n（n≥0）个数据元素组成的有限序列。

在这个序列中，每个数据元素的位置是按照其逻辑顺序排列的。

线性表有两种存储结构：顺序存储结构和链式存储结构。

顺序存储结构是用一组地址连续的存储单元依次存储线性表中的数据元素，使得逻辑上相邻的两个元素在物理位置上也相邻。

其优点是可以随机访问表中的任意元素，时间复杂度为 O(1)；缺点是插入和删除操作需要移动大量元素，时间复杂度为 O(n)。

链式存储结构是通过指针将各个数据元素链接起来，每个数据元素由数据域和指针域组成。

其优点是插入和删除操作不需要移动大量元素，时间复杂度为 O(1)；缺点是不能随机访问表中的元素，需要从头指针开始遍历，时间复杂度为 O(n)。

四、实验内容本次实验实现了顺序表和链表的基本操作，包括创建、插入、删除、查找、遍历等。

1、顺序表的实现定义顺序表的结构体，包括数据存储数组和表的长度。

实现顺序表的初始化函数，将表的长度初始化为 0。

实现顺序表的插入函数，在指定位置插入元素，如果插入位置非法或表已满，则返回错误。

实现顺序表的删除函数，删除指定位置的元素，如果删除位置非法，则返回错误。

实现顺序表的查找函数，查找指定元素，如果找到则返回元素的位置，否则返回－1。

实现顺序表的遍历函数，输出表中的所有元素。

2、链表的实现定义链表的结构体，包括数据域和指向下一个节点的指针域。

实现链表的创建函数，创建一个空链表。

实现链表的插入函数，在指定位置插入元素，如果插入位置非法，则返回错误。

实现链表的删除函数，删除指定位置的元素，如果删除位置非法，则返回错误。

数据结构线性表实验报告

实验一线性表一、实验目的1.掌握实现线性表的基本操作方法；2.掌握线性表的基本操作:建表、插入、删除、输出等运算在顺序存储结构和链式存储结构上的实现；3.通过本次实习加深对高级语言C语言的使用(特别是函数参数、指针类型、链表的使用)。

熟悉线性表的基本运算在两种存储结构(顺序结构和链式结构)上的实现。

二、实验环境装有VisualC++6.0的普通PC机三、源程序#include"string.h"#include "stdio.h"#include "stdlib.h"#include "conio.h"#define MaxLine 100 /*顺序存储的最大个数*/ typedef int ElemType;typedef struct SqList{ElemType data[MaxLine];/*存放顺序表的数组*/ int length;/*顺序表的长度*/} L;/*初始化顺序表*/void InitList(SqList&L){L.length = 0;//L.length =0;}/*得到顺序表的长度*/int GetLength(SqList &L){return L.length;}/*得到顺序表中的第i个元素*/ElemType GetElem(SqList &L,int i){if(i < 1 || i > L.length) 开始{printf("error");exit(1);}return L.data[i-1];}void ListInsert(SqList &L,int i,ElemType x)/*添加线性表中第i个位置上的元素,i从1开始*/{int j;if(i < 1 || i > L.length+1) /*检查添加位置的合法性*/{printf("error");exit(1);}if(L.length >= MaxLine){printf("overflow!");exit(1);}j = L.length;while(j>=i)/*此处语句相对参考语句有较大改变*/{L.data[j]=L.data[j-1];j--;}L.data[i-1] = x;L.length++;}void ListDelete(SqList &L,int i) /* 删除线性表中第i个位置上的元素*/ {int j;if(i<1 || i>L.length) /* 检查空表及删除位置的合法性*/ {printf ("不存在第i个元素");exit(0);}for(j=i;j<=L.length-1;j++)L.data[j-1]=L.data[j]; /* 向前移动元素*/L.length--;}int main(){FILE *fp;struct SqList A;InitList(A);/*初始化顺序表*/int Judge2=0;printf(" ***线性表操作实验***\n \n\n请输入0对长度为8的线性表输入数据或者其他任意数进行其他操作^_^\n");scanf("%d",&Judge2);if(Judge2==0){int t = 1,d=1;for(t=1;t<=8;t++)/*此处为顺序表首先输入8个元素*/{printf("请输入第%d个线性表元素:",t);scanf("%d",&d);ListInsert(A,t,d);}}int Judge=0;printf("输入0结束程序或者输入其他任意数继续对该表进行操作^_^\n");scanf("%d",&Judge);while(Judge)/*判断是结束程序还是要继续操作该顺序表*/{int a=0;int pos=0;int c=0;int Judge1=0;int P;/*给出顺序表操作选择菜单分别为输入，删除，显示长度，打印顺序表*/printf(" ***************\n *输入1进行插入*\n");printf(" *输入2进行删除*\n");printf(" *输入3显示长度*\n");printf(" *输入4打印该表*\n");printf(" *输入5保存数据*\n");printf(" *输入6进行排序*\n");printf(" *输入7查找数据*\n ***************\n");printf("请选择:");/*选择要进行的操作*/scanf("%d",&P);if(P==0)return 0;else if(P>=1&&P<=7)switch(P){case 1:printf("请输入想进行插入操作的位置:");/*选择待插入位置*/scanf("%d",&pos);int PP;printf("请输入待插入的元素:\n");/*输入要插入的元素*/scanf("%d",&PP);ListInsert(A,pos,PP);c=GetLength(A);printf("该线性表的长度为：%d!\n",c);/*此处选择是重新选择操作还是按顺序进行下一项操作*/printf("请输入0结束操作或者其他任意数继续其他操作^_^\n");scanf("%d",&Judge1);if(Judge1==1)continue;else break;case 2:printf("输入要删除元素的位置:");/*选择要删除的元素位置*/scanf("%d",&a);ListDelete(A,a);c=GetLength(A);printf("该线性表的长度为：%d!\n",c);/*此处选择是重新选择操作还是按顺序进行下一项操作*/printf("请输入0结束操作或者其他任意数继续进行其他操作^_^\n");scanf("%d",&Judge1);if(Judge1==1)continue;else break;case 3:c=GetLength(A);printf("该线性表的长度为：%d!\n",c);printf("请输入0结束操作或者其他任意数继续进行其他操作^_^\n");scanf("%d",&Judge1);if(Judge1==1)continue;else break;case 4:{c=GetLength(A);int d=0;printf("%s"," 该线性表数据记录如下\n");printf("%s","*****************************************************\n");for(int aa=0;aa<c;aa++){printf(" ");printf("%d \t",A.data[aa]); d++;/*打印该线性表*/if( d%4 ==0) printf("\n");}printf("\n");printf("%s","*****************************************************\n");printf("请输入0结束操作或者其他任意数继续进行其他操作^_^\n");scanf("%d",&Judge1);if(Judge1==1)continue;else break;}case 5:{fp=fopen("Test.txt","wt+");int i=0,j=0;fprintf(fp,"%s"," 文件Test数据记录\n");fprintf(fp,"%s","_________________________\n");for(i=0;i<GetLength(A);){fprintf(fp,"%d",A.data[i]);i++;fputc('\t',fp);j++;if(j%4==0) fputc(10,fp);} ;fprintf(fp,"%s","\n_________________________");fclose(fp);printf("相关数据已经存入文件Test.txt中^_^\n");printf("请输入0结束操作或者其他任意数继续进行其他操作^_^\n");scanf("%d",&Judge1);if(Judge1==1)continue;else break;}case 6:{int i,j,temp;for(i=0;i<GetLength(A)-1;i++)for(j=i+1;j<GetLength(A);j++) /*注意循环的上下限*/{if(A.data[i]>A.data[j]){temp=A.data[i];A.data[i]=A.data[j];A.data[j]=temp;}}c=GetLength(A);int d=0;printf("%s","排序后该线性表数据记录如下\n");printf("%s","**************************\n");for(int aa=0;aa<c;aa++){printf("%d \t",A.data[aa]); d++;/*打印该线性表*/if( d%4 ==0) printf("\n");}printf("\n");printf("%s","**************************\n");printf("请输入0结束操作或者其他任意数继续进行其他操作^_^\n");scanf("%d",&Judge1);if(Judge1==1)continue;else break;}case 7:{int value;printf("请输入待查找的数据：\n");scanf("%d",&value);for(int i=0;i<GetLength(A);){if(A.data[i] == value)printf("待查找的是表中第%d个数据%d^_^\n",i+1,value);else if(i>=(GetLength(A)-1)) printf("待查找的数据不存在+_+\n");i++;}printf("请输入0结束操作或者其他任意数继续进行其他操作^_^\n");scanf("%d",&Judge1);if(Judge1==1)continue;else break;}}printf("请输入0 结束程序或者输入其他任意数继续进行操作^_^\n");scanf("%d",&Judge);}return 0;}四、实验数据记录1，生成长度为8的线性表2，选择插入数据3，删除数据4，打印表5，保存数据6，排序7，查找数据五、实验总结实验在编写源程序是由于参考给的参考程序较多，但是参考程序存在一定的问题且相当不完善，走了弯路。

数据结构线性表实验报告

数据结构线性表实验报告数据结构线性表实验报告1.实验目的1.1 理解线性表的概念和操作方法1.2 学习线性表的顺序存储结构和链式存储结构1.3 掌握线性表的各种基本操作算法2.实验内容2.1 实现线性表的顺序存储结构a. 定义顺序存储结构的数据类型和长度b. 实现线性表的初始化操作c. 实现线性表的插入操作d. 实现线性表的删除操作e. 实现线性表的查找操作2.1.6 实现线性表的更新操作2.1.7 实现线性表的打印操作2.2 实现线性表的链式存储结构a. 定义链式存储结构的数据类型和长度b. 实现线性表的初始化操作c. 实现线性表的插入操作d. 实现线性表的删除操作e. 实现线性表的查找操作2.2.6 实现线性表的更新操作2.2.7 实现线性表的打印操作2.3 实现线性表的其他操作a. 实现线性表的长度计算b. 实现线性表的合并操作c. 实现线性表的排序操作3.实验步骤3.1 初始化线性表a. 选择合适的存储结构b. 设置线性表的初始状态c. 完成线性表的初始化工作3.2 插入操作a. 根据线性表的存储结构选择插入点b. 将要插入的元素放入插入点位置c. 调整线性表的长度和位置3.3 删除操作a. 根据线性表的存储结构选择删除点b. 删除指定位置的元素c. 调整线性表的长度和位置3.4 查找操作a. 根据线性表的存储结构选择查找方法b. 实现线性表的按值查找3.4.3 实现线性表的按位置查找3.5 更新操作a. 根据线性表的存储结构选择更新点b. 更新指定位置的元素c. 调整线性表的长度和位置3.6 打印操作a. 根据线性表的存储结构选择打印方法b. 实现线性表的打印功能4.实验结果4.1 实现了线性表的顺序存储结构，包括初始化、插入、删除、查找、更新和打印功能4.2 实现了线性表的链式存储结构，包括初始化、插入、删除、查找、更新和打印功能4.3 实现了线性表的其他操作，包括长度计算、合并和排序操作5.实验总结5.1 通过本次实验，掌握了线性表的基本概念和操作方法5.2 熟悉了线性表的顺序存储结构和链式存储结构的实现方式5.3 熟练使用了线性表的各种基本操作算法附件：●附件1：代码实现●附件2：实验数据法律名词及注释：1.著作权：著作权是指作者对其创作的文学、艺术和科学等作品享有的法律权利。

数据结构线性表实验报告

数据结构线性表实验报告⼀、实验⽬的：1、复习c/c++语⾔，并实现简单的算法设计。

2、掌握结构体类型/类的定义⽅法以及⾃定义数据类型使⽤。

3、掌握函数的设计和调⽤。

4、学会理解ADT(Abstract Data Type)描述，从⽽利⽤程序语⾔加以实现。

5、学会基本的程序组织⽅法和对抽象数据类型实现的应⽤。

⼆、实验内容和要求实验内容：设计⼀个复数的抽象类型定义。

实现复数基本运算基本操作。

编写函数对所实现的抽象数据类型进⾏测试并验证。

实验要求：1、由输⼊⽣成复数的实部虚部。

2、对所定义的数据类型的应⽤中，间接访问结构体类型/类内部数据。

3、完成基本四则运算，设置复数实部、虚部等操作。

三、实现提⽰1、抽象数据类型定义抽象数据类型⽤⼀个三元组（D，S，P）表实，其中D表⽰数据对象，S是D上的关系集，P是对数据对象D的基本操作集合。

A、抽象数据类型的定义格式：ADT抽象类型名{数据对象：<数据对象定义>数据关系：<数据关系定义>基本操作：<基本操作定义>}ADT抽象数据类型名B、抽象数据类型中基本操作的定义格式：基本操作名（参数表）初始条件：<初始条件描述>操作结果：<操作结果描述>赋值参数：为操作提供输⼊值；引⽤参数：既可为操作提供输⼊值，还返回操作结果；初始条件：指操纵前数据结构和参数应满⾜的条件。

若不满⾜，操作失败，返回相应错误信息。

初始条件为空，省略之。

操作结果：操作正常完成，数据结构的变化和返回结果。

2、抽象数据类型的复数例ADTComplex{D: {real, imag | e1,e2为实数}R:{<real, imag>}P: void InitialComplex(Complex &x,float r, float i);赋值参数：初始化复数x，实数r，虚部i；操作结果：设置复数x的实部为r，虚部为i；float GetReal(Complex x);赋值参数：复数x操作结果：返回复数x的实部float GetImag(Complex x);赋值参数：复数x操作结果：返回复数x的虚部void SetReal(Complex &x, float real);赋值参数：操作复数x，将为复数x赋值于实部的real；操作结果：复数x的实部被设置为real；void SetImag (Complex &x, float imag);赋值参数：操作复数x，将为复数x赋值于虚部的imag；操作结果：复数x的虚部被设置为imag；Complex add(Complex x, Complex y);赋值参数：所要相加的两个复数x，y操作结果：返回两个复数x和y的和Complex sub(Complex x, Complex y);赋值参数：所要相减的两个复数x，yComplex multi(Complex x, Complex y);赋值参数：所要相称的两个复数x，y操作结果：返回两个复数x和y积Complex expect(Complex x, Complex y);赋值参数：所要相除的两个复数x，y操作结果：返回两个复数x和y商3、复数基本知识复数基本四则运算：①、复数z1与z2的和的定义：z1+z2=（a+bi）+（c+di）=（a+c）+（b+d）i；②、复数z1与z2的差的定义：z1-z2=（a+bi）-（c+di）=（a-c）+（b-d）i；③、复数的乘法运算规则：设z1=a+bi，z2=c+di（a、b、c、d∈R）是任意两个复数，那么它们的积（a+bi）（c+di）=（ac-bd）+（bc+ad）i，其实就是把两个复数相乘，类似两个多项式相乘，在所得的结果中把i2换成-1，并且把实部与虚部分别合并，两个复数的积仍然是⼀个复数。

数据结构实验报告-线性表

1 线性表1. 实验题目与环境1.1实验题目及要求（1）顺序表的操作利用顺序存储方式实现下列功能：根据键盘输入数据建立一个线性表，并输出该线性表；对该线性表进行数据的插入、删除、查找操作，并在插入和删除数据后，再输出线性表。

（2）单链表的操作利用链式存储方式实现下列功能：根据键盘输入数据建立一个线性表，并输出该线性表；对该线性表进行数据的插入、删除、查找操作，并在插入和删除数据后，再输出线性表。

（3）线性表的应用约瑟夫环问题。

有n个人围坐一圈，现从某个人开始报数，数到M的人出列，接着从出列的下一个人开始重新报数，数到M的人又出列，如此下去，直到所有人都出列为止。

要求依次输出出列人的编码。

2.问题分析（1）顺序表的操作利用一位数组来描述顺序表，即将所有元素一词储存在数组的连续单元中，要在表头或中间插入一个新元素时，需要将其后的所有元素都向后移动一个位置来为新元素腾出空间。

同理，删除开头或中间的元素时，则将其后的所有元素向前移动一个位置以填补空位。

查找元素时，则需要利用循环语句，一一判断直到找出所要查找的元素（或元素的位置），输出相关内容即可（2）单链表的操作利用若干个结点建立一个链表，每个节点有两个域，即存放元素的数据域和存放指向下一个结点的指针域。

设定一个头指针。

在带头结点的单链表中的第i个元素之前插入一新元素，需要计数找到第i-1个结点并由一指针p指向它，再造一个由一指针s指向的结点，数据为x，并使x的指针域指向第i个结点，最后修改第i-1个结点的指针域，指向x结点。

删除第i个元素时，需要计数寻找到第i个结点，并使指针p指向其前驱结点，然后删除第i个结点并释放被删除结点的空间。

查找第i个元素，需从第一个结点开始计数找到第i个结点，然后输出该结点的数据元素。

（3）线性表的应用程序运行之后，首先要求用户指定初始报数的上限值，可以n<=30,此题中循环链表可不设头结点，而且必须注意空表和"非空表"的界限。

实验一线性表操作实验报告

实验一_线性表操作_实验报告实验一：线性表操作一、实验目的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.掌握上机调试线性表的基本方法；2.掌握线性表的一些基本操作；实验内容：将两个有序链表合并为一个有序链表一、需求分析1.实验程序中先创建两个有序链表，演示程序以用户和计算机的对话方式执行，即在计算机终端上显示“提示信息”之后，由用户在键盘上输入两个链表中的相应数据。

2.将两个链表合并时可按数据从大到小或从小到大合并，用户根据提示可选择一种排序方式。

3.程序执行命令包括：（1）构造链表；（2）输入数据；（3）合并两个链表，根据用户需求选择一种排序方式；（4）将合并结果输出；（5）结束4.测试数据：链表1数据为：2，4，6，7，10链表2数据为：1，3，5，6，7，12按从小到达合并为：1，2，3，4，5，6，6，7，7，10，12；按从大到小合并为：12，10，7，7，6，6，5，4，3，2，1；二、概要设计1.基本操作Linklist creat （）操作结果：构造一个链表，并输入数据，返回头节点指针。

void print(Linklist head)初始条件：链表已存在；操作结果：将链表输出。

void MergeList_1(Linklist La,Linklist Lb)初始条件：有序线性链表La 和Lb 已存在；操作结果：将La 和Lb 两个链表按从小到大的顺序合并。

void MergeList_2(Linklist La,Linklist Lb)初始条件：有序线性链表La 和Lb 已存在；操作结果：将La 和Lb 两个链表按从大到小的顺序合并。

2.本程序包括四个模块：（1）主程序模块；（2）链表数据输入模块；（3）链表合并模块；（4）链表输出模块；三、详细设计1.元素类型，节点类型，指针类型主程序模块数据输入按从小到大合并两链表按从大到小合并两链表将新链表输出将新链表输出typedef struct LNode //定义节点{int data;struct LNode *next;}LNode,* Linklist;2.每个模块的分析（1）主函数模块int main(){Linklist head1,head2;int i;printf("请输入链表1数据（由小到大，输入0表示输入结束）：\n");head1=creat(); //创建链表1，将头结点指针返回为head1printf("请输入链表2数据（由小到大，输入0表示输入结束）：\n");head2=creat();printf("请选择排序方式（输入1则从小到达合并，输入其它整数则按从大到小合并）：");scanf("%d",&i); //创建链表2，将头结点指针返回为head2if(i==1) //选择两种排序方式，如果输入1，则合并后按从小到大输出；输入其它数，合成链表按从大到小输出{printf("按小到大将两表合并得：\n");MergeList1(head1,head2); //将创建好的两表的头结点地址head1，head2作为函数参数}else{ printf("按从大到小将两表合并得：\n");MergeList2(head1,head2); //将创建好的两表的头结点地址head1，head2作为函数参数}return 0;}（2）数据输入创建链表模块Linklist creat() //创建链表函数，并将创建链表的头结点指针返回{Linklist head,p,s;int z=1,x;head=(LNode *) malloc(sizeof(LNode));p=head;while(z){scanf("%d",&x);if(x!=0) //输入0表示链表数据输入结束{s=(LNode *)malloc(sizeof(LNode));s->data=x;p->next=s;s->next=NULL;p=s;}elsez=0;}return(head);}（3）合并链表模块，两个函数分别表示两种排序方式，将链表合并后直接在函数中调用链表输出函数void print(Linklist head)将链表输出void MergeList_1(Linklist La,Linklist Lb)//已知链表La和Lb元素都按从小到大排列，将La和Lb合并成新链表，其中元素也按从小到大排列{Linklist pa,pb,pc,Lc;pa = La->next; pb = Lb->next;Lc = pc = La; //把La的头节点作为新建链表Lc的头结点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; //插入剩余段print(Lc); //将链表Lc输出}void MergeList_2(Linklist La,Linklist Lb)//已知链表La和Lb的元素都按从小到大排列，合并La和Lb得到新链表，其中元素按照从大到小的顺序排列{Linklist pa,qa,pb,qb,Lc; //设指针qa,qb,分别作为pa,pb的前驱的指针pa=La->next;pb=Lb->next;Lc=La;Lc->next=NULL;while(pa&&pb){if(pa->data<=pb->data){qa=pa;pa=pa->next;qa->next=Lc->next;Lc->next=qa;}else{qb=pb;pb=pb->next;qb->next=Lc->next;Lc->next=qb;}}while(pa) //如果pa不为空，则将La链的剩余段倒叙插入到头节点的后面{qa=pa;pa=pa->next;qa->next=Lc->next;Lc->next=qa;}while(pb) //如果pb不为空，则将Lb链的剩余段倒叙插入到头结点的后面{qb=pb;pb=pb->next;qb->next=Lc->next;Lc->next=qb;}print(Lc); //将新合成的链表Lc输出}(4)链表输出模块，实现最终链表的输出void print(Linklist head) //链表输出函数，将链表输出{LNode *p;p=head->next;if(head!=NULL)do{printf("%d ",p->data);p=p->next;} while (p);printf("\n");四、程序使用说明及测试结果1.程序使用说明（1）本程序的运行环境为VC6.0；（2）进入演示程序后显示提示信息：请输入链表1数据（由小到大，输入0表示输入结束）：按要求输入数据请输入链表2数据（由小到大，输入0表示输入结束）：按要求输入数据请选择排序方式（输入1则从小到达合并，输入其它整数则按从大到小合并）：输入数据选择合并方式2.测试结果对链表1输入数据2，4，6，7，10，0对链表2输入数据1，3，5，6，7，12，0输入数据选择排序方式：如果输入：1 输出结果为：1，2，3，4，5，6，6，7，7，10，12如果输入：3（整数非1）输出结果为：12，10，7，7，6，6，5，4，3，2，13.调试中遇到的错误分析第一次运行时有问题，看以看出它的排序方式是对的，但是输出是多出前面一个很大的数，可能是输出函数void print(Linklist head)有问题，检查程序：此处逻辑出错，直接将p指针指向head，然后就将p->data输出，因此第一个数是头指针head所对应节点的值，所以可将p=head;改为p=head->next;这样p就指向第一个节点。

数据结构线性表实验报告五篇

数据结构线性表实验报告五篇第一篇：数据结构线性表实验报告实验报告课程名：数据结构实验名：线性表及其操作姓名：班级：学号：撰写时间：2014.09.24一实验目的与要求1.掌握线性表的实现2.掌握线性表的基本操作的实现二实验内容• 分别完成线性表的顺序表示及链式表示• 在两种表示上, 分别实现一些线性表的操作, 至少应该包括–在第i个位置插入一个元素–删除第i个元素–返回线性表长–返回第i个元素的值三实验结果与分析#include #include //---------线性表链式表示-----------struct V//声明一个结构体类型struct V { int value;struct V * next;//定义结构体变量};void PrintLink(struct V*p)//定义一个结构体指针{ while(p!=NULL)//只要指针指向的变量不为NULL；就会一直循环链表指向下一个结构体{printf(“%d, ”,(*p).value);p=(*p).next;//指针指向下一个结构体} printf(“n”);} void Link(){struct V*head;head=(struct V*)malloc(sizeof(struct V));//开辟一个长度为size的内存(*head).value=-100;//表头为-100(*head).next=NULL;printf(“------------线性表链式表示------------n”);int i,n=10;struct V*p=head;printf(“10个数据:n”);for(i=0;i(*p).next=(struct V*)malloc(sizeof(struct V));p=(*p).next;(*p).value=2*i;(*p).next=NULL;} PrintLink(head);//调用PrintLink函数printf(“删除第四个数据:n”);int k=4;p=head;for(i=1;ip=(*p).next;} struct V*temp=(*p).next;//k表示插入和删除的位置(*p).next=(*temp).next;free(temp);PrintLink(head);printf(“插入第十个数据:n”);k=10;p=head;for(i=1;ip=(*p).next;} temp=(*p).next;(*p).next=(struct V*)malloc(sizeof(struct V));(*(*p).next).value=-99;(*(*p).next).next=temp;PrintLink(head);}//---------线性表顺序表示-----------void seq1(){ int i,n=10,k=4;int a[10];//---------输出数组元素------------printf(“-------------线性表顺序表示---------n”);for(i=0;ia[i]=i;} printf(“数组元素为:n”);for(i=0;iprintf(“%3d”,a[i]);} printf(“n”);//--------插入一个数组元素---------int m=n+1,j=12;//插入元素12 int b[20];for(i=0;i if(i{b[i]=a[i];}else if(i==k){b[i]=j;}else{b[i]=a[i-1];} } printf(“输出插入一个元素的数组:n”);for(i=0;i{if(i{c[i]=a[i];}else{c[i]=a[i+1];} } printf(“输出删除一个元素的数组:n”);for(i=0;i printf(“数组元素为:n”);for(i=1;i<=a[0];i++){a[i]=i;} for(i=0;i<2*a[0];i++){printf(“%d,”,a[i]);} printf(“n”);//-----在k 位置插入一个元素------------for(i=a[0];i>=k;i--){a[i+1]=a[i];} a[k]=-100;++a[0];for(i=0;i<2*a[0];i++){printf(“%d,”,a[i]);} printf(“n”);//-------在k---------------for(i=0;i>k;i++){a[i]=a[i+1];} a[k]=-1;a[0]=n;--a[0];for(i=0;i<2*a[0];i++){printf(“%d,”,a[i]);} printf(“n”);} int main(int argc,char *argv[]){ seq1();seq2();Link();return 0;} 图1：实验结果截图实验分析：已在程序中按规定格式标注。

数据结构线性表实验报告

一、实验目的和要求（1）理解线性表的逻辑结构特性。

（2）深入掌握线性表的两种存储方法，即顺序表和链表。

体会这两种存储结构之间的差异。

（3）重点掌握顺序表和链表上各种基本运算的实现。

（4）综合运用线性表解决一些复杂的实际问题。

二、实验内容实验2.1 编写一个程序algo2-1.cpp，实现顺序表的各种基本运算（假设顺序表的元素类型为char）,并在此基础上设计一个程序exp2-1.cpp，完成如下功能：（1）初始化顺序表L；（2）采用尾插法依次插入元素a，b，c，d，e；（3）输出顺序表L;（4）输出顺序表L长度；（5）判断顺序表L是否为空；（6）输出顺序表L的第三个元素；（7）输出元素a的位置；（8）在第4个元素位置上插入元素f；（9）输出顺序表L；（10）删除L的第3个元素；（11）输出顺序表L；（12）释放顺序表L。

实验2.2 编写一个程序algo2-2.cpp，实现单链表的各种基本运算（假设单链表的元素类型为char），并在此基础上设计一个程序exp2-2.cpp，完成如下功能：（1）初始化单链表h；（2）采用尾插法依次插入元素a，b，c，d，e；（3）输出单链表h;（4）输出单链表h长度；（5）判断单链表h是否为空；（6）输出单链表h的第三个元素；（7）输出元素a的位置；（8）在第4个元素位置上插入元素f；（9）输出单链表h；（10）删除L的第3个元素；（11）输出单链表h；、（12）释放单链表h。

释放顺序表L。

实验2.3 编写一个程序algo2-3.cpp，实现双链表的各种基本运算（假设双链表的元素类型为char），并在此基础上设计一个程序exp2-3.cpp，完成如下功能：（1）初始化双链表h；（2）采用尾插法依次插入元素a，b，c，d，e；（3）输出双链表h;（4）输出双链表h长度；（5）判断双链表h是否为空；（6）输出双链表h的第三个元素；（7）输出元素a的位置；（8）在第4个元素位置上插入元素f；（9）输出双链表h；（10）删除L的第3个元素；（11）输出双链表h；、（12）释放双链表h。

数据结构线性表实验报告

数据结构线性表实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构中线性表的基本概念、存储结构和操作算法，并通过实际编程实现来提高对线性表的应用能力和编程技能。

二、实验环境本次实验使用的编程语言为C+＋，开发工具为Visual Studio 2019。

三、实验内容（一）线性表的顺序存储结构顺序表是用一组地址连续的存储单元依次存储线性表的数据元素。

其特点是逻辑上相邻的元素在物理位置上也相邻，便于随机存取，但插入和删除操作需要移动大量元素，效率较低。

（二）线性表的链式存储结构链表是通过指针将一组零散的存储单元链接成一个线性序列。

常见的链表有单链表、双向链表和循环链表。

链表的插入和删除操作只需修改指针，无需移动元素，但随机存取效率较低。

（三）线性表的基本操作实现1、初始化线性表2、销毁线性表3、清空线性表4、判断线性表是否为空5、获取线性表的长度6、获取指定位置的元素7、查找指定元素在线性表中的位置8、在线性表指定位置插入元素9、删除线性表指定位置的元素四、实验步骤（一）顺序表的实现1、定义顺序表的结构体，包括数据存储数组和表的长度。

2、实现顺序表的初始化函数，分配初始存储空间并设置表长度为0。

3、销毁顺序表函数，释放存储空间。

4、清空顺序表函数，将表长度置为 0。

5、判断顺序表是否为空，根据表长度判断。

6、获取顺序表长度，直接返回表长度。

7、获取指定位置元素，检查位置合法性后返回对应元素。

8、查找指定元素位置，遍历表进行比较。

9、插入元素函数，检查插入位置合法性，若合法则移动后续元素，插入新元素并更新表长度。

10、删除元素函数，检查删除位置合法性，若合法则移动后续元素，更新表长度。

（二）链表的实现1、定义链表节点结构体，包含数据域和指针域。

2、实现链表的初始化函数，创建头节点。

3、销毁链表函数，遍历链表释放节点内存。

4、清空链表函数，遍历链表删除节点但保留头节点。

5、判断链表是否为空，检查头节点的指针域是否为空。

数据结构实验报告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、实验结果成功创建并初始化了线性表。