线性表的顺序存储结构_实验报告样例
实验报告 线性表的顺序存储结构
**大学实验报告学院：专业：班级：
实
验
总
结
1、线性表的初始化为一个空表时，要明确给空（l.list==NULL)
2、线性表的插入、删除操作前都要进行非法位置的剔除
3、插入、删除等操作非法时，一定要有返回值（return false），否则操作会出现错误
4、程序编写过程中，要注意细节部分，减少错误的产生，减少调试时间
指
导
教
师
意
见签名：年月日注：各学院可根据教学需要对以上栏木进行增减。
表格内容可根据内容扩充。
（资料素材和资料部分来自网络，供参考。
可复制、编制，期待你的好评与关注）。
数据结构实验报告-线性表(顺序表实现)
实验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.归并顺序表（销毁或清空操作前）七、思考讨论题或体会或对改进实验的建议通过本次实验，我掌握了定义线性表的顺序存储类型，加深了对顺序存储结构的理解，进一步巩固和理解了顺序表的基本操作，如建立、查找、插入和删除等。
数据结构实验线性表的顺序存储结构
南昌航空大学实验报告课程名称：数据结构实验名称：实验一线性表的链式存储结构班级：080611 学生姓名：冯武明学号：16 指导教师评定：XXX 签名: XXX题目：设计并实现以下算法：给出用单链表存储多项式的结构，利用后接法生成多项式的单链表结构，实现两个多项式相加的运算，并就地逆置相加后的多项式链式。
一、需求分析⒈先构造两个多项式链表，实现两个多项式的和及删除值为零元素的操作，不同用户输入的多项式不同。
⒉在演示过程序中，用户需敲击键盘输入值，即可观看结果。
⒊程序执行的命令包括：（1）构造多项式链表A （2）构造多项式链表B （3）求两张链表的和（4）删除值为零元素，即不创建链表。
二、概要设计⒈为实现上述算法，需要线性表的抽象数据类型：ADT Stack {数据对象：D={a i:|a i∈ElemSet,i=1…n,n≥0}数据关系：R1={<a i-1,a i>|a i-1,a i∈D,i=2,…n≥0}基本操作:init(linklist *L)操作结果：destroylist(List *L)clearlist(List *L)初始条件：线性表L已经存在，1≤i≤ListLength(&L)操作结果：用e返回L中第i个数据元素的值。
insfirst(link h,link s)初始条件：数据元素e1,e2存在操作结果：以e1,e2中的姓名项作为判定e1,e2是否相等的依据。
delfirst(link h,link *q)初始条件：数据元素e1,e2存在操作结果：以e1,e2中的姓名项(为字符串)的≤来判定e1,e2是否有≤的关系。
append(linklist *L,link s)初始条件：线性表La已经存在操作结果：判断La中是否有与e相同的元素。
remove(linklist *L,link *q)初始条件：非递减线性表La，Lb已经存在操作结果：合并La，Lb得到Lc，Lc仍按非递减有序排列。
数据结构实验报告-实验：1线性表的顺序存储和操作实现
}
for(inti=pos-1;i<length;i++)
if(listArray[i].equals(obj))returni+1;
return-1;
}
publicbooleanmodify(Object obj,intpos){
if(pos<1||pos>length){
List sort();
}
publicclasssequenceListimplementsList {
finalintmaxSize=10;
privateintlength;
privateObject[]listArray;
publicsequenceList(){//无参数的构造函数的定义
length=0;//线性表初始为空，即长度为0
System.out.println();
list2.preOrder();
System.out.println("线性表list2长度："+list2.size());
}
}
publicinterfaceList {
Object value(intpos);
booபைடு நூலகம்eanadd(Object obj,intpos);
int[] a={20,16,38,42,29};
for(inti=0;i<a.length;i++) list1.add(a[i], i+1);
intn1=(Integer)list1.remove(2);
list1.add(80, 3);
intn2=(Integer)list1.value(4);
数据结构实验报告1线性表的顺序存储结构
数据结构实验报告1线性表的顺序存储结构数据结构实验报告1线性表的顺序存储结构第一章引言线性表是计算机中最常见的数据结构之一，它是一种有序的数据元素集合，其中的数据元素之间具有一对一的关系。
线性表的存储结构有多种方式，其中顺序存储结构是最简单的一种，它使用一段连续的存储单元来存储线性表中的元素。
第二章顺序存储结构的定义顺序存储结构是将线性表中的元素按照其逻辑顺序依次存储在一块连续的存储空间中。
顺序存储结构的特点是可以快速地访问任意位置的元素，但插入和删除操作需要移动大量的元素。
第三章顺序存储结构的实现1.存储空间的分配顺序存储结构通常使用数组来实现，数组的长度应该大于等于线性表的长度，以防止溢出。
存储空间的分配可以使用静态分配或动态分配两种方式来实现。
2.线性表的初始化初始化线性表时，需要设置线性表的长度和当前元素的个数。
3.线性表的增删改查操作●插入操作：________在指定位置插入一个元素时，需要将插入位置之后的元素依次后移，给待插入的元素腾出位置。
●删除操作：________删除指定位置的元素时，需要将删除位置之后的元素依次前移，覆盖删除位置上的元素。
●修改操作：________修改指定位置的元素时，直接对该位置上的元素进行修改即可。
●查找操作：________根据指定的元素值，查找其在顺序存储结构中的位置。
4.线性表的遍历操作遍历操作可以按照顺序访问线性表中的每个元素，可以使用循环结构实现遍历操作。
第四章顺序存储结构的优缺点分析1.优点：________可以快速地访问任意位置的元素，节省存储空间。
2.缺点：________插入和删除操作需要移动大量的元素，不适用于频繁插入和删除的场景。
第五章实验过程和结果分析在本次实验中，我们以顺序存储结构为基础，实现了线性表的增删改查操作，并进行了遍历操作。
通过实验，我们发现顺序存储结构在查询操作上有较好的性能，但在插入和删除操作上的性能较差。
第六章附件本文档涉及的附件详见附件文件。
数据结构实验报告-3-线性表的顺序存储-1
//析构函数为空
int Length();
//求线性表的长度
datatype Get(int i);
//按位查找，取线性表的第 i 个元素
int Locate(datatype item); //查找元素 item
void Insert(int i, datatype item); //在第 i 个位置插入元素 item
cout<<"溢出"<<endl; } if (i<1 || i>length+1) {
cout<<"i 不合法！"<<endl; } for (j=length; j>=i; j--)
data[j]=data[j-1]; data[i-1]=item; length++; } //（5）删除线性表中第 i 个元素算法 /* *输 入：要删除元素位置 i *前置条件：顺序表存在,i 要合法 *功 能：删除顺序表中位置为 i 的元素 *输 出：无 *后置条件： 顺序表册除了一个元素，表长减 1 */ //实现代码： template <class datatype> datatype SeqList<datatype>::Delete(int i) { int item,j; if (length==0) {
cout<<"表为空,无法删除元素!"<<endl; } if (i<1 || i>length)
{ cout<<"i 不合法!"<<endl;
} item=data[i-1];//获得要删除的元素值 for (j=i; j<length; j++)
《线性表的顺序存储》实验报告
《线性表的顺序存储》实验报告1.需解决的的问题利用顺序表，设计一组输入数据。
2.数据结构的定义typedefstruct{ElemType *elem;int length;intlistsize;}SqList;3.程序的结构图4.函数的功能1）初始化一个空顺序表voidInitSqList(SqList *L){L->elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L->elem) exit(OVERFLOW);L->length=0;L->listsize=LIST_INIT_SIZE;}2）输入元素voidPushSqList(SqList *L){inti;printf("input the length of the list:");scanf("%d",&L->length);printf("input the sqlist:");for(i=0;i<L->length;i++){printf("input the %dth number:",i+1);scanf("%d",&L->elem);}}3）在指定位置插入一个指定的元素voidInsertSqList(SqList *L,inti,ElemType x){ElemType *newbase;intn,m;if(i<1||i>L->length+1){printf("ERROR!");}if(L->length>=L->listsize){newbase=(ElemType*)realloc(L->elem,(L->listsize+LISTINCREMENT)*sizeof(ElemType));if(!newbase) exit(OVERFLOW);L->elem=newbase;L->listsize+=LISTINCREMENT;}else{for(n=L->length;n>=i;n--){++L->length;L->elem[n]=L->elem[n-1];}L->elem[i-1]=x;printf("the list is:");for(m=0;m<L->length+1;n++)printf("%d",L->elem[n]);}}4）删除指定位置的元素voidDelSqList(SqList *L,inti){ElemType *p,*q;ElemType x;int n;if(i<1||i>L->length)printf("ERROR!");p=&(L->elem[i-1]);x=*p;for(q=p;q<&(L->elem[L->length-1]);q++)*q=*(q+1);L->length--;printf("the element which is delete is %d",x);printf("the list is:");for(n=0;n<L->length-1;n++)printf("%d",L->elem[n]);}5）将顺序表中所有的元素颠倒voidChangeoverSqList(SqList *L){SqList S;inti,j;if(L->length==L->listsize)S.elem=(ElemType*)malloc(L->length*sizeof(ElemType));if(!S.elem) exit(OVERFLOW);else{for(i=0;i<L->length;i++)S.elem[i]=L->elem[L->length-i-1];for(i=0;i<L->length;i++)L->elem[i]=S.elem[i];}printf("the list is:");for(j=0;j<L->length;i++)printf("%d",L->elem[i]);}6）按顺序输出表中元素voidPrintSqList(SqList *L){inti;for(i=0;i<L->length;i++)printf("%d ",L->elem[i]);}7）摧毁顺序表voidDestroySqList(SqList *L){if(L->elem) free(L->elem);}8）清空顺序表voidClearSqList(SqList *L){L->length=0;}9）查找指定位置的元素，并返回该元素的值intGetElem(SqList *L,inti){ElemType x;if(i<1||i>L->length+1) {printf("ERROR!");}else{x=L->elem[i-1];printf("the elem is %d",x);}}5.输入/输出数据1）创建一个顺序表，先输入表长度，然后输入数据2）选择菜单，进行不同操作选‘1’，在指定位置插入指定元素选‘2’，删除指定位置的元素选‘3’，颠倒顺序表中元素的顺序选‘4’，按顺序输出表中的元素选‘5’，摧毁顺序表选‘6’，清空线性表选‘7’，输出当前顺序表的长度选‘8’，输出指定位置的元素选‘9’，退出该程序6.总结这个实验让我更好的掌握了在线性表的顺序存储中如何初始化，如何进行输入输出的处理，以及各种常用功能是怎样实现的。
数据结构实验报告-线性表的顺序存储
姓 名
专业班级
实验地点
指导教师
实验时间
一、实验目的及要求
本次实验目的是通过上机练习，熟悉和掌握课堂所讲授的基本知识点。要求上机以前要认真复习课堂教学内容。完成教师带领实验，完成线性表的顺序存储实验。
二、实验设备（环境）及要求
计算机；学生不许把食物带到机房吃；不许上网做与实验无关的内容；不许同学之间聊天；保持实验室安静卫生。下课把键盘，座椅放回原处。
Integer length;/*当前线性表长度，线性表中现有元素个数*/
Integer listsize;/*当前分配的存储量以下定义线性表的操作*/
Integer InitList(Class_List *SqList)
/*构造一个空的线性表*/
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
typedef int Integer;
typedef char *String;
typedef struct
{
Integer number;
String name[10];
Integer age;
String interest[50];
完成一个有多于3个学生的线性表。并且显示学生信息。删除其中一个学生。然后再打印显示。
Source.cpp
#include"header.h"
void main()
{
Class_List xinji2013;
InitList(&xinji2013);
Student st;
Integer i,n=2,w,q,e;
三、实验内容与步骤
存储结构描述实验报告
一、实验目的通过本次实验，使学生掌握数据结构中存储结构的基本概念，了解不同存储结构的特点和适用场景，能够根据具体问题选择合适的存储结构，提高编程能力和问题解决能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发环境：Visual Studio 2019三、实验内容1. 线性表的存储结构描述（1）顺序存储结构：使用数组实现线性表的存储结构，通过数组的索引来访问元素。
顺序存储结构具有以下特点：优点：存储密度高，空间利用率高；随机访问速度快。
缺点：插入和删除操作需要移动大量元素，效率较低。
（2）链式存储结构：使用链表实现线性表的存储结构，每个节点包含数据和指向下一个节点的指针。
链式存储结构具有以下特点：优点：插入和删除操作效率高，只需修改指针；支持动态内存分配。
缺点：存储密度低，空间利用率较低；随机访问速度慢。
2. 栈的存储结构描述（1）顺序存储结构：使用数组实现栈的存储结构，栈顶元素位于数组的最后一个位置。
顺序存储结构具有以下特点：优点：存储密度高，空间利用率高；随机访问速度快。
缺点：插入和删除操作需要移动大量元素，效率较低。
（2）链式存储结构：使用链表实现栈的存储结构，每个节点包含数据和指向下一个节点的指针。
链式存储结构具有以下特点：优点：插入和删除操作效率高，只需修改指针；支持动态内存分配。
缺点：存储密度低，空间利用率较低；随机访问速度慢。
3. 队列的存储结构描述（1）顺序存储结构：使用数组实现队列的存储结构，队首元素位于数组的第一个位置，队尾元素位于数组的最后一个位置。
顺序存储结构具有以下特点：优点：存储密度高，空间利用率高；随机访问速度快。
缺点：插入和删除操作需要移动大量元素，效率较低。
（2）链式存储结构：使用链表实现队列的存储结构，队首元素位于链表的第一个节点，队尾元素位于链表的最后一个节点。
链式存储结构具有以下特点：优点：插入和删除操作效率高，只需修改指针；支持动态内存分配。
线性表实验报告
线性表实验报告一、实验目的本次实验的主要目的是深入理解线性表的基本概念和操作，通过实际编程实现线性表的存储和基本运算，掌握线性表在数据结构中的应用，提高对数据结构的理解和编程能力。
二、实验环境本次实验使用的编程语言为C+＋，开发工具为Visual Studio 2019。
三、实验原理线性表是一种最基本、最简单的数据结构，它是由 n（n≥0）个数据元素组成的有限序列。
在这个序列中，每个数据元素的位置是按照其逻辑顺序排列的。
线性表有两种存储结构：顺序存储结构和链式存储结构。
顺序存储结构是用一组地址连续的存储单元依次存储线性表中的数据元素，使得逻辑上相邻的两个元素在物理位置上也相邻。
其优点是可以随机访问表中的任意元素，时间复杂度为 O(1)；缺点是插入和删除操作需要移动大量元素，时间复杂度为 O(n)。
链式存储结构是通过指针将各个数据元素链接起来，每个数据元素由数据域和指针域组成。
其优点是插入和删除操作不需要移动大量元素，时间复杂度为 O(1)；缺点是不能随机访问表中的元素，需要从头指针开始遍历，时间复杂度为 O(n)。
四、实验内容本次实验实现了顺序表和链表的基本操作，包括创建、插入、删除、查找、遍历等。
1、顺序表的实现定义顺序表的结构体，包括数据存储数组和表的长度。
实现顺序表的初始化函数，将表的长度初始化为 0。
实现顺序表的插入函数，在指定位置插入元素，如果插入位置非法或表已满，则返回错误。
实现顺序表的删除函数，删除指定位置的元素，如果删除位置非法，则返回错误。
实现顺序表的查找函数，查找指定元素，如果找到则返回元素的位置，否则返回－1。
实现顺序表的遍历函数，输出表中的所有元素。
2、链表的实现定义链表的结构体，包括数据域和指向下一个节点的指针域。
实现链表的创建函数，创建一个空链表。
实现链表的插入函数，在指定位置插入元素，如果插入位置非法，则返回错误。
实现链表的删除函数，删除指定位置的元素，如果删除位置非法，则返回错误。
顺序存储线性表的基本运算(实验报告)
实验一顺序存储线性表的基本运算一、实验目的1、掌握线性表的定义、顺序存储的方法及基本操作。
2、2掌握将算法在VC++6.0语言环境下实现的过程。
二、实验原理利用线性表的顺序存储结构完成一个班级的一个学期的所有课程成绩的管理，要求实现增加、删除学生的成绩记录等运算。
三、实验仪器和设备1、PC微机２、Microsoft VC++6.0四、预习要求1、复习线性表的定义、线性表的顺序存储结构的定义以及顺序存储线性表的增加、删除元素的算法。
2、掌握顺序存储线性表的C语言的实现。
五、实验内容及步骤编写程序如下：#include <stdio.h>#include <stdlib.h>#include <string.h>#define Max_length 3typedef struct{int xh; /*学号*/char name[35]; /*姓名*/int c1,c2,c3; /*三门课程成绩*/} Element;/*删除第i个学生的记录算法*/int Delete_list(int i,Element s[ ] ,int *n_pointer){int j,n;n=*n_pointer;if((i<1) ||(i>n))return(0);for (j=i+1;j<=n;j++){/*移动*/s[j-1].xh=s[j].xh;// strcopy(s[j-1].name,s[j].name);s[j-1].name,s[j].name;s[j-1].c1=s[j].c1;s[j-1].c2=s[j].c2;s[j-1].c3=s[j].c3;}n--;*n_pointer=n;return (1);}/*查找学号为x的算法*/int Locate_list (Element s[ ], int n, int x){int i;for(i=1;i<=n;i++)if (s[i].xh==x)return (i);return (0);}/*修改学号为i的学生的记录函数*/int Change_list (int i, Element s[ ] ){if( (i<1) || (i>Max_length +1) ) return (0);printf ("Input data for updating :\n");scanf ("%d%s%d%d%d",s[i].xh,s[i].name,s[i].c1,s[i].c2,s[i].c3);return (1);}/*打印已建立的数据记录，n是记录总数*/void printf_list (Element s[ ],int n){int i;if(n>Max_length) return ;printf ("XH Name C1 C2 C3 \n");printf("--------------------------------------------\n");for(i=1;i<=n;i++)printf ("%4d%10s%7d%7d%7d\n",s[i].xh,s[i].name,s[i].c1,s[i].c2,s[i].c3); }/*在第i个记录的后面插入一个学生的记录算法*/int Insert_list (int i,Element s[ ],int *n_pointer){/*n_pointe存放已输入的最大记录数*/int j,n;n=*n_pointer;if((n== Max_length) || (i<1) || (i>n+1)) return (0);for(j=n;j>=1;j--) s[j+1]=s[j]; /*移动*/printf("Input Data for inserting (XH Name C1 C2 C3) \n");scanf("%d%s%d%d%d",&s[i].xh,&s[i].name,&s[i].c1,&s[i].c2,&s[i].c3);n++;*n_pointer=n;return (1);}void main ( ){int i, records=0;Element s[Max_length];/*创建线性表*/for (i=1;i<=Max_length;i++)Insert_list ( i, s, &records);/*创建线性表*/printf_list (s, records); /*显示学生记录内容*/}上机调试、运行源程序。
线性表的实验报告
线性表的实验报告线性表的实验报告概述：线性表是一种常见的数据结构，它是由一组具有相同数据类型的元素组成的序列。
本次实验旨在通过实际操作线性表，掌握线性表的基本操作以及了解其应用场景。
实验目的：1. 理解线性表的概念和基本操作；2. 掌握线性表的顺序存储结构和链式存储结构；3. 熟悉线性表的常见应用场景。
实验材料：1. 计算机；2. 编程软件（如C、C++、Java等）；3. 实验教材或参考资料。
实验步骤：一、线性表的顺序存储结构实验1. 创建一个空的线性表；2. 向线性表中插入若干元素；3. 删除线性表中的某个元素；4. 根据索引查找线性表中的元素；5. 遍历线性表，输出所有元素。
二、线性表的链式存储结构实验1. 创建一个空的链表；2. 向链表中插入若干节点；3. 删除链表中的某个节点；4. 根据节点值查找链表中的节点；5. 遍历链表，输出所有节点。
实验结果：1. 顺序存储结构实验结果：- 成功创建空的线性表；- 成功插入若干元素；- 成功删除某个元素；- 成功根据索引查找元素；- 成功遍历线性表，输出所有元素。
2. 链式存储结构实验结果：- 成功创建空的链表；- 成功插入若干节点；- 成功删除某个节点；- 成功根据节点值查找节点；- 成功遍历链表，输出所有节点。
实验分析：1. 顺序存储结构适用于元素个数固定或变化不大的情况，插入和删除操作需要移动大量元素，效率较低；2. 链式存储结构适用于元素个数不固定的情况，插入和删除操作只需修改指针，效率较高；3. 线性表的应用场景包括但不限于：图书馆图书管理系统中的图书列表、学生信息管理系统中的学生列表等。
实验总结：通过本次实验，我深入了解了线性表的概念、基本操作以及两种常见存储结构。
顺序存储结构适用于元素个数固定的情况，而链式存储结构适用于元素个数不固定的情况。
线性表在实际应用中有着广泛的应用场景，如图书馆管理系统、学生信息管理系统等。
在以后的学习和工作中，我将灵活运用线性表，为解决实际问题提供便利。
实验二-顺序存储的线性表实验报告
实验二-顺序存储的线性表实验报告宁波大红鹰学院实验报告实验名称：实验二顺序存储的线性表学院：信息工程学院专业：信息管理与信息系统年级：2012级小组成员1：于益锋学号：1211060544 职责：编程和报告设计小组成员2：学号：职责：小组成员3：学号：职责：实验时间：年月日实验类型：综合性实验地点：XX—405 成绩：指导教师签字：实验报告基本内容要求：一、实验目的和要求；二、实验内容和原理；三、主要仪器设备；四、操作方法与实验步骤；五、实验数据记录和处理；六、实验结果与分析；七、讨论、心得一、实验目的1．复习并掌握算法设计的要点2．了解线性表的逻辑结构特性，以及这种特性在计算机内的两种存储结构。
3. 重点是线性表的基本操作在两种存储结构上的实现；本次实验以顺序存储的操作为侧重点；并进一步学习结构化的程序设计方法。
二、实验内容1、课堂讨论1)数据结构是抽象的一种组织，是由数据类型组织成的。
数据类型是组成数据结构的元素。
2)线性结构是最简单最常用的一种数据结构,线性结构的特点是结构中的元素之间满足线性关系,按这个关系可以把所有元素排成一个线性序列.线性表,串,栈和队列都属于线性结构.而非线性结构是指在该类结构中至少存在一个数据元素,它具有两个或者两个以上的前驱或后继.如树和二叉树等3)目的是评价算法的效率，通过评价可以选用更加好更加适合的算法来完成4) O(m*n);O(n²)三、主要仪器设备计算机四、实验步骤（将2、3的源程序粘贴进来）2.#include<stdio.h>#define MAXSIZE 20typedef struct{int a[MAXSIZE];int length;}SeqList;int main(){int i=0,x;int min;printf("请输入原始数据（输入0表示结束）:\n");while(1){scanf("%d",&x);if(x==0)break;else L.a[i]=x;i++;}L.length=i;min=L.a[0];for(i=1;i<L.length;i++)if(min>L.a[i])min=L.a[i];printf("这%d个数中最小的数为：%d\n",L.length,min); }3.#include<stdio.h>#define MAXSIZE 20typedef struct{int a[MAXSIZE];int length;}SeqList;int main(){int i=0,j,x;int min;printf("请输入原始数据（输入0表示结束）:\n");while(1){scanf("%d",&x);if(x==0)break;else L.a[i]=x;i++;}L.length=i;printf("请输入需要删除的元素:");scanf("%d",&x);for(i=0;i<L.length;i++)if(L.a[i]==x){for(j=i;j<L.length-1;j++)L.a[j]=L.a[j+1];L.length--;i--;}printf("删除元素后的顺序表为:\n");for(i=0;i<L.length;i++)printf("%d",L.a[i]);}五、实验结果（写出1的题目及答案，粘贴2、3的截图。
线性表的顺序存储结构_实验报告样例
线性表的顺序存储结构_实验报告样例年南昌航空大学实验报告（用实验报告纸，手写）课程名称：数据结构实验名称：实验一线性表的顺序存储结构班级： 080611 学生姓名：赖凌学号： 08061101 指导教师评定：签名:题目：有两张非递减有序的线性学生表A，B，采用顺序存储结构，两张表合并用c表存，要求C仍为非递减有序的，并删除C中值相同的表。
一、需求分析⒈本演示程序根据已有的6位学生的信息，实现两张表的合并及删除值相同元素的操作，不需要用户重新输入学生的信息。
⒉在演示过程序中，用户敲击键盘，即可观看演示结果。
⒊程序执行的命令包括：（1）构造线性表A （2）构造线性表B （3）求两张表的并（4）删除C中值相同的元素二、概要设计⒈为实现上述算法，需要线性表的抽象数据类型：ADT Stack {数据对象：D={a i:|a i∈ElemSet,i=1…n,n≥0}数据关系：R1={|a i-1,a i∈D,i=2,…n≥0}基本操作:init(list *L)操作结果：构造一个空的线性表L。
ListLength(List *L)初始条件：线性表L已经存在操作结果：返回L中数据元素的个数。
GetElem(List L, int i, ElemType *e)初始条件：线性表L已经存在，1≤i≤ListLength(&L)操作结果：用e返回L中第i个数据元素的值。
EqualList(ElemType *e1,ElemType *e2)初始条件：数据元素e1,e2存在操作结果：以e1,e2中的姓名项作为判定e1,e2是否相等的依据。
Less_EquaList(ElemType *e1,ElemType *e2)初始条件：数据元素e1,e2存在操作结果：以e1,e2中的姓名项(为字符串)的≤来判定e1,e2是否有≤的关系。
LocateElem(List *La,ElemType e,int type)初始条件：线性表La已经存在操作结果：判断La中是否有与e相同的元素。
实验二 线性表(顺序存储)
实验二线性表(顺序存储)一、实验目的1. 了解线性表的逻辑结构特性，以及这种特性在计算机内的两种存储结构。
2. 重点是线性表的基本操作在两种存储结构上的实现；本次实验以顺序存储的操作为侧重点；并进一步学习结构化的程序设计方法。
二、实例1. 线性表的顺序存储表示（结构）及实现。
阅读下列程序请注意几个问题：（1）关于线性表的顺序存储结构的本质是：在逻辑上相邻的两个数据元素a i-1, a i，在存储地址中也是相邻的,既地址连续。
不同的教材有不同的表示，有的直接采用一维数组，这种方法有些过时。
有的采用含‘动态分配’一维数组的结构体，这种方法过于灵活抽象（对读者要求过高）。
我们采用的是含‘静态’一维数组和线性表长的结构体：typedef struct{ ElemType a[MAXSIZE]; /* 一维数组子域 */int length; /* 表长度子域 */}SqList; /* 顺序存储的结构体类型 */（2）本程序是一个完整的、子函数较多的源程序。
目的为学生提供一个示范，提供顺序存储表示的资料，供学生参考。
比如，主函数中简单“菜单设计”(do-while循环内嵌套一个 switch结构)技术。
在学习数据结构的初级阶段，并不强要求学生一定使用“菜单设计”技术，同学们可以在main()函数中直接写几个简单的调用语句，就象前面的复数处理程序中的main()一样。
但是随着学习的深入，尽早学会使用“菜单设计”技术，会明显提高编程和运行效率。
[源程序]（略）三、实验题1. 一个线性表有n个元素（n<MAXSIZE, MAXSIZE指线性表的最大长度），且递增有序。
现有一元素x要插入到线性表的适当位置上，并保持线性表原有的顺序不变。
设计程序实现。
要求：采用顺序存储表示实现；提示：请按照如下顺序实现本题功能：第一步：创建顺序表，并输出原始数据第二步：排序，输出排好序的线性表第三步：输入要插入的元素x第四步：将x插入已排序的线性表中，使线性表仍然有序第五步：输出最终结果要求：1、70分程序//事先直接给定有序表#include<stdio.h>#define MAXSIZE 50typedef struct{int a[MAXSIZE];int length;}List;void main(){List L;int i,j;int x;L.length=10;for(i=0;i<10;i++)L.a[i]=2*i;printf("事先给定的有序表为(当前表长为10)：\n");for(i=0;i<L.length;i++)printf("%4d",L.a[i]);printf("\n请输入一个数x");scanf("%d",&x);for(i=9;i>=0;i--){if(x<L.a[i])L.a[i+1]=L.a[i];else{L.a[i+1]=x;//printf("%d",L.a[i]);++L.length;break;}}for(i=0;i<L.length;i++)printf("%4d",L.a[i]);}2、80分程序：//事先直接给定有序表,用函数实现数据元素x的插入#include<stdio.h>#define MAXSIZE 50typedef struct{int a[MAXSIZE];int length;}List;void Insert(List *L,int x);void main(){List L;int i,j;int x;L.length=10;for(i=0;i<10;i++)L.a[i]=2*i;printf("事先给定的有序表为(当前表长为10)：\n");for(i=0;i<L.length;i++)printf("%4d",L.a[i]);printf("\n");//以下程序段请填空完成：现有一元素x要插入到线性表的适当位置上，并保持线性表原有的顺序不变。
数据结构线性表实验报告
数据结构线性表实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构中线性表的基本概念、存储结构和操作算法，并通过实际编程实现来提高对线性表的应用能力和编程技能。
二、实验环境本次实验使用的编程语言为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、实验结果成功创建并初始化了线性表。
线性表的顺序存储结构实验报告样例
年南昌航空大学实验报告（用实验报告纸，手写）课程名称：数据结构实验名称：实验一线性表的顺序存储结构班级： 08061 1 学生姓名：赖凌学号： 08061101 指导教师评定：签名:题目：有两张非递减有序的线性学生表A，B，采用顺序存储结构，两张表合并用c表存，要求C仍为非递减有序的，并删除C中值相同的表。
一、需求分析⒈本演示程序根据已有的6位学生的信息，实现两张表的合并及删除值相同元素的操作，不需要用户重新输入学生的信息。
⒉在演示过程序中，用户敲击键盘，即可观看演示结果。
⒊程序执行的命令包括：（1）构造线性表A（2）构造线性表B（3）求两张表的并（4）删除C中值相同的元素二、概要设计⒈为实现上述算法，需要线性表的抽象数据类型：ADT Stack{数据对象：D={ai :|ai∈ElemSe t,i=1…n,n≥0}数据关系：R1={<ai-1,ai>|ai-1,ai∈D,i=2,…n≥0}基本操作:init(list *L)操作结果：构造一个空的线性表L。
ListLe ngth(List *L)初始条件：线性表L已经存在操作结果：返回L中数据元素的个数。
GetEle m(List L, int i, ElemTy pe *e)初始条件：线性表L已经存在，1≤i≤ListLe ngth(&L)操作结果：用e返回L中第i个数据元素的值。
EqualL ist(ElemTy pe *e1,ElemTy pe *e2)初始条件：数据元素e1,e2存在操作结果：以e1,e2中的姓名项作为判定e1,e2是否相等的依据。
Less_E quaLi st(ElemTy pe *e1,ElemTy pe *e2)初始条件：数据元素e1,e2存在操作结果：以e1,e2中的姓名项(为字符串)的≤来判定e1,e2是否有≤的关系。
线性表的顺序存储结构实验报告总结
线性表的顺序存储结构实验报告总结一、目的1.做实验的目的加深对线性表的理解，学会定义线性表的存储结构，掌握线性表的基本操作。
2.撰写实验报告的目的对本次实验情况进行总结,加强对实验内容的理解,对实验过程有一-个系统的认识，从中获得本次试验的经验，并对实验结果进行适当的分析,加深对栈和队列的理解和认识。
二、内容1.说明实验次数及实验内容本次实验用一次实验课时完成实验内容:节点定义:typedef struct node{int idx: int age: struct node *next:}Node, *List;本次实验的对象的存储内容包括功D和AGE,所以定义了如上的结构体，idx用于存储ID号，age用于存储年龄，next用于形成链式结构，Node定义了该类型的一一个节点，List定义了该类型的--个链表。
(1)、编写函数CreateList ()和PrintList(),从给定数组创建链表,打印链表。
int idx[8] = {1,2,3,4,5,6, 7,8}:int age[8] = {15, 18, 13, 22, 50, 18, 30, 20} :List CreatList(int idx[]，int age[], int 1en) {}int PrintList(List L) {}(2)、编写函数DeleteNode(List L, int delete_ age)，完成以下操作。
int DeleteNodeAge(List L, intdelete_ age) {}该函数传入List L,可以直接修改链表的节点，建议返回值为int 或void类型，无需为List类型，3,题同上。
2.1删除年龄为18的成员，打印链表。
2.2删除年龄为20的成员，打印链表。
2.3删除年龄为15的成员，打印链表。
2.4 (可选)删除年龄为21的成员(因无此成员，报错) ,打印链表。
.(3)、编写函数Inser tNodeByIdx(List L, Node nd)，完成以下操作。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
年南昌航空大学实验报告（用实验报告纸，手写）课程名称：数据结构实验名称：实验一线性表的顺序存储结构班级： 080611 学生姓名：赖凌学号： 08061101 指导教师评定：签名:题目：有两张非递减有序的线性学生表A，B，采用顺序存储结构，两张表合并用c表存，要求C仍为非递减有序的，并删除C中值相同的表。
一、需求分析⒈本演示程序根据已有的6位学生的信息，实现两张表的合并及删除值相同元素的操作，不需要用户重新输入学生的信息。
⒉在演示过程序中，用户敲击键盘，即可观看演示结果。
⒊程序执行的命令包括：（1）构造线性表A （2）构造线性表B （3）求两张表的并（4）删除C中值相同的元素二、概要设计⒈为实现上述算法，需要线性表的抽象数据类型：ADT Stack {数据对象：D={a i:|a i∈ElemSet,i=1…n,n≥0}数据关系：R1={<a i-1,a i>|a i-1,a i∈D,i=2,…n≥0}基本操作:init(list *L)操作结果：构造一个空的线性表L。
ListLength(List *L)初始条件：线性表L已经存在操作结果：返回L中数据元素的个数。
GetElem(List L, int i, ElemType *e)初始条件：线性表L已经存在，1≤i≤ListLength(&L)操作结果：用e返回L中第i个数据元素的值。
EqualList(ElemType *e1,ElemType *e2)初始条件：数据元素e1,e2存在操作结果：以e1,e2中的姓名项作为判定e1,e2是否相等的依据。
Less_EquaList(ElemType *e1,ElemType *e2)初始条件：数据元素e1,e2存在操作结果：以e1,e2中的姓名项(为字符串)的≤来判定e1,e2是否有≤的关系。
LocateElem(List *La,ElemType e,int type)初始条件：线性表La已经存在操作结果：判断La中是否有与e相同的元素。
MergeList(List *La,List *Lb,List *Lc)初始条件：非递减线性表La，Lb已经存在操作结果：合并La，Lb得到Lc，Lc仍按非递减有序排列。
UnionList(List *La ,List *Lb)初始条件：线性表La，Lb已经存在操作结果：将所有在Lb而不在La中的元素插入到La中表尾的位置。
PrintList(List L)初始条件：线性表L已经存在操作结果：打印出表L。
ListInsert(List *L, int i, struct STU e)初始条件：线性表L已经存在，1≤i≤ListLength(&L)+1操作结果：在表L中第i个位置前插入元素e，L的长度加1。
}ADT List2. 本程序有三个模块：⑴主程序模块void main(){初始化；{接受命令；显示结果；｝｝⑵线性表单元模块：实现线性表抽象数据类型；⑶结点结构单元模块：定义线性表中的结点结构。
三、详细设计⒈元素类型，结点类型struct STU{char name[20]; //学生名字、学号、年龄、分数char stuno[10];int age;int score;};typedef struct STU ElemType; //元素类型struct LIST{ElemType *elem;int length; //表的长度、大小int listsize;};typedef struct LIST list; //结点类型2.对抽象数据类型中的部分基本操作的伪码算法如下：int init(List *L){L→elem=(ElemType *)malloc(sizeof(ElemType)*LIST_INIT_SIZE);If(!L→elem) exit (OVERFLOW);L→length=0;L→listsize= LIST_INIT_SIZE;Return OK;}//初始化表int ListLength(List *L){return L→length;}//返回表长void GetElem(List L, int i, ElemType *e){*e=L.elem[i];} //返回元素int locateElem(List *La, ElemType e, int type){int I;switch(type) //确定元素在表中的位置{case EQVAL;for(i=0;i<La→length;i++)if(EqualList(&La→elem[i],&e))return 1;break;default;break;}return 0;}void MergeList(List *La, List *Lb, List *Lc){ //将两个表合并成Lc ElemType *pa,*pb,*pc,*pa_last,*pb_last;Pa=La→elem;pb=Lb→elem;Lc→Listsize=Lc→length=La→length+Lb→length;Pc=Lc→elem==(ElemType *)malloc(Lc→listsize*sizeof(ElemType));if (!Lc→elem) exit(OVERFLOW);pa_last=La→elem+La→length-1;pb_last=Lb→elem+Lb→length-1;while (pa<=pa_last&&pb<=pb_last){if (Less_EqualList(pa,pb)) *pc++=*pa++;else *pc++=*pb++;}while (pa<=pa_last) *pc++=*pa++;while (pb<=pb_last) *pc++=*pb++;}void UnionList(List *La, List *Lb){La_len=ListLength(La);Lb_len=ListLength(Lb);For(i=0;i<Lb_len;i++){GetElem(*Lb,i,&e);If (!LocateElem(La,e,EQUAL))ListInsert(La,++La_len,e);}}int ListInset(List *L,int i,struct STU e){ //将元素插入表Ｌ中if(i<1||i>L→length+1) return ERROR;q=&(L→elem[i-1]);for(p=L→elem[L→length-1];p>=q;p--)*(p+1)=*p;*q=e;++(L→length);return OK;}//ListInsert Before i3.主函数和其他函数的伪码算法void main(){Initialization();//初始化ReadCommand(cmd);//读入一个操作符MakeList(La);printList(La);//产生并打印LaMakeList(Lb);printList(Lb);// 产生并打印LbOperateList(La,Lb);}void Initialization(){//系统初始化clrscr();}int ReadCommand(cmd)//任意键入一个字符{cmd=getch();return 1;}void MakeList(La){ListInsert(&La,i,e);}void OperateList(La,Lb){MergeList(&La,&Lb,&Lc);UnionList(&La,&Lb);}4 函数调用关系Less_EqualListInit ListInsert LocateElemEqualList四、调试分析⒈刚开始输入时，漏掉了一些变量参数的标记"&"，有的则错加了"&"，使得程序运行出来的结果不正确，使调试程序时费时不少。
⒉程序采用逐个输入的方法创建La,Lb,在元素较多时，会使得程序很庞大，不利于检查错误等。
⒊算法的时空分析各操作的算法时间复杂度比较合理init,ListLength,GetElem,EqualList,Less_EqualList为O(1)LocateElem,ListInsert,printList为O(n),UnionList为O(mn),MergeList为O(n)。
4.本次实验采用数据抽象的程序设计方法，将程序化为三层次结构，设计时思路清晰，使调试也较顺利，各模块有较好的可重用性。
五、用户手册⒈本程序的运行环境为windows xp操作系统，执行文件为Exp1Prb1.c；⒉进入演示程序后，完成编译，连接（即同时按下Ctrl F9）进入演示界面，用户键入任一符号，都能看完整个演示过程。
六、测试结果(1)同时键入Ctrl F9，演示为：-----------------List Demo is running--------------First is InsertList functionname stuno age scorestu1 100001 80 1000stu3 100002 80 1000(2)键入任意字符，演示为：name stuno age scorestu1 100001 80 1000stu3 100002 80 1000stu5 100003 80 1000List A length now is 3.(3)键入任意字符，演示为：name stuno age scorestu2 100001 80 1000stu4 100002 80 1000stu6 100001 80 1000List B length now is 3.(4)键入任意字符，演示为：name stuno age scorestu1 100001 80 1000stu2 100001 80 1000stu3 100002 80 1000stu4 100002 80 1000stu5 100003 80 1000stu6 100001 80 1000Second is UnionList function.Now union List A and List B...name stuno age scorestu1 100001 80 1000stu2 100002 80 1000stu3 100003 80 1000stu4 100001 80 1000stu5 100002 80 1000stu6 100001 80 1000List A length now is 6.(5) 键入任意字符，退出演示界面，回到编辑状态。