实验报告1(顺序表)
数据结构实验一顺序表实验报告

数据结构实验一顺序表实验报告
数据结构是计算机科学中的一门基础课程,在学习数据结构的过程中,顺序表是我们必须深入了解和掌握的重要数据结构之一。
在实验一中,我们对顺序表进行了一系列的操作,实现了增删改查等基本操作。
我们先来介绍一下顺序表的基本概念。
顺序表是将线性表中的数据存储在一段连续的存储空间中的数据结构,其查找效率高,但插入和删除操作效率较低。
顺序表需要预先分配一定的存储空间,当存储空间不足时需要进行动态扩容,即重新申请更大的存储空间并将原有数据复制到新的存储空间中。
在实验中,我们首先学习了顺序表的实现方式,包括顺序表的结构体定义、创建顺序表、插入元素、删除元素、修改元素以及查询元素等基本操作。
我们通过 C 语言来实现了这些操作,并将其封装成一个顺序表的 API,使其更加易于使用和维护。
在实验过程中,我们还发现顺序表中数据的存储顺序非常重要,因为顺序表中元素的存储顺序与元素的下标是一一对应的,如果存储的顺序错误,可能会导致元素的下标与我们想象中的不一致,从而造成一些意想不到的结果。
总的来说,实验一帮助我们更深入地了解了顺序表的实现方式和基本操作,同时也挖掘出了一些潜在问题,这对于我们今后的学习和实践都起到了很大的帮助。
顺序表实验报告

顺序表实验报告
摘要:
一、实验背景及目的
二、实验对象与方法
三、实验结果与分析
四、实验总结与建议
正文:
一、实验背景及目的
随着科技的不断发展,顺序表在各种领域的应用越来越广泛。
为了进一步了解顺序表的性能和特点,本实验对顺序表进行了相关测试。
实验旨在通过对比分析,评估顺序表在不同条件下的表现,为后续研究与应用提供参考依据。
二、实验对象与方法
1.实验对象:某品牌顺序表产品
2.实验方法:
(1)根据实验需求,制定实验方案,明确实验步骤与评价标准;
(2)将顺序表产品置于不同环境下,如高温、低温、湿度等,观察其性能变化;
(3)通过数据记录与分析,评估顺序表在不同环境下的稳定性、可靠性和适用性。
三、实验结果与分析
1.顺序表在不同环境下的性能表现:
(1)在高温环境下,顺序表表现稳定,数据传输速率较快;
(2)在低温环境下,顺序表仍能正常工作,性能略有下降;
(3)在湿度较大的环境下,顺序表出现一定程度的性能波动,但整体表现良好。
2.分析:
(1)顺序表在不同环境下性能表现差异较小,说明产品具有较强的适应性;
(2)在湿度较大环境下,性能略有波动,可能与产品内部结构有关,需进一步优化;
(3)实验结果符合预期,顺序表产品具备较好的稳定性和可靠性。
数据结构实验报告-线性表(顺序表实现)

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

《数据结构》实验报告一系别:班级:学号:姓名:日期:指导教师:一、上机实验的问题和要求:顺序表的查找、插入与删除。
设计算法,实现线性结构上的顺序表的产生以及元素的查找、插入与删除。
具体实现要求:从键盘输入10个整数,产生顺序表,并输入结点值。
从键盘输入1个整数,在顺序表中查找该结点的位置。
若找到,输出结点的位置;若找不到,则显示“找不到”。
从键盘输入2个整数,一个表示欲插入的位置i,另一个表示欲插入的数值x,将x插入在对应位置上,输出顺序表所有结点值,观察输出结果。
从键盘输入1个整数,表示欲删除结点的位置,输出顺序表所有结点值,观察输出结果。
二、程序设计的基本思想,原理和算法描述:(包括程序的结构,数据结构,输入/输出设计,符号名说明等)三、源程序及注释:#include <stdio.h>/*顺序表的定义:*/#define ListSize 100 /*表空间大小可根据实际需要而定,这里假设为100*/ typedef int DataType; /*DataType可以是任何相应的数据类型如int, float或char*/ typedef struct{ DataType data[ListSize]; /*向量data用于存放表结点*/int length; /*当前的表长度*/}SeqList;/*子函数的声明*/void CreateList(SeqList * L,int n); /*创建顺序表函数*/int LocateList(SeqList L,DataType x); /*查找顺序表*/void InsertList(SeqList * L,DataType x,int i); /*在顺序表中插入结点x*/void DeleteList(SeqList * L,int i);/*在顺序表中删除第i个结点*/void PrintList(SeqList L,int n); /*打印顺序表中前n个结点*/void main(){SeqList L;int n=10,x,i; /*欲建立的顺序表长度*/L.length=0;/*调用创建线性表函数*/printf("create function:\n");CreateList(&L,n); /*建立顺序表*/PrintList(L,n); /*打印顺序表*//*调用查找函数*/printf("search function:\n");printf("input the data you want to search:");scanf("%d",&x);i=LocateList(L,x); /*顺序表查找*/if (i==0)printf("sorry,don't find %d!\n\n",x);elseprintf("i have find the %d,it locate in %d!\n\n",x,i);/*调用插入函数*/printf("Insert function:\n");printf("输入要插入的位置:(input the position:)");scanf("%d",&i);printf("输入要插入的元素:(input the data:)");scanf("%d",&x);InsertList(&L,x,i); /*顺序表插入 */PrintList(L,n); /*打印顺序表 *//*调用删除函数*/printf("delete function:\n");printf("输入要删除的位置:(input the position:)");scanf("%d",&i);DeleteList(&L,i); /*顺序表删除 */PrintList(L,n); /*打印顺序表 */}/*顺序表的建立:*/void CreateList(SeqList *L,int n){ int i;for (i=0;i<n;i++){ printf("\ninput the %d data:",i+1);scanf("%d",&(*L).data[i]);}(*L).length=n;}/*顺序表的查找:*/int LocateList(SeqList L,DataType x){ int i=0;while (i<L.length&&x!=L.data[i])++i;if (i<L.length) return i+1;else return 0;}/*顺序表的插入:*/void InsertList(SeqList *L,DataType x,int i){/*将新结点x插入L所指的顺序表的第i个结点的位置上 */ int j;if (i<0||i>(*L).length){printf("插入位置非法");exit(0);}if ((*L).length>=ListSize){printf("表空间溢出,退出运行");exit(0);}for (j=(*L).length-1;j>=i-1;j--)(*L).data[j+1]=(*L).data[j]; /*顺序表元素从后向前依次后移*/ (*L).data[i-1]=x; /*将x插入第i个结点位置*/(*L).length++; /*表长自增1*/}/*顺序表的删除:*/void DeleteList(SeqList *L,int i){/*从L所指的顺序表中删除第i个结点 */int j;if (i<0 || i>(*L).length){printf("删除位置非法");exit(0);}for (j=i;j<=(*L).length-1;j++)(*L).data[j]=(*L).data[j+1]; /*顺序表自第i个结点开始,依次前移*/ (*L).length--; /*表长自减1*/}/*顺序表的打印:*/void PrintList(SeqList L,int n){ int i;printf("the sequal list data is:");for (i=0;i<n;i++)printf("%d ",L.data[i]);printf("\n\n");}四、运行输出结果:五、调试和运行程序过程中产生的问题及采取的措施:六、对算法的程序的讨论、分析,改进设想,其它经验教训:七、对实验方式、组织、设备、题目的意见和建议:。
顺序表的操作实验报告

顺序表的操作实验报告顺序表的操作实验报告一、引言顺序表是一种常见的数据结构,它在计算机科学中被广泛应用。
本实验旨在通过实际操作顺序表,探索其基本操作和性能。
二、实验目的1. 理解顺序表的基本原理和数据结构;2. 掌握顺序表的插入、删除、查找等操作;3. 分析顺序表操作的时间复杂度。
三、实验过程1. 初始化顺序表:首先,我们创建一个空的顺序表,并设定其初始长度为10。
2. 插入元素:在顺序表中插入若干个元素,观察插入操作的效果。
我们可以通过在表尾插入元素,或者在表中间插入元素来测试插入操作的性能。
3. 删除元素:从顺序表中删除指定位置的元素,并观察删除操作的效果。
我们可以选择删除表尾元素或者表中间元素来测试删除操作的性能。
4. 查找元素:在顺序表中查找指定元素,并返回其位置。
我们可以选择查找表头元素、表尾元素或者表中间元素来测试查找操作的性能。
5. 扩容操作:当顺序表的长度不足以容纳更多元素时,我们需要进行扩容操作。
在实验中,我们可以在插入元素时观察到扩容操作的效果。
四、实验结果与分析1. 初始化顺序表:成功创建了一个长度为10的空顺序表。
2. 插入元素:通过在表尾插入10个元素,我们观察到插入操作的时间复杂度为O(1)。
然而,当我们在表中间插入元素时,需要将插入位置之后的所有元素后移,时间复杂度为O(n)。
3. 删除元素:从表尾删除元素的时间复杂度为O(1),而从表中间删除元素需要将删除位置之后的所有元素前移,时间复杂度为O(n)。
4. 查找元素:在顺序表中查找元素的时间复杂度为O(n),因为需要逐个比较每个元素。
5. 扩容操作:当顺序表的长度不足以容纳更多元素时,我们需要进行扩容操作。
在实验中,我们观察到扩容操作的时间复杂度为O(n),因为需要将原有元素复制到新的更大的空间中。
五、实验总结通过本次实验,我们深入了解了顺序表的基本操作和性能。
顺序表的插入、删除和查找操作的时间复杂度与操作位置有关,需要注意选择合适的操作位置以提高效率。
实验一顺序表的基本操作实验报告

元素之后的所有数据都前移一个位置,最将线性表长减1。
3.顺序表查找操作的基本步骤:要在顺序表中查找一个给定值的数据元素则可以采用顺序查找的方法,从表中第 1 个数据元素开始依次将值与给定值进行比较,若相等则返回该数据元素在顺序表中的位置,否则返回0 值。
线性表的动态分配顺序存储结构—C语言实现#define MaxSize 50//存储空间的分配量Typedef char ElemType;Typedef struct{ElemType data[MaxSize];int length; //表长度(表中有多少个元素)}SqList;动态创建一个空顺序表的算法:void InitList(SqList *&L) //初始化线性表{L=(SqList *)malloc(sizeof(SqList)); //分配存放线性表的空间L->length=0; //置空线性表长度为0}线性表的插入:status Sqlist_insert(Sqlist &L,int i,Elemtype x)/*在顺序表L中第i个元素前插入新元素x*/{ if (i<1||i>L.length+1) return ERROR; /*插入位置不正确则出错*/if (L.length>=MAXLEN)return OVERFLOW;/*顺序表L中已放满元素,再做插入操作则溢出*/for(j=L.length-1;j>=i-1;j--)L.elem[j+1]=L.elem[j]; /*将第i个元素及后续元素位置向后移一位*/L.elem[i-1]=x; /*在第i个元素位置处插入新元素x*/L.length++; /*顺序表L的长度加1*/return OK;}线性表的删除:status Sqlist_delete(Sqlist &L,int i,Elemtype &e)/*在顺序表L中删除第i个元素*{ if (i<1||i>L.length) return ERROR; /*删除位置不正确则出错*/for(j=i;j<=L.length-1;j++)L.elem[j-1]=L.elem[j]; /*将第i+1个元素及后继元素位置向前移一位*/L.length--;/*顺序表L的长度减1*/return OK;}线性表元素的查找:int LocateElem(SqList *L, ElemType e) //按元素值查找{int i=0;while (i<L->length && L->data[i]!=e)i++; //查找元素eif (i>=L->length) //未找到时返回0return 0;elsereturn i+1; //找到后返回其逻辑序号}输出线性表:void DispList(SqList *L) //输出线性表{int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf("%c ",L->data[i]);printf("\n");}输出线性表第i个元素的值:bool GetElem(SqList *L,int i,ElemType &e)//求线性表中某个数据元素值{if (i<1 || i>L->length)return false; //参数错误时返回falsee=L->data[i-1]; //取元素值return true; //成功找到元素时返回true}代码:#include <stdio.h>#include <malloc.h>#define MaxSize 50typedef char ElemType;typedef struct{ElemType data[MaxSize];int length;} SqList;void InitList(SqList *&L);void DestroyList(SqList *L);bool ListEmpty(SqList *L);int ListLength(SqList *L);void DispList(SqList *L);bool GetElem(SqList *L,int i,ElemType &e);int LocateElem(SqList *L, ElemType e);bool ListInsert(SqList *&L,int i,ElemType e);bool ListDelete(SqList *&L,int i,ElemType &e);void InitList(SqList *&L)//初始化线性表{L=(SqList *)malloc(sizeof(SqList));//分配存放线性表的空间L->length=0;//置空线性表长度为0 }void DestroyList(SqList *L)//销毁线性表{free(L);}bool ListEmpty(SqList *L)//判线性表是否为空表{return(L->length==0);}int ListLength(SqList *L)//求线性表的长度{return(L->length);}void DispList(SqList *L)//输出线性表{int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf("%c ",L->data[i]);printf("\n");}bool GetElem(SqList *L,int i,ElemType &e)//求线性表中某个数据元素值{if (i<1 || i>L->length)return false;//参数错误时返回falsee=L->data[i-1];//取元素值return true;//成功找到元素时返回true}int LocateElem(SqList *L, ElemType e)//按元素值查找{int i=0;while (i<L->length && L->data[i]!=e)i++;//查找元素eif (i>=L->length)//未找到时返回0return 0;elsereturn i+1;//找到后返回其逻辑序号}bool ListInsert(SqList *&L,int i,ElemType e)//插入数据元素{int j;if (i<1 || i>L->length+1)return false;//参数错误时返回falsei--;//将顺序表逻辑序号转化为物理序号for (j=L->length;j>i;j--)//将data[i]及后面元素后移一个位置L->data[j]=L->data[j-1];L->data[i]=e;//插入元素eL->length++;//顺序表长度增1return true;//成功插入返回true}bool ListDelete(SqList *&L,int i,ElemType &e)//删除数据元素{int j;if (i<1 || i>L->length)//参数错误时返回falsereturn false;i--;//将顺序表逻辑序号转化为物理序号e=L->data[i];for (j=i;j<L->length-1;j++)//将data[i]之后的元素前移一个位置L->data[j]=L->data[j+1];L->length--;//顺序表长度减1return true;//成功删除返回true}void main(){SqList *L;ElemType e;printf("顺序表的基本运算如下:\n");printf(" (1)初始化顺序表L\n");InitList(L);printf(" (2)依次采用尾插法插入a,b,c,d,e元素\n");ListInsert(L,1,'a');ListInsert(L,2,'b');ListInsert(L,3,'c');ListInsert(L,4,'d');ListInsert(L,5,'e');printf(" (3)输出顺序表L:");DispList(L);printf(" (4)顺序表L长度=%d\n",ListLength(L));printf(" (5)顺序表L为%s\n",(ListEmpty(L)?"空":"非空"));GetElem(L,3,e);printf(" (6)顺序表L的第3个元素=%c\n",e);实验结果:心得体会:通过本次实验,实现了数据结构在程序设计上的作用,了解了数据结构语言,加深了对c语言的认识掌并掌握了线性表的顺序存储结构的表示和实现方法,掌握顺序表基本操作的算法实现,同时了解了顺序表的应用。
实验报告1-顺序表操作

《数据结构》实验报告实验名称:顺序表的操作专业:计算机科学与技术班级:本1103学号:201108111122 姓名:秦文杰提交日期:2012.10.8一、实验目的熟练掌握线性表的类型定义方法、顺序存储方法及其基本运算(元素的插入、删除等)的实现方法,培养综合运用所学知识,根据具体问题进行数据结构设计和算法设计的能力。
二、实验要求1.在问题分析的基础上选择顺序存储结构,进行算法设计,编制程序并上机调试成功。
2.按要求完成实验报告3.保存和打印出程序的运行结果,并结合程序进行分析。
三、实验内容设计实现一个顺序表操作的综合应用程序。
要求:实现顺序表的构造、插入、删除、显示以及查找功能。
(基本要求)四、实验设计及测试结果1.数据结构typedef struct {int *elem;int length;int listsize;}SqList;2.函数调用层次结构图1 函数调用层次结构3.函数功能说明Createlist函数:创建一个顺序表;Printlist函数:输出顺序表;listinsert函数:在顺序表的第i个元素之前插入一个元素;listdelete函数:在顺序表中删除第i个元素;locatelem函数:在顺序表中查找与e等值的元素;4. 测试结果与分析上述程序在Visual C++ 6.0环境下加以实现。
经过多次测试,程序运行正确。
运行结果如图2所示。
图2 运行结果五、收获与体会通过这次课程设计:a)我进一步巩固了C语言的基础,尤其是编写C语言的结构及算法转化程序的方法。
b)做实验达到了理论与实践结合的目的,提高了自己的编程能力,c)程序由算法和数据结构组成,一个好的程序不仅算法重要,数据结构的设计也很重要。
d)程序不够简洁,还有待改进,功能还有待更完善,下一步需要改进程序为菜单形式!六、源程序#include <iostream.h>#include <malloc.h>//如需要用到其它头文件请加入。
实验一 顺序表 实验报告

顺序表实验报告一、实验内容和目的实验目的:掌握顺序表的建立、查找、插入和删除操作。
掌握有序表的建立、合并、插入操作。
实验内容:1. 顺序表的建立2. 顺序表的遍历3. 顺序表的元素查找4. 顺序表的元素插入5. 顺序表的元素删除6. 有序表的建立7. 有序表的遍历8. 有序表的元素插入9. 有序表的合并二、实验原理基本原理:通过连续的地址空间实现逻辑上和物理上连续的储存的一系列元素。
并在此基础上进行元素的添加,查找,删除操作。
有序表的插入算法:元素插入之前的,先跟有序表中的逐个元素进行对比,以找到合适的插入位置。
例如,已有有序表L,要向L 中插入元素18L={13,15,17,19,20,35,40}第一步:将18与L1进行比较,18 > L1,不是合适的插入位置。
第二步:将18与L2进行比较,18>L2,仍然不是不是的插入位置。
重复上述步骤,知道找到18≤Ln,然后在(n-1) 和n之间插入元素。
(如果元素比有序表中的所有元素都要大,则把该元素放到有序表的最后)此例子中,L n-1 = 17,L n = 19插入元素之后的有序表L为:L′={13,15,17,18,19,20,35,40}仍然保持有序。
重置光标的位置:程序接受两种方式的输入。
一种是输入数字后按回车,一种是利用空格间隔的连续几个数字。
然而,在使用后者输入数字的时候,会出现提示输出不正确的问题。
(如图)这个问题的原因简单如下:当程序输出“请输入第2个数字:”的时候,应该等待用户输入;然而,在程序等待输入第一个数字的时候,用户输入了五个数字。
因此,程序输出“输入第2个提示以后”,程序发现仍然有数据没有进行处理,因此把上次输入但未处理的字符当成是用户的输入。
所以没让用户输入数据就自动继续执行。
解决这个问题的思路:每次输出提示时,将光标移动到行首,因此,输出提示的时候会自动覆盖已经输出的提示信息。
效果如下:具体的解决方法:#include<windows.h>// 将光标移动到行首void ResetCursor(){HANDLE hOut;COORD cTarget;CONSOLE_SCREEN_BUFFER_INFO info;int y = 0;hOut = GetStdHandle(STD_OUTPUT_HANDLE);GetConsoleScreenBufferInfo(hOut, &info);y = info.dwCursorPosition.Y;cTarget.X = 0;cTarget.Y = y;SetConsoleCursorPosition(hOut, cTarget);}三、程序流程图四、实现步骤4.1 创建顺序表的实现①通过scanf 函数从键盘中读入数据,并通过scanf函数的返回值判断用户输入的是数字还是非数字,作为判断输入结束的判断。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
5、查找操作:(1)按内容查找:执行循环以从L->last开始扫描,直到找到需要查找的值为止;
(2)按序号查找:从顺序表的1个位置开始扫描,直到扫描到的序号=查找的序号时为止;
{
int i,n,x;
ElemType e;
Seqlist L; //定义各个变量
int t;
while(t!=0)
{
system("cls");//清屏
printf("请输入选择:\n");
printf("[1]创建线性表\n");
printf("[2]输出线性表\n");
printf("[3]插入线性表\n");
{
int j;
i=1;
printf("请输入要查找的位置:");
scanf("%d",&j);
if(j<1||j>st+1)
{
printf("查找的位置不合法!");
return 0;
}
else
{
while(i<j)
i++;
printf("查找的值为:%d",L.elem[i-1]);
return(L.elem[i-1]);
int last;
}Seqlist;
void Initseqlist(Seqlist *L)//顺序表的初始化
{
L->last=-1;
}
void CreatSeqlist(Seqlist *L,int n)//顺序表的创建
{
int i;
for(i=1;i<=n;i++)
{
scanf("%d",&L->elem[i-1]);
break;
}
case 3://线性表插入
{
Inslist(&L,i,e);
printf("插入后的线性表为:");
Outputseqlist(L);
break;
}
case 4://线性表的删除操作
{
DilList(&L,i,&x);
printf("删除后的线性表为;");
{
int i=0;
printf("请输入要查找的值:");
printf("[4]删除线性表\n");
printf("[5]按内容查找\n");
printf("[6]按序号查找\n");
printf("[7]清空线性表\n");
printf("[0]退出\n");
scanf("%d",&t);
switch(t)
{
case 1://创建线性表
{
Initseqlist(&L);
}
}
void DilList(Seqlist *L,int i,ElemType *x)//顺序表的删除
{
int j;
printf("请输入要删除的位置:");
scanf("%d",&i);
if(i<1||i>L->last+1)
printf("删除位置不合法!");
*x=L->elem[i-1];
设计分析:
1、借助于高级程序设计语言中的一维数组来表示顺序表的存储结构,一维数组的下标与元素在顺序表中的序号对应;
2、创建顺序表:将存储数据按输入顺序存入一维数组以创建顺序表;
3、插入操作:插入之前判断插入位置的合法与否以及判断表满与否,将原表中位置n,n-1,…,i上的结点,依次后移到位置n+1,n,…i+1上,空出第i个位置,然后在该位置上插入行的结点;
printf("表已满,无法插入!");
for(k=L->last;k>=i-1;k--)
L->elem[k+1]=L->elem[k];
L->elem[i-1]=e;
L->last++;
}
int Locate(Seqlist L,ElemType e)//顺序表按内容查找
void main()//主函数
信息学院
高级语言程序设计上机实验报告
学号:134120337
姓名:王靖
班级:计科13B
实验时间:2014.10.8
实验性质:□综合性实验□设计性实验□验证实验
实验内容:顺序表创建、插入等操作
题目来源:□教材页题□教师补充□自选题目
主要功能描述:实现线性表的顺序存储,即用一组地址连续的存储单元依次存储线性表中的各个元素,使得线性表中在逻辑结构上相邻的数据元素存储在连续的物理存储单元中,在此程序中可实现顺序表的创建、查找(按内容查找、按序号查找)、插入、删除操作。
printf("请输入线性表的长度:");
scanf("%d",&n);
printf("请输入%d个数字,分别用空格隔开\n",n);
CreatSeqlist(&L,n);
printf("你创建的线性表为:");
Outputseqlist(L);
break;
}
case 2://输出线性表
{
Outputseqlist(L);
在此之前也需要对查找位置的合法与否进行判断。
典型测试数据输入:
输出:
预期结果:
2 3 4 5 6
2 9 3 4 5 6
2 3 4 5 6
2
3
程序及运行结果正误判断:□非常好□正确,还可改进□基本正确,还需改进□还有错误
不足之处或设计经验小结:
该实验在设计思路上基本正确,但在程序设计时,考虑到程序的读取速度,还可进一步改进,使该程序更简洁明了且程序运行效率提高,实现完该程序的设计后,让我对数组的概念更加清楚,且对其运用更加灵活,在此基础上,也让我知道了在程序中元素地址的重要性。
for(j=i;j<L->last+1;j++)
L->elem[j-1]=L->elem[j];
L->last--;
}
Outputseqlist(L);
break;
}
case 5://按内容查找
{
Locate(L,e);
break;
}
case 6://按序号查找
{
GetDate(L,i);
break;
任课教师评语:
教师签字:年 月 日
源程序
(1)流程图:略
(2)程序:
#include <stdio.h>
#include "stdlib.h"
#define MAXSIZE 100
typedef int ElemType;
typedef struct//定义顺序表的结构
{
ElemType elem[MAXSIZE];
}
case 7:
{
Initseqlist(&L);
break;
}
case 0:
{
break;
}
}
system("pause");//暂停
}
}//(完)
{ int k;
printf("请输入要插入的位置:");
scanf("%d",&i);
printf("\n");
printf("请输入要插入的值:");
scanf("%d",&e);
if(i<=0||i>L->last+2)
printf("输入位置不合法");
if(L->last>=MAXSIZE-1)
scanf("%d",&e);
while((i<=st)&&(L.elem[i]!=e))
i++;
if(i<=st)
{
printf("查找的值为:%d",i+1);
return (i+1);
}
else{
printf("无法查找该值!");
return -1;
}
}
int GetDate(Seqlist L,int i)//顺序表按序号查找
L->last++;
}
}
void Outputseqlist(Seqlist L)//输出线性表
{
int i;
for(i=1;i<=st+1;i++)
printf("%d ",L.e}
void Inslist(Seqlist *L,int i,ElemType e)//顺序表的插入