顺序表的实现

合集下载

数据结构与算法分析实验报告

数据结构与算法分析实验报告

数据结构与算法分析实验报告一、实验目的本次实验旨在通过实际操作和分析,深入理解数据结构和算法的基本概念、原理和应用,提高解决实际问题的能力,培养逻辑思维和编程技巧。

二、实验环境本次实验使用的编程语言为 Python,使用的开发工具为 PyCharm。

操作系统为 Windows 10。

三、实验内容(一)线性表的实现与操作1、顺序表的实现使用数组实现顺序表,包括插入、删除、查找等基本操作。

通过实验,理解了顺序表在内存中的存储方式以及其操作的时间复杂度。

2、链表的实现实现了单向链表和双向链表,对链表的节点插入、删除和遍历进行了实践。

体会到链表在动态内存管理和灵活操作方面的优势。

(二)栈和队列的应用1、栈的实现与应用用数组和链表分别实现栈,并通过表达式求值的例子,展示了栈在计算中的作用。

2、队列的实现与应用实现了顺序队列和循环队列,通过模拟银行排队的场景,理解了队列的先进先出特性。

(三)树和二叉树1、二叉树的遍历实现了先序、中序和后序遍历算法,并对不同遍历方式的结果进行了分析和比较。

2、二叉搜索树的操作构建了二叉搜索树,实现了插入、删除和查找操作,了解了其在数据快速查找和排序中的应用。

(四)图的表示与遍历1、邻接矩阵和邻接表表示图分别用邻接矩阵和邻接表来表示图,并比较了它们在存储空间和操作效率上的差异。

2、图的深度优先遍历和广度优先遍历实现了两种遍历算法,并通过对实际图结构的遍历,理解了它们的应用场景和特点。

(五)排序算法的性能比较1、常见排序算法的实现实现了冒泡排序、插入排序、选择排序、快速排序和归并排序等常见的排序算法。

2、算法性能分析通过对不同规模的数据进行排序实验,比较了各种排序算法的时间复杂度和空间复杂度。

四、实验过程及结果(一)线性表1、顺序表在顺序表的插入操作中,如果在表头插入元素,需要将后面的元素依次向后移动一位,时间复杂度为 O(n)。

删除操作同理,在表头删除元素时,时间复杂度也为 O(n)。

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

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

实验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. 引言顺序表是一种常见的数据结构,它可以用于存储一组有序的元素。

在本实验中,我们将探索顺序表的实现方式,并通过实验验证其性能和效果。

2. 实验目的本实验的主要目的是掌握顺序表的实现原理和基本操作,并通过实验对比不同操作的时间复杂度。

3. 实验方法3.1 数据结构设计我们选择使用静态数组作为顺序表的底层存储结构。

通过定义一个固定大小的数组,我们可以实现顺序表的基本操作。

3.2 基本操作实现在顺序表的实现中,我们需要实现以下基本操作:- 初始化操作:创建一个空的顺序表。

- 插入操作:向顺序表中插入一个元素。

- 删除操作:从顺序表中删除一个元素。

- 查找操作:在顺序表中查找指定元素。

- 获取长度:获取顺序表中元素的个数。

4. 实验步骤4.1 初始化操作首先,我们需要创建一个空的顺序表。

这可以通过定义一个数组和一个变量来实现,数组用于存储元素,变量用于记录当前顺序表的长度。

4.2 插入操作在顺序表中插入一个元素的过程如下:- 首先,判断顺序表是否已满,如果已满则进行扩容操作。

- 然后,将要插入的元素放入数组的末尾,并更新长度。

4.3 删除操作从顺序表中删除一个元素的过程如下:- 首先,判断顺序表是否为空,如果为空则返回错误信息。

- 然后,将数组中最后一个元素删除,并更新长度。

4.4 查找操作在顺序表中查找指定元素的过程如下:- 首先,遍历整个数组,逐个比较元素与目标元素是否相等。

- 如果找到相等的元素,则返回其位置;如果遍历完仍未找到,则返回错误信息。

4.5 获取长度获取顺序表中元素个数的过程如下:- 直接返回记录长度的变量即可。

5. 实验结果与分析在实验中,我们通过对大量数据进行插入、删除、查找等操作,记录了每个操作的耗时。

通过对比不同操作的时间复杂度,我们可以得出以下结论:- 初始化操作的时间复杂度为O(1),因为只需要创建一个空的顺序表。

- 插入和删除操作的时间复杂度为O(n),因为需要遍历整个数组进行元素的移动。

实现顺序表的各种基本运算的算法

实现顺序表的各种基本运算的算法

实现顺序表的各种基本运算的算法
1.初始化顺序表:首先需要定义一个数组来存储顺序表中的元素,在初始化顺序表时,需要给定顺序表的大小,即可创建一个空的顺序表。

2. 插入元素:要在顺序表中插入一个元素,需要确定插入位置
和插入元素的值。

插入元素时,需要将插入位置后面的元素都向后移动一位,然后将插入元素插入到插入位置。

3. 删除元素:要从顺序表中删除一个元素,需要确定删除位置。

删除元素时,需要将删除位置后面的元素都向前移动一位,然后将最后一个元素移到删除位置处,即可完成删除操作。

4. 查找元素:要在顺序表中查找一个元素,可以使用顺序查找
或者二分查找算法。

顺序查找需要遍历整个顺序表,而二分查找需要先对顺序表进行排序,然后再进行查找。

5. 修改元素:要修改顺序表中的一个元素,需要先查找到该元
素的位置,然后再进行修改操作。

6. 获取顺序表长度:顺序表的长度就是顺序表中元素的个数,
可以通过遍历整个顺序表来获取其长度。

7. 清空顺序表:清空顺序表就是将顺序表中的元素全部删除,
可以通过遍历整个顺序表进行删除操作来实现。

8. 销毁顺序表:销毁顺序表就是释放顺序表所占用的内存空间,可以通过调用系统函数来实现。

以上就是实现顺序表的各种基本运算的算法。

实验一 顺序表操作实现

实验一 顺序表操作实现

实验一顺序表操作实现实验一顺序表操作实现实验日期:2022年3月6日实验目的及要求1.掌握线性表的基本操作和顺序存储的实现;2.以线性表的各种操作(建立、插入、删除、遍历等)的实现为重点;3.掌握线性表的顺序存储结构的定义和基本操作的实现;4.加深本函数指针的使用(尤其是C的应用)。

实验内容已知程序文件seqlist CPP给出了学生身高信息序列表的类型定义和基本运算函数定义。

(1)顺序表类型定义typedefstruct{intxh;/*学号*/floatsg;/*身高*/intsex;/*性别:0为男性,1为女性*/}数据类型;typedefstruct{datatypedata[max];/*存放顺序表元素的数组*/intlast;/*表示data中实际存放元素个数*/}seqlist;(2)基本操作功能原型voidinitlist(seqlist*lp);/*置一个空表*/voidcreatelist(seqlist*lp);/*创建学生订单表*/voidsort_xh(seqlist*lp);/*按学生编号排序*/void error(char*s)/*用户定义的错误处理函数*/void pntlist (seqlist*LP)/*输出学生表*/voidsave(seqlist*lp,charstrname[]);/*保存学生顺序表到指定文件*/任务一创建程序文件seqlist.cpp,其代码如下所示,理解顺序表类型seqlist和基本运算函数后回答下列问题。

/*seqlist。

CPP程序文件代码*/#include#include#definemax50typedef{intxh;/*学号*/floatsg;/*身高*/intsex;/*性别:0为男性,1为女性*/}数据类型;typedefstruct{datatypedata[max];/*存放顺序表元素的数组*/intlast;/*表示data中实际存放元素个数*/}seqlist;voidinitlist(seqlist*lp);/*摆一张空桌子*/voidcreatelist(seqlist*lp);/*建一个学生顺序表*/voidsort_xh(seqlist*lp);/*按学号排序*/voiderror(char*s);/*自定义错误处理函数*/voidpntlist(seqlist*lp);/*输出学生表*/voidsave(seqlist*lp,charstrname[]);/*将学生序列表保存到指定文件*//*置一个空表*/voidinitlist(seqlist*lp){lp->last=0;}/*建一个学生顺序表*/voidcreatelist(seqlist*lp){file*fp;intxh,sex;floatsg;if((fp=fopen(\{error(\}而(!feof(fp)){fscanf(fp,\lp->data[lp->last].xh=xh;lp->data[lp->last].sg=sg;lp->data[lp->last].sex=sex;lp->last++;}fclose(fp);}/*按学生人数递增*/voidsort_xh(seqlist*lp){inti,j,k;datatypest;对于(i=0;ilast-1;i++){k=i;for(j=i+1;jlast;j++)if(lp->data[j].xhdata[k].xh)k=j;if(k!=i){st=lp->data[k];lp->data[k]=lp->data[i];lp->data[i]=st;}}}/*自定义错误处理函数*/void error(char*s){printf(\exit(1);/*返回os,该函数定义在stdlib.h中*/}/*输出学生序列表*/void pntlist(seqlist*LP){inti;for(i=0;ilast;i++)printf(\}/*保存学生顺序表到指定文件*/voidsave(seqlist*lp,charstrname[]){file*fp;inti;如果((fp=fopen(strname,\{error(\}for(i=0;ilast;i++){fprintf(fp,\}fclose(fp);}请回答以下问题:(1)由顺序表类型定义可知,该顺序表类型名为seqlist,其中存放的元素为学生信息,学生信息定义的类型名为datatype,包含xh、sg、sex三个成员(写出成员变量名),学生信息存储于data数组,顺序表的表长变量为max。

实现顺序表的各种基本运算的算法

实现顺序表的各种基本运算的算法

实现顺序表的各种基本运算的算法1. 初始化顺序表算法实现:初始化操作就是将顺序表中所有元素的值设置为默认值,对于数值类型,可以将其设置为0,对于字符类型,可以将其设置为空格字符。

初始化的时间复杂度为O(n),其中n为顺序表的长度。

2. 插入操作算法实现:顺序表的插入操作就是在指定位置上插入一个元素,需要将该位置后面的元素全部后移,在指定位置上插入新元素。

若顺序表已满,则需要进行扩容操作,将顺序表长度扩大一倍或者按一定的比例扩大。

插入操作的时间复杂度为O(n),其中n为顺序表长度。

3. 删除操作算法实现:顺序表的删除操作需要将指定位置上的元素删除,并将该位置后面的元素全部前移。

删除操作后,如果顺序表的实际长度小于等于其总长度的1/4,则需要进行缩容操作,将顺序表长度缩小一倍或者按一定的比例缩小。

删除操作的时间复杂度为O(n),其中n为顺序表长度。

4. 修改操作算法实现:顺序表的修改操作就是将指定位置上的元素赋予新的值。

修改操作的时间复杂度为O(1)。

5. 查找操作算法实现:顺序表的查找操作就是在顺序表中找到指定位置的元素,并返回其值。

查找操作的时间复杂度为O(1)。

6. 遍历操作算法实现:顺序表的遍历操作就是依次访问顺序表中的每个元素,遍历操作的时间复杂度为O(n),其中n为顺序表的长度。

7. 合并操作算法实现:顺序表的合并操作就是将两个顺序表合并成一个新的顺序表,新的顺序表的长度为两个顺序表的长度之和。

合并操作的时间复杂度为O(n),其中n为两个顺序表的长度之和。

总结:顺序表是一种简单而高效的数据结构,其基本运算包括初始化、插入、删除、修改、查找、遍历和合并等操作。

其中,插入、删除、遍历和合并操作的时间复杂度比较高,需要进行相应的优化处理。

同时,在实际应用中,还需要注意顺序表的扩容和缩容操作,避免造成资源浪费或者性能下降。

顺序表基本操作的实现

顺序表基本操作的实现

【实验名称】顺序表基本操作的实现【实验目的】1. 熟悉调试工具VC++6.0的使用2. 温习C++相关程序的编写与应用3. 掌握顺序表的基本操作:构造顺序表、插入、删除、查找等4. 掌握顺序表的应用:顺序表的合并等运算【实验原理】VC6.0工具的使用,C++类实现顺序表的定义及基本操作算法的实现,应用顺序表解决实际问题。

【学时安排】2学时上机实践【具体操作内容及要求】1.创建一个目录(学号命名),然后创建项目和源文件完成本次实验内容:(1)创建项目或源文件名为“Ex1_(学号后四位).cpp”;(2)编写并调试线性表的C++模板类定义,即调试运行课本中44页程序2.2(3)编写并调试顺序表类定义(由线性表类派生)及顺序表基本操作的算法实现。

即调试运行课本46~50页程序2.5~2.9。

(4)编写主函数main,实现课本52页程序2.10中顺序表的合并操作应用。

(注意算法的改进)(5)注意所有变量、类名、方法名的命名规范。

2. 撰写实验报告(下载实验报告模板),内容包括:实验原理、实验目的、实验具体步骤及实验结果(运行效果截图)。

3. 将实验报告和程序源文件放在一个以学号命名的文件夹中,然后压缩(如2010011213.rar)提交,注意提交截止时间。

实验结果:①编程代码:A: LinearList.h头文件代码:#include <iostream.h>#include <stdlib.h>class LinearList{public:LinearList(){};~LinearList(){};virtual int Size()const=0;virtual int Length()const=0;virtual int Search(T& x)const=0;virtual int Locate(int i)const=0;virtual bool getData(int i,T& x)const=0;virtual void setData(int i,T& x)=0;virtual bool Insert(int i,T& x)=0;virtual bool Remove(int i,T& x)=0;virtual bool IsEmpty()const=0;virtual bool IsFull()const=0;// virtual void Sort()=0;virtual void input()=0;virtual void output()=0;// virtual LinearList<T> operator=(LinearList<T>& L)=0;};B:SeqList.h头文件代码:#include "linearlist.h"const int DefaultSize = 100;class SeqList:public LinearList<T>{public:SeqList ( int size = DefaultSize );SeqList(SeqList<T>& L);~SeqList() { delete[] data; }int Size()const{ return maxSize;}int Length()const { return last+1; } int Search( T& x ) const;int Locate(int i)const;bool getData(int i,T& x)const{if(i>0 && i<=last+1){x=data[i-1];return true;}elsereturn false;}void setData(int i,T& x){if(i>0 && i<=last+1){}}bool Insert(int i, T& x);bool Remove(int i,T& x);bool IsEmpty()const { return (last == -1)?true:false; }bool IsFull()const { return (last == maxSize - 1)?true:false; } void input();void output();SeqList<T> operator=(SeqList<T>& L);protected:T *data;int maxSize;int last;void reSize(int newSize);};template <class T>SeqList<T>::SeqList( int sz){if ( sz > 0 ) {maxSize = sz; last = -1; //置表的实际长度为空data = new T[maxSize]; //创建顺序表存储数组if(data==NULL) //动态分配失败{exit(1);}}}//赋值构造函数,用参数表中给出的已有顺序初始化新建的顺序表。

顺序表的基本操作和实现实验报告(一)

顺序表的基本操作和实现实验报告(一)

顺序表的基本操作和实现实验报告(一)顺序表的基本操作和实现实验报告1. 引言顺序表是计算机科学中一种常用的数据结构,用于存储一组元素并支持快速的随机访问。

本实验旨在探究顺序表的基本操作和实现方法。

2. 实验目的•理解顺序表的概念和特性。

•学习顺序表的基本操作,包括插入、删除、查找和修改等。

•掌握顺序表的实现方法,包括静态分配和动态分配两种方式。

•培养对数据结构的抽象思维和编程能力。

3. 实验内容1.了解顺序表的定义,及其与数组的关系。

2.掌握插入操作的实现方法,包括在表头、表中和表尾插入元素。

3.掌握删除操作的实现方法,包括按索引删除和按值删除。

4.掌握查找操作的实现方法,包括按索引查找和按值查找。

5.掌握修改操作的实现方法,包括按索引修改和按值修改。

6.实现顺序表的静态分配和动态分配两种方式。

4. 实验步骤1.定义顺序表的结构体,包括数据存储区和长度属性。

2.实现插入操作,根据需要选择插入位置和移动元素。

3.实现删除操作,根据需要选择删除方式和更新长度。

4.实现查找操作,根据需要选择查找方式和返回结果。

5.实现修改操作,根据需要选择修改方式和更新元素。

6.实现顺序表的静态分配和动态分配方法。

5. 实验结果经过多次实验和测试,顺序表的基本操作都能够正确实现。

在插入操作中,能够将元素正确插入指定位置,并保持顺序表的有序性。

在删除操作中,能够按需删除指定位置或值的元素,并正确更新顺序表的长度。

在查找操作中,能够根据索引或值查找到对应的元素,并返回正确的结果。

在修改操作中,能够按需修改指定位置或值的元素,并更新顺序表的内容。

6. 实验总结本实验通过对顺序表的基本操作和实现方法的学习和实践,进一步巩固了对数据结构的理解和编程能力的培养。

顺序表作为一种常用的数据结构,对于解决实际问题具有重要的作用。

通过本次实验,我对顺序表的插入、删除、查找和修改等操作有了更深入的了解,并学会了如何实现这些操作。

通过本次实验,我还学会了顺序表的静态分配和动态分配方法,了解了它们的区别和适用场景。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

数据结构实验顺序表的实现姓名学号专业班级实验名称:顺序表的实现一.实验目的:1.掌握线性表的顺序存储结构;2.验证顺序表的基本操作的实现;3.理解算法与程序的关系,能够将顺序表转换为对应程序;二.实验内容:1.建立含有若干元素的顺序表;2.对已建立的顺序表实现插入、删除、查找等基本操作;三.算法设计1.建立顺序表并初始化1)顺序表的大小为MaxSize,存入元素的下标为na.如果n>MaxSize,则抛出参数非法;b.将元素a[i]赋值给线性表中元素序号为i的元素;2.顺序表的插入1)如果表满了,则抛出上溢异常;2)如果元素插入的位置不合理,则抛出位置异常;3)将最后一个元素及第i个元素分别向后移动一个位置;4)将要插入的元素x填入为位置i处;5)表长加1;3.顺序表的删除1)如果表空,则抛出下一异常;2)如果删除的位置不合理,则抛出删除位置异常;3)取出被删元素;4)将下表为i至n-1的元素分别向前移动1个元素;5)表长减一,返回被删元素值;4.顺序表的查找A.按位查找1)如果查找的位置不合理,则抛出查找的不合理;2)返回被查找的元素值;B.按值查找1)若查找成功,返回被查找元素的序号;2)若查找失败,则返回0;四.部分代码文件名称:SeqList.h#define SEQLIST_Hconst int MaxSize = 5;template <class T>class SeqList{publi#ifndef SEQLIST_Hc:SeqList(); //默认构造函数SeqList(T a[],int n); //数组a传递数据元素信息,n表示元素个数~SeqList(); //析构函数int Length(); //返回顺序表的长度void Insert(int i,T x);//在第i个位置插入数据元素xT Get(int i); //得到第i个位置上的数据元素T Delete(int i); //删除第i个位置上的数据元素int Locate(T x); //在顺序表中查找数据元素x,并返回它的位置,否则返回0.void PrintList(); //打印顺序表中的数据元素信息。

private:T data[MaxSize]; //数组data用来存放顺序表的数据元素int length; //length表示顺序表中数据元素的个数};#endif文件名称:SeqList.cpp#include "SeqList.h"//默认构造函数template <class T>SeqList<T>::SeqList(){length = 0 ;}template <class T>SeqList<T>::SeqList(T a[],int n){if(n>MaxSize)return;for(int i=0;i<n;i++){data[i] = a[i];}length = n;}template <class T>SeqList<T>::~SeqList(){}//返回顺序表的长度template <class T>int SeqList<T>::Length(){return length;}template <class T>void SeqList<T>::Insert(int i,T x){if(length == MaxSize){cout<<"线性表已满!"<<endl;return;}if(i<=0||i>length){cout<<"插入位置不合法!"<<endl;return;}for(int j=length;j>=i;j--){data[j] = data[j-1];}data[i] = x;length++;}template <class T>T SeqList<T>::Get(int i){if(i>length-1||i<1) throw "非法位置";return data[i-1];}template <class T>int SeqList<T>::Locate(T x){for(int i=0;i<length;i++){if(data[i]==x){return i+1;}}return 0;}template <class T>T SeqList<T>::Delete(int i){T x = data[i-1];for(int j=i-1;j<length-1;j++)data[j] = data[j+1];length--;return x;}template <class T>void SeqList<T>::PrintList(){for(int i=0;i<length;i++){if(i%10==0) cout<<endl;cout<<data[i]<<" ";}}文件名称:Student.h#ifndef STUDENT_H#define STUDENT_H#include <iostream>#include <string>using namespace std;class Student{public:Student(){} //默认构造函数Student(int n,int s,string na,int gra); //参数n为学号,s为性别,0表示男,其他表示女,na表示姓名~Student(); //析构函数Student(Student& s); //复制构造函数friend ostream& operator<<(ostream& out,Student& stu){ //输出流运算符重载out<<stu.num<<"."<<<<",";if(stu.sex==0)out<<"男";elseout<<"女";cout<<endl;return out;}friend istream& operator>>(istream& in,Student& stu){ //输入流运算符重载in>>stu.num>>>>stu.sex;return in;}Student& operator=(Student& stu); //赋值运算符重载void query();void insert();private:int num; //学号int sex; //性别string name;//姓名int grade; //成绩};#endif文件名称:Student.cpp#include "Student.h"#include <iostream>#include <string>using namespace std;Student::Student(int n,int s,string na,int gra){this->num = n;this->name = na;this->sex = sex;this->grade=gra;}Student::~Student(){}//复制构造函数Student::Student(Student& s){this->num = s.num;this->name = ;this->sex = s.sex;this->grade=s.grade;}Student& Student::operator=(Student& stu){this->num = stu.num;this->name = ;this->sex = stu.sex;this->grade=stu.grade;return *this;}void Student::query(){Student stud;int num,gra,way;string na;cout<<"please choose your way to query:"<<endl;cout<<"1):学号"<<endl<<"2)姓名:"<<endl;cin>>way;switch(way){case'1':{cout<<"请输入你要查询的学生学号:"<<endl;cin>>num;//for(int i=0;i<MaxSize;i++)if(stud.num==num){cout<<"该学生的学号为:"<<stud.num<<endl;cout<<"该学生的姓名为:"<<<<endl;cout<<"该学生的性别为:"<<stud.sex<<endl;cout<<"该学生的成绩为:"<<stud.grade<<endl;}}break;case'2':{cout<<"请输入你要查询的学生姓名:";cin>>na;//for(int i=0;i<MaxSize;i++)if(==na){cout<<"该学生的学号为:"<<stud.num<<endl;cout<<"该学生的姓名为:"<<<<endl;cout<<"该学生的性别为:"<<stud.sex<<endl;cout<<"该学生的成绩为;"<<stud.grade<<endl;}}break;}}void Student::insert(){int n;int s;string na;int gra;cout<<"请输入你要插入的学生信息:"<<endl;cout<<"学号:"<<endl;cin>>n;cout<<"姓名:"<<endl;cin>>na;cout<<"性别(0为男,其他为女)"<<endl;cin>>s;cout<<"成绩:"<<endl;cin>>gra;//Student stu[n]=(n,sex,na,gra);}五实验心得:在编写代码是要仔细小心,对于出现的错误不懂的可以去百度查找;另外,要清楚所需的操作与函数之间的关系。

相关文档
最新文档