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

实验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、顺序表存储
原理:将表中元素⼀个个存⼊⼀组连续的存储单元中,这种存储结构是顺序结构。
采⽤顺序存储结构的线性表简称为“ 顺序表”。
优点:简单易⽤使⽤的是联系的内存空间可以借助CPU的缓存机制预读取数组中的数据所以访问效率⽐较⾼
缺点:1.插⼊和删除⽐较慢
2.不可以增长长度
3:如果申请的过⼤系统可能没有⾜够的内存空间给分配,会导致内存不⾜,如果声明过⼩就会导致不够⽤如果不够⽤只能申请⼀个更⼤的空间还要把原数组的数据copy 过去影响效率
⽐如:插⼊或者删除⼀个元素时,整个表需要遍历移动元素来重新排⼀次顺序 C# 中如 ArrayList List 等
2、链式表存储
原理:链表存储是在程序运⾏过程中动态的分配空间,只要存储器还有空间,就不会发⽣存储溢出问题
优点:插⼊和删除速度快,保留原有的物理顺序
缺点:查找速度慢,因为查找时,需要循环链表访问并且链式存储在内存中不连续这样对CPU的缓存不友好没办法做到预先读取链表除了要存储本⾝数据外还要额外维护前后节点的指针,对内存要求的严格的程序是不友好的~⽽且链表频繁的删除和新增会导致内存也频繁的申请释放容易产⽣内存碎⽚导致GC 频繁的去回收
⽐如:插⼊或者删除⼀个元素时,只需要改变指针指向即可 C# 中 LinkedList<T>
总结在实际开发中我们还是要权衡⾃⼰的使⽤场景来决定使⽤什么样的数据结构。
chap2数据结构,顺序表,树,图,链表,排序

2.4 一元多项式的表示
ADT List { 数据对象: D={ ai | ai ∈ElemSet, i=1,2,...,n, n≥0 } { 称 n 为线性表的表长; 称 n=0 时的线性表为空表。} 数据关系:
R1={ <ai-1 ,ai >|ai-1 ,ai∈D, i=2,...,n }
{ 设线性表为 (a1,a2, . . . ,ai,. . . ,an), 称 i 为 ai 在线性表中的位序。}
i = 1; found = TRUE; while ( i<= La_len && found ) {
GetElem(LA, i, e); // 取得LA中一个元素
if (LocateElem(LB, e, equal( ))
i++;
// 依次处理下一个
else found = FALSE;
// LB中没有和该元素相同的元素
{加工型操作} ClearList( &L ) ( 线性表置空 ) PutElem( &L, i, &e ) ( 改变数据元素的值 ) ListInsert( &L, i, e ) ( 插入数据元素 ) ListDelete( &L, i, &e ) ( 删除数据元素 )
ClearList( &L ) 初始条件:线性表 L 已存在。 操作结果:将 L 重置为空表。 PutElem( &L, i, e ) 初始条件: 线性表 L 已存在, 且 1≤i≤LengthList(L)。 操作结果:L 中第 i 个元素赋值和 e 相同。
线性结构的基本特征: 线性结构 是 一个数据元素的有序(次序)集 1.集合中必存在唯一的一个“第一元素” 2.集合中必存在唯一的一个 “最后元素”
数据结构实验一顺序表

数据结构实验一1、实验目的∙掌握线性表的逻辑特征∙掌握线性表顺序存储结构的特点,熟练掌握顺序表的基本运算2、实验内容:建立顺序表,完成顺序表的基本操作:初始化、插入、删除、逆转、输出、销毁, 置空表、求表长、查找元素、判线性表是否为空;1.问题描述:利用顺序表,设计一组输入数据(假定为一组整数),能够对顺序表进行如下操作:∙创建一个新的顺序表,实现动态空间分配的初始化;∙根据顺序表结点的位置插入一个新结点(位置插入),也可以根据给定的值进行插入(值插入),形成有序顺序表;∙根据顺序表结点的位置删除一个结点(位置删除),也可以根据给定的值删除对应的第一个结点,或者删除指定值的所有结点(值删除);∙利用最少的空间实现顺序表元素的逆转;∙实现顺序表的各个元素的输出;∙彻底销毁顺序线性表,回收所分配的空间;∙对顺序线性表的所有元素删除,置为空表;∙返回其数据元素个数;∙按序号查找,根据顺序表的特点,可以随机存取,直接可以定位于第i 个结点,查找该元素的值,对查找结果进行返回;∙按值查找,根据给定数据元素的值,只能顺序比较,查找该元素的位置,对查找结果进行返回;∙判断顺序表中是否有元素存在,对判断结果进行返回;.编写主程序,实现对各不同的算法调用。
2.实现要求:∙“初始化算法”的操作结果:构造一个空的顺序线性表。
对顺序表的空间进行动态管理,实现动态分配、回收和增加存储空间;∙“位置插入算法”的初始条件:顺序线性表L 已存在,给定的元素位置为i,且1≤i≤ListLength(L)+1 ;操作结果:在L 中第i 个位置之前插入新的数据元素e,L 的长度加1;∙“位置删除算法”的初始条件:顺序线性表L 已存在,1≤i≤ListLength(L) ;操作结果:删除L 的第i 个数据元素,并用e 返回其值,L 的长度减1 ;∙“逆转算法”的初始条件:顺序线性表L 已存在;操作结果:依次对L 的每个数据元素进行交换,为了使用最少的额外空间,对顺序表的元素进行交换;∙“输出算法”的初始条件:顺序线性表L 已存在;操作结果:依次对L 的每个数据元素进行输出;∙“销毁算法”初始条件:顺序线性表L 已存在;操作结果:销毁顺序线性表L;∙“置空表算法”初始条件:顺序线性表L 已存在;操作结果:将L 重置为空表;∙“求表长算法”初始条件:顺序线性表L 已存在;操作结果:返回L 中数据元素个数;∙“按序号查找算法”初始条件:顺序线性表L 已存在,元素位置为i,且1≤i≤ListLength(L)操作结果:返回L 中第i 个数据元素的值∙“按值查找算法”初始条件:顺序线性表L 已存在,元素值为e;操作结果:返回L 中数据元素值为e 的元素位置;∙“判表空算法”初始条件:顺序线性表L 已存在;操作结果:若L 为空表,则返回TRUE,否则返回FALSE;分析: 修改输入数据,预期输出并验证输出的结果,加深对有关算法的理解。
数据结构 顺序表的面试题目

在面试中,关于顺序表(也就是数组)的数据结构,可能会涉及以下一些问题:
解释顺序表:你能否给出一个顺序表(数组)的简单定义?它有哪些优点和缺点?
索引和访问:在顺序表中,我们如何快速地访问特定的元素?索引的作用是什么?
插入和删除:在顺序表中插入或删除元素时,时间复杂度是多少?如何实现这些操作?
排序:你能解释一下几种常见的排序算法(如冒泡排序、选择排序、插入排序、快速排序等)吗?它们的时间复杂度是多少?
反转:如何反转一个顺序表?这有什么实际应用场景吗?
计算长度:在顺序表中,如何计算元素的数量?
动态扩容:在顺序表设计中,我们如何实现动态扩容?这会带来什么影响?
内存使用:顺序表在内存中是如何存储的?其内存使用情况如何?
与链表的比较:顺序表和链表有哪些主要的区别?它们各自的优点和缺点是什么?
实际应用:你能给出一个使用顺序表解决的实际问题例子吗?
这些问题可以用来评估面试者对顺序表数据结构的理解和技能。
注意,实际问题的答案可能会根据具体的面试官和公司需求而有所不同。
数据结构-顺序表

数据结构-顺序表判断题1.(neuDS)所谓随机存取,就是通过⾸地址和元素的位序号值可以在O(1)的时间内找到指定的元素。
F2.(neuDS)在顺序表上进⾏插⼊、删除操作时需要移动元素的个数与待插⼊或待删除元素的位置⽆关。
T F3.顺序存储⽅式只能⽤于存储线性结构。
T F4.在顺序表中取出第i个元素所花费的时间与i成正⽐。
T F5.对于顺序存储的长度为N的线性表,删除第⼀个元素和插⼊最后⼀个元素的时间复杂度分别对应为O(1)和O(N)。
T F6.(neuDS)在顺序表中逻辑上相邻的元素,其对应的物理位置也是相邻的。
F7.顺序存储的线性表可以随机存取。
F8.顺序存储结构的主要缺点是不利于插⼊或删除操作。
F选择题1.⽤数组表⽰线性表的优点是()。
A.便于插⼊和删除操作B.便于随机存取C.可以动态地分配存储空间D.不需要占⽤⼀⽚相邻的存储空间2.阅读下列程序,其功能是()。
typedef struct {ElemType *list;int size;intMaxSize;}SeqList;void fun1(SeqList&L) {inti, j;ElemType temp;for (i=0, j= L.sise-1; i<j; i++, j--) {temp=L.list[i];L.list[i]=L.list[j];L.list[j]=temp;}}A.将顺序表原地逆置B.将链表原地逆置C.将顺序表⾸尾元素对换D.将链表⾸尾元素对换3.顺序存储表⽰中数据元素之间的逻辑关系是由()表⽰的。
A.指针B.逻辑顺序C.存储位置D.问题上下⽂4.顺序表的优点是()。
A.插⼊操作的时间效率⾼B.适⽤于各种逻辑结构的存储表⽰C.存储密度(存储利⽤率)⾼D.删除操作的时间效率⾼5.若线性表最常⽤的操作是存取第i个元素及其前驱的值,则采⽤( )存储⽅式节省时间。
A.单链表B.双向链表C.单循环链表D.顺序表6.数组A[1..5,1..6]每个元素占5个单元,将其按⾏优先次序存储在起始地址为1000的连续的内存单元中,则元素A[5,5]的地址为:A.1120B.1125C.1140D.11457.若某线性表最常⽤的操作是存取任⼀指定序号的元素和在最后进⾏插⼊和删除运算,则利⽤哪种存储⽅式最节省时间?A.双链表B.单循环链表C.带头结点的双循环链表D.顺序表8.若长度为n的线性表采⽤顺序结构,在第i个数据元素之前插⼊⼀个元素,需要它依次向后移动()个元素。
数据结构 顺序表
int i,j; //for循环参数
int k; //while参数,switch分支选项
int x; //插入表的位置
int elem; //输入的元素
int num; //个数
int y; //接受调用函数的返回值
printf("\t\t9.删除元素e。\t\t10.销毁已创建的顺序表。\n");
printf("\t\t11.打印顺序表元素。\t12.查看顺序表长度。\n");
printf("\t\t0.退出。\n");
printf("\t\t***********************************************\n");
{
printf("\n\n\t\t顺序表未创建或已清空!\n");
getch();
break;
}
printf("\n\n\t\t输入添加的元素个数:__\b\b");
scanf("%d",&num);
if((num+L.length)>=L.listsize)
getch();
break;
case 3:
ClearList(&L);
printf("顺序表清空成功!");
getch();
break;
case 4:
y=InspectList(L);
if(y==INFEASTBLE)
{
printf("\t\t1.创建一个空顺序表。\t2.添加元素。\n");
顺序表实验总结
顺序表实验总结顺序表是数据结构中最基础的一种,它可以存储一组相同类型的数据,并且具有顺序性。
在进行实验的过程中,我对顺序表的构建、操作以及其在实际应用中的性能表现有了更深入的了解。
以下是我对顺序表实验的总结与心得。
一、顺序表构建与基本操作在实验中,我通过数组的方式构建了顺序表。
首先,我需要定义一个固定大小的数组来存储数据,然后使用指针来指示当前数据的末尾位置。
通过这种方式,我能够方便地通过下标来访问和修改数据,同时还可以通过指针来动态调整数组的大小。
在进行实验过程中,我熟练掌握了顺序表的基本操作,如插入、删除、查找等。
这些基本操作是对顺序表进行增加、删除和查找数据的关键操作,能够有效地操作顺序表中的数据。
二、顺序表与其他数据结构的比较在实验中,我也对顺序表与其他数据结构进行了比较。
相比于链表这样的动态数据结构,顺序表具有更好的随机存取性能,可以通过下标直接访问数据,而链表则需要通过指针进行遍历。
此外,顺序表的内存利用率更高,不需要额外的指针空间来存储下一个节点的地址。
但是顺序表的插入和删除操作相对耗时,需要进行数据的移动操作,而链表的插入和删除则更为方便。
三、顺序表在实际应用中的性能分析顺序表可以广泛应用于各种实际场景中,如数据库系统中的数据表、线性代数中的矩阵运算等。
在实验中,我对顺序表在实际应用中的性能进行了分析。
首先,顺序表的随机存取性能非常优秀。
通过下标可以直接访问数据,无需进行遍历操作,因此在需要频繁进行数据访问的场景下,顺序表的性能优势明显。
其次,顺序表适用于读操作频率远大于写操作的场景。
由于插入和删除操作需要进行数据的移动,因此在写操作频率较高的情况下,顺序表的性能会受到较大的影响。
最后,顺序表的空间复杂度较高。
由于顺序表需要预先分配一定的空间,因此在数据量较大或者变化不确定的情况下,可能会造成空间的浪费。
综上所述,顺序表是一种性能较优的数据结构,能够在实际应用中发挥重要的作用。
通过对顺序表实验的总结与学习,我不仅掌握了顺序表的构建和基本操作,还深入了解了它在不同场景下的性能表现。
数据结构编程实现顺序表的基本操作
数据结构编程实现顺序表的基本操作顺序表是一种基础的数据结构,它是线性表的一种实现方式,它采用连续存储结构来存储线性表的元素。
顺序表中的数据元素存储往往是数值型,它通常用于存储数组和队列等数据结构。
今天我们来学习顺序表的基本操作及其编程实现。
第一步:定义顺序表在编写顺序表的基本操作之前,我们需要先定义一个顺序表的数据结构。
这里我们可以使用结构体来定义一个顺序表的数据类型:```typedef struct {int *data; // 存储空间的基地址int length; // 顺序表的长度int max_size; // 顺序表可存储的最大元素个数} SeqList;```以上定义了一个SeqList结构体类型,包含三个成员:data表示存储空间的基地址,length表示顺序表的元素个数,max_size表示顺序表可存储的最大元素个数。
其中,data采用动态分配内存的方式,可以根据实际需要动态调整顺序表的大小,max_size则是由用户在创建顺序表时指定的。
第二步:实现顺序表的基本操作顺序表的基本操作包括初始化、插入、删除、查找、获取元素等。
下面分别介绍这些操作的实现方法。
1. 初始化操作初始化操作用于创建一个空的顺序表。
它的实现方法如下:```SeqList* init_seq_list(int max_size) {SeqList *list = (SeqList*)malloc(sizeof(SeqList)); // 申请存储空间if (!list) { // 内存申请失败printf("Error: Out of memory!\n");return NULL;}list->data = (int*)malloc(sizeof(int) * max_size); // 申请存储数据的空间if (!list->data) { // 内存申请失败printf("Error: Out of memory!\n");free(list); // 释放存储空间return NULL;}list->length = 0; // 空表长度为0list->max_size = max_size; // 顺序表可存储的最大元素个数 return list; // 返回顺序表指针}```在初始化过程中,我们先申请存储空间,然后再申请存储数据的空间,最后将顺序表的长度设为0,顺序表可存储的最大元素个数设为max_size,返回顺序表的指针。
数据结构实验报告—顺序表
《算法与数据结构》课程实验报告一、实验目的1、实现线性表的顺序存储结构。
2、熟悉C++程序的基本结构,掌握程序中的头文件、实现文件和主文件之间的相互关系及各自的作用。
3、熟悉顺序表的基本操作方式,掌握顺序表相关操作的具体实现。
二、实验内容及要求对顺序存储的线性表进行一些基本操作。
主要包括:(1)插入:操作方式为在指定元素前插入、在指定元素之后插入、在指定位置完成插入。
(2)删除:操作方式可分为删除指定元素、删除指定位置的元素等,尝试实现逻辑删除操作。
(3)显示数据。
(4)查找:查询指定的元素(可根据某个数据成员完成查询操作)。
(5)定位操作:定位指定元素的序号。
(6)更新:修改指定元素的数据。
(7)数据文件的读写操作等。
其它操作可根据具体需要自行补充。
要求线性表采用类的定义,数据对象的类型自行定义。
三、系统分析(1)数据方面:能够实现多种数据类型顺序表的创建,并进行操作,不同的数据类型数据使用不同的文本文件保存。
(2)功能方面:能够实现线性表的一些基本操作,主要包括:1.计算表最大可以容纳表项个数以及当前表的当前长度。
2.能够进行添加操作,在已有的数据文件中进行数据的添加。
3.能够进行搜索操作,返回搜索项在表中表项序号4.能够进行定位操作,定位到表中合理位置。
5.能够进行取值操作,根据用户需求取出表中某项的值。
6.能够进行修改操作,在用户选择修改项后将重新输入内容修改到对应位置。
7.能够进行插入操作,在用户选择合理位置并输入插入内容后即可。
8.能够进行删除操作,用户根据选择表中项数删除对应数据。
9.能够进行判断表空或表满。
四、系统设计(1)设计的主要思路根据实验要求,首先将顺序表模板类完成,并将需要实现的功能代码完善,在写实现各个功能的菜单并将模板类实例化为简单数据类型最后进行调试,由于还需使得顺序表能够存储自定义的学生类类型数据,故根据要求写出Student类,并将之前所写得模板类用学生类数据类型实例化,再进行调试。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
熟练掌握线性表的基本操作在顺序存储结构上的实现掌握顺序表的建立、查找、插入、删除等基本操作。
实验设备(环境):
PC
实验内容:
1、分析、理解程序。
2、完成插入操作的函数设计。
3、调试程序:
建立12个元素的顺序表SqList={c,h,i,n,a,w,e,l,c,o,m,e},分别实现以下操作:
fflush(stdin);
scanf("%c",&x);
j=0;
while( x!='#')
{
L->datas[j]=x;
L->length++; j++;
fflush(stdin);
scanf("%c",&x);
}
}
//查找操作
int LocateElem_Sq(SqList *L, char x)
int k;
if((i<1)||(i>L->length)||(L->length==0))//出错处理,考虑算法的健壮性
printf("error"); //i值不合法或表已空则出错
else{
for (k=i; k<L->length; k++)//将第i+1至第n个元素逐一向前移一个位置
L->datas[k-1]=L->datas[k];
}
//求顺序表长度
int Get_length(SqList *L)
{
return L->length;
}
//插入操作
void ListInsert_Sq (SqList *L,int i,char e)
{//在顺序表L的第i个位置前插入一个新的元素e
int k;
if((i<1)||(i>L->length)||(L->length>=MAXSIZE))
{ //在顺序线性表L中查找第1个值与x相等的元素,若找到,则返回其在L中的位序,否则返回0
int k;
k=1; //k的初值为第1个元素的位序
while(k<=L->length && L->datas[k-1]!=x) k++;
if(k<=L->length)
return k;
else
return 0;
L->length=L->length-1; //将顺序表的长度减1
}
}
//输出顺序表
void PRINT(SqList *L)
{int i;
printf("顺序表的当前值为:\n");
for(i=0;i<L->length;i++)
printf("%c ",L->datas[i]);
printf("\n");
scanf("%d",&k);
while( k<0 || k>6)
{
printf("您只能选择0-6,请重新输入:");
scanf("%d",&k);
}
while( k>=0 && k<=6)
{
switch(k)
{
case 0: exit(0);
case 1: creat_Sq(L);
break;
case 2: printf("请输入待查找的元素x:");
scanf("%d",&k);
}
}
2.调试结果
(1)
(2)
(3)
实验总结(包括过程总结、心得体会及实验改进意见等):
具体了解了顺序表的基本操作,在删除操作中首先要判断位置i是否存在,若不存在,则给出错误信息,若存在,则将位置i+1之后的所有数据元素分别向上移动一个位置。在进行插入操作之前首先要判断位置i是否存在,若不存在,则给出错误信息,若存在,则进行插入操作。
}
main()
{SqList * L;
int k;
int i;
char x;
//初始化顺序表
L=(SqList *)malloc(sizeof(SqList));
L->length=0; //空表长度为0
printf("请选择您要进行的操作:\n");
printf("0:退出\n");
printf("1:建立顺序表L\n");
struct SqList
{
char datas[MAXSIZE];
int length;
};
typedef struct SqList SqList;
//建立顺序表L
void creat_Sq(SqList *L)
{
char x; int j;
//按要求建立顺序表
printf("按要求输入顺序表初始时的元素(切换用回车),以#结束:\n");
指导教师评语:
成绩评定
教师签字
年月日
备注:
注:1、报告内的项目或设置,可根据实际情况加以补充和调整
2、教师批改学生实验报告应在学生提交实验报告10日内
fflush(stdin);
scanf("%c",&x);
printf("%d在顺序表中的位序为:%d\n",x,LocateElem_Sq(L, x));
break;
case 3: printf("顺序表的长度为:%d\n",Get_length(L));
break;
case 4: printf("请输入待插入元素的位置i及元素的值x:");
1)查找元素y在SqList中的位序,输出为O则表示“y不在SqList中”;
2)在SqList的元素6之前插入一个新元素#,输出插入后的结果;
3)删除SqList中第8个元素,输出删除后的结果
实验步骤、实验结果及分析:
1.代码
#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 30
break;
default: printf("您只能选择0-6,请重新输入:");
}
printf("--******************************--\n");
printf("请选择您要进行的操作:\n");
printf("0:退出\n");
printf("1:建立顺序表L\n");
printf("2:查找操作(查找某个元素的位序)\n");
printf("3:求顺序表的长度\n");
printf("4:插入操作(在顺序表L的第i个位置前插入一个新元素e)\n");
printf("5:删除操作(删除顺序表L中的第i元素)\n");
printf("6:输出操作(输出顺序表的当前值)\n");
printf("2:查找操作(查找某个元素的位序)\n");
printf("3:求顺序表的长度\n");
printf("4:插入操作(在顺序表L的第i个位置前插入一个新元素e)\n");
printf("5:删除操作(删除顺序表L中的第i元素)\n");
printf("6:输出操作(输出顺序表的当前值)\n");
printf("error");
else
{for(k=L->length;k>=i;k--)
L->datas[k]=L->datas[k-1];
L->datas[i-1]=e;L->length++;}}
//删除操作
void ListDelete_Sq(SqList *L,int i)
{//在顺序表L中删除第i个数据元素
scanf("%d",&i);
fflush(stdin);
scanf("%c",&x);
ListInsert_Sq (L,i,x);
break;
case 5: printf("请输入待删除元素的位置i:");
scanf("%d",&i);
ListDelete_Sq(L,i);
break;
case 6: PRINT(L);