数据结构实验一 顺序表的实现

合集下载

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

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

数据结构实验一顺序表实验报告
数据结构是计算机科学中的一门基础课程,在学习数据结构的过程中,顺序表是我们必须深入了解和掌握的重要数据结构之一。

在实验一中,我们对顺序表进行了一系列的操作,实现了增删改查等基本操作。

我们先来介绍一下顺序表的基本概念。

顺序表是将线性表中的数据存储在一段连续的存储空间中的数据结构,其查找效率高,但插入和删除操作效率较低。

顺序表需要预先分配一定的存储空间,当存储空间不足时需要进行动态扩容,即重新申请更大的存储空间并将原有数据复制到新的存储空间中。

在实验中,我们首先学习了顺序表的实现方式,包括顺序表的结构体定义、创建顺序表、插入元素、删除元素、修改元素以及查询元素等基本操作。

我们通过 C 语言来实现了这些操作,并将其封装成一个顺序表的 API,使其更加易于使用和维护。

在实验过程中,我们还发现顺序表中数据的存储顺序非常重要,因为顺序表中元素的存储顺序与元素的下标是一一对应的,如果存储的顺序错误,可能会导致元素的下标与我们想象中的不一致,从而造成一些意想不到的结果。

总的来说,实验一帮助我们更深入地了解了顺序表的实现方式和基本操作,同时也挖掘出了一些潜在问题,这对于我们今后的学习和实践都起到了很大的帮助。

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

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

实验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.顺序表的建立和基本运算成绩专业班级*** 指导教师***姓名*** 学号*** 实验日期***实验一顺序表的建立和基本运算一、实验目的1、掌握顺序表存储结构的定义及C/C++语言实现2、掌握顺序表的各种基本操作及C/C++语言实现3、设计并实现有序表的遍历、插入、删除等常规算法二、实验环境PC微机,Windows,DOS,Turbo C或者Visual C++三、实验内容1、顺序表的建立和基本运算(1)问题描述顺序表时常进行的运算包括:创建顺序表、销毁顺序表、求顺序表的长度、在顺序表中查找某个数据元素、在某个位置插入一个新数据元素、在顺序表中删除某个数据元素等操作。

试编程实现顺序表的这些基本运算。

(2)基本要求实现顺序表的每一个运算要求用一个函数实现。

(3)算法描述参见教材算法2.3、算法2.4、算法2.5等顺序表的常规算法。

(4)算法实现#include<malloc.h> // malloc()等#include<stdio.h> // NULL, printf()等#include<process.h> // exit()// 函数结果状态代码#define OVERFLOW -2#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1typedef int Status; // Status是函数的类型,其值是函数结果状态代码,如OK等typedef int Boolean; // Boolean是布尔类型,其值是TRUE或者FALSE//-------- 线性表的动态分配顺序存储结构-----------#define LIST_INIT_SIZE 10 // 线性表存储空间的初始分配量#define LIST_INCREMENT 2 // 线性表存储空间的分配增量typedef int ElemType;struct SqList{ElemType *elem; // 存储空间基址int length; // 当前长度int listsize; // 当前分配的存储容量(以sizeof(int)为单位)};void InitList(SqList &L) // 算法2.3{ // 操作结果:构造一个空的顺序线性表LL.elem=new ElemType[LIST_INIT_SIZE];if(!L.elem)exit(OVERFLOW); // 存储分配失败L.length=0; // 空表长度为0L.listsize=LIST_INIT_SIZE; // 初始存储容量}void DestroyList(SqList &L){ // 初始条件:顺序线性表L已存在。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

数据结构实验一顺序表的实现

数据结构实验一顺序表的实现

算法分析实验一顺序表的实现班级学号姓名分数一、实验目的:1.掌握线性表的顺序存储结构2.能熟练地利用顺序存储结构实现线性表的基本操作3.能熟练地掌握顺序存储结构中算法的实现二、实验要求熟悉线形表的基本操作,对线形表能够进行插入、删除、修改、查找等操作。

三、实验内容及分析:建立含有若干个元素的顺序表,并将结果在屏幕上输出。

对刚建立的顺序表实现插入、删除、修改、查找,并将结果在屏幕上输出。

内容分析:先建立一个顺序表,定义表的最大长度为100,程序可以实现输出、查找、插入、删除操作。

先定义一个整型变量i,用于初始线性表的长度,再输入所有元素,选择菜单里的选项实现功能。

插入:选择需插入元素的位置,插入位置及后面的元素后移一位,再插入元素;删除:选择要删除元素的位置,将要删除的元素移出顺序表,删除位置后的元素前移一位;查找:输入要查找的元素,按顺序查找,当查找到顺序表的第一个与要查找的元素相同时,输出结果。

四、程序的调试及运行结果五、程序代码#include <iostream>using namespace std;const int Max=100; <<endl;cout <<endl;initial(s); 示所有元素. " <<endl;cout <<" 2.插入一个元素." <<endl;cout <<" 3.删除一个元素." <<endl;cout <<" 4.查找一个元素." <<endl;cout <<" 5.结束程序." <<endl;cout <<"---------------------------" <<endl;cout <<"请选择:" ;cin >>j;switch(j){case '1':print(s);break; 2 a <<endl;else if(temp==true)print(s);break;}case '3':{cout <<"请输入要删除元素的位置: ";cin >>loc; //输入要删除的元素的位置temp=del(s,loc,ch); //删除检查if(temp==true)cout <<"删除了一个元素: " <<ch <<endl;elsecout <<"该元素不存在!" <<endl;print(s);break;}case '4':{cout <<"请输入要查找的元素: " ;cin >>ch; //输入要查找的元素loc=locate(s,ch); //寻找元素的位置if(loc!=-1){cout <<"该元素所在位置: " ;cout <<(loc+1) <<endl;}elsecout <<"该元素不存在!" <<endl;break;}default:flag=0;cout <<"程序结束,按任意键退出!" <<endl;}}}//初始化线性表void initial(seqlist &v){int i;cout <<"请输入初始线性表长度:n=";cin >>;c out <<"请输入各元素/字符[中间用空格隔开](例如:a b c d): ";for(i=0;i<;i++)cin >>&[i];}//插入一个元素,成功返回True,失败返回Falsebool insert (seqlist &v,int loc,char ch){int i;i f((loc<1)||(loc>+1)){cout <<"插入位置不合理!" <<endl; //位置错误return false;}else if>=Max){cout <<"超出线性表最大容量!" <<endl; //溢满return false;}else{for(i=;i>=loc-1;i--)[i+1]=[i]; //插入位置后的元素后移[loc-1]=ch; //插入元素++; //表长度加1return true;}}//删除一个元素,成功返回True,并用ch返回该元素值,失败返回False bool del(seqlist &v,int loc,char &ch){int j;if(loc<1||loc>{cout <<"删除位置不合理!" <<endl;return false;}else{ch=[loc-1]; //将删除位置的元素赋给chfor(j=loc-1;j<;j++)[j]=[j+1]; //删除位置后元素前移; //表长度减1return true;}}//在线性表中查找ch的位置,成功返回其位置,失败返回-1 int locate(seqlist v,char ch){int i=0;w hile(i<&&[i]!=ch)i++;if[i]==ch)return i;else return (-1);}//显示线性表的所有元素void print(seqlist v){int i;for(i=0;i<;i++)cout <<[i] <<' ';cout <<endl;}。

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

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

数据结构实验报告顺序表1一、实验目的本次实验的主要目的是深入理解和掌握顺序表这种数据结构的基本概念、存储方式和操作方法,并通过实际编程实现,提高对数据结构的实际应用能力和编程技能。

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

三、顺序表的基本概念顺序表是用一组地址连续的存储单元依次存储线性表中的数据元素。

在顺序表中,逻辑上相邻的元素在物理位置上也相邻。

顺序表可以随机访问表中的任意元素,但插入和删除操作可能需要移动大量元素,效率较低。

四、顺序表的存储结构在 C++中,可以使用数组来实现顺序表。

以下是一个简单的顺序表存储结构的定义:```cppconst int MAX_SIZE = 100; //定义顺序表的最大容量class SeqList {private:int dataMAX_SIZE; //存储数据元素的数组int length; //顺序表的当前长度public:SeqList(){ length = 0; }//构造函数,初始化长度为 0//其他操作函数的声明int GetLength();bool IsEmpty();bool IsFull();int GetElement(int position);int LocateElement(int element);void InsertElement(int position, int element);void DeleteElement(int position);void PrintList();};```五、顺序表的基本操作实现1、获取顺序表长度```cppint SeqList::GetLength(){return length;}```2、判断顺序表是否为空```cppbool SeqList::IsEmpty(){return length == 0;}```3、判断顺序表是否已满```cppbool SeqList::IsFull(){return length == MAX_SIZE;}```4、获取指定位置的元素```cppint SeqList::GetElement(int position) {if (position < 1 || position > length) {std::cout <<"位置错误!"<< std::endl; return -1;}return dataposition 1;}```5、查找指定元素在顺序表中的位置```cppint SeqList::LocateElement(int element) {for (int i = 0; i < length; i++){if (datai == element) {return i + 1;}}return -1; //未找到返回-1}```6、在指定位置插入元素```cppvoid SeqList::InsertElement(int position, int element) {if (IsFull()){std::cout <<"顺序表已满,无法插入!"<< std::endl; return;}if (position < 1 || position > length + 1) {std::cout <<"位置错误!"<< std::endl;return;}for (int i = length; i >= position; i) {datai = datai 1;}dataposition 1 = element;length++;}```7、删除指定位置的元素```cppvoid SeqList::DeleteElement(int position) {if (IsEmpty()){std::cout <<"顺序表为空,无法删除!"<< std::endl; return;}if (position < 1 || position > length) {std::cout <<"位置错误!"<< std::endl;return;}for (int i = position; i < length; i++){datai 1 = datai;}length;}```8、打印顺序表中的所有元素```cppvoid SeqList::PrintList(){for (int i = 0; i < length; i++){std::cout << datai <<"";}std::cout << std::endl;}```六、实验结果与分析1、对顺序表进行初始化,创建一个空的顺序表。

数据结构实验报告-实验一顺序表、单链表基本操作的实现

数据结构实验报告-实验一顺序表、单链表基本操作的实现

数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现l 实验⽬的1、顺序表(1)掌握线性表的基本运算。

(2)掌握顺序存储的概念,学会对顺序存储数据结构进⾏操作。

(3)加深对顺序存储数据结构的理解,逐步培养解决实际问题的编程能⼒。

l 实验内容1、顺序表1、编写线性表基本操作函数:(1)InitList(LIST *L,int ms)初始化线性表;(2)InsertList(LIST *L,int item,int rc)向线性表的指定位置插⼊元素;(3)DeleteList1(LIST *L,int item)删除指定元素值的线性表记录;(4)DeleteList2(LIST *L,int rc)删除指定位置的线性表记录;(5)FindList(LIST *L,int item)查找线性表的元素;(6)OutputList(LIST *L)输出线性表元素;2、调⽤上述函数实现下列操作:(1)初始化线性表;(2)调⽤插⼊函数建⽴⼀个线性表;(3)在线性表中寻找指定的元素;(4)在线性表中删除指定值的元素;(5)在线性表中删除指定位置的元素;(6)遍历并输出线性表;l 实验结果1、顺序表(1)流程图(2)程序运⾏主要结果截图(3)程序源代码#include<stdio.h>#include<stdlib.h>#include<malloc.h>struct LinearList/*定义线性表结构*/{int *list; /*存线性表元素*/int size; /*存线性表长度*/int Maxsize; /*存list数组元素的个数*/};typedef struct LinearList LIST;void InitList(LIST *L,int ms)/*初始化线性表*/{if((L->list=(int*)malloc(ms*sizeof(int)))==NULL){printf("内存申请错误");exit(1);}L->size=0;L->Maxsize=ms;}int InsertList(LIST *L,int item,int rc)/*item记录值;rc插⼊位置*/ {int i;if(L->size==L->Maxsize)/*线性表已满*/return -1;if(rc<0)rc=0;if(rc>L->size)rc=L->size;for(i=L->size-1;i>=rc;i--)/*将线性表元素后移*/L->list[i+=1]=L->list[i];L->list[rc]=item;L->size++;return0;}void OutputList(LIST *L)/*输出线性表元素*/{int i;printf("%d",L->list[i]);printf("\n");}int FindList(LIST *L,int item)/*查找线性元素,返回值>=0为元素的位置,返回-1为没找到*/ {int i;for(i=0;i<L->size;i++)if(item==L->list[i])return i;return -1;}int DeleteList1(LIST *L,int item)/*删除指定元素值得线性表记录,返回值为>=0为删除成功*/ {int i,n;for(i=0;i<L->size;i++)if(item==L->list[i])break;if(i<L->size){for(n=i;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return i;}return -1;}int DeleteList2(LIST *L,int rc)/*删除指定位置的线性表记录*/{int i,n;if(rc<0||rc>=L->size)return -1;for(n=rc;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return0;}int main(){LIST LL;int i,r;printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.size,LL.Maxsize);printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.list,LL.Maxsize);while(1){printf("请输⼊元素值,输⼊0结束插⼊操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d",&i);if(i==0)break;printf("请输⼊插⼊位置:");scanf("%d",&r);InsertList(&LL,i,r-1);printf("线性表为:");OutputList(&LL);}while(1){printf("请输⼊查找元素值,输⼊0结束查找操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d ",&i);if(i==0)break;r=FindList(&LL,i);if(r<0)printf("没有找到\n");elseprintf("有符合条件的元素,位置为:%d\n",r+1);}while(1){printf("请输⼊删除元素值,输⼊0结束查找操作:");fflush(stdin);/*清楚标准缓存区*/scanf("%d",&i);if(i==0)break;r=DeleteList1(&LL,i);if(i<0)printf("没有找到\n");else{printf("有符合条件的元素,位置为:%d\n线性表为:",r+1);OutputList(&LL);}while(1){printf("请输⼊删除元素位置,输⼊0结束查找操作:");fflush(stdin);/*清楚标准输⼊缓冲区*/scanf("%d",&r);if(r==0)break;i=DeleteList2(&LL,r-1);if(i<0)printf("位置越界\n");else{printf("线性表为:");OutputList(&LL);}}}链表基本操作l 实验⽬的2、链表(1)掌握链表的概念,学会对链表进⾏操作。

数据结构-顺序表的基本操作的实现-课程设计-实验报告

数据结构-顺序表的基本操作的实现-课程设计-实验报告

数据结构-顺序表的基本操作的实现-课程设计-实验报告顺序表的基本操作的实现一、实验目的1、掌握使用VC++上机调试顺序表的基本方法;2、掌握顺序表的基本操作:建立、插入、删除等运算。

二、实验仪器安装VC++软件的计算机。

三、实验原理利用线性表的特性以及顺序存储结构特点对线性表进行相关的基本操作四、实验内容程序中演示了顺序表的创建、插入和删除。

程序如下:#include#include/*顺序表的定义:*/#define ListSize 100typedef struct{ int data[ListSize]; /*向量data用于存放表结点*/i nt length; /*当前的表长度*/}SeqList;void main(){ void CreateList(SeqList *L,int n);v oid PrintList(SeqList *L,int n);i nt LocateList(SeqList *L,int x);v oid InsertList(SeqList *L,int x,int i);v oid DeleteList(SeqList *L,int i);SeqList L;i nt i,x;i nt n=10;L.length=0;c lrscr();C reateList(&L,n); /*建立顺序表*/P rintList(&L,n); /*打印建立后的顺序表*/p rintf("INPUT THE RESEARCH ELEMENT");s canf("%d",&x);i=LocateList(&L,x);p rintf("the research position is %d\n",i); /*顺序表查找*/ p rintf("input the position of insert:\n");s canf("%d",&i);p rintf("input the value of insert\n");s canf("%d",&x);I nsertList(&L,x,i); /*顺序表插入*/P rintList(&L,n); /*打印插入后的顺序表*/p rintf("input the position of delete\n");s canf("%d",&i);D eleteList(&L,i); /*顺序表删除*/P rintList(&L,n); /*打印删除后的顺序表*/g etchar();}/*顺序表的建立:*/void CreateList(SeqList *L,int n){int i;printf("please input n numbers\n");for(i=1;i<=n;i++)scanf("%d",&L->data[i]);L->length=n;}/*顺序表的打印:*/void PrintList(SeqList *L,int n){int i;printf("the sqlist is\n");for(i=1;i<=n;i++)printf("%d ",L->data[i]);}/*顺序表的查找:*/int LocateList(SeqList *L,int x){int i;for(i=1;i<=10;i++)if((L->data[i])==x) return(i);else return(0);}/*顺序表的插入:*/void InsertList(SeqList *L,int x,int i){int j;for(j=L->length;j>=i;j--)L->data[j+1]=L->data[j];L->data[i]=x;L->length++;}void DeleteList(SeqList *L,int i) /*顺序表的删除:*/ { int j;for(j=i;j<=(L->length)-1;j++)L->data[j]=L->data[j+1];}五、实验步骤1、认真阅读和掌握本实验的程序。

数据结构实验报告顺序表

数据结构实验报告顺序表

数据结构实验报告顺序表数据结构实验报告:顺序表一、引言数据结构是计算机科学的重要基础,它研究数据的组织方式和操作方法。

顺序表是一种常见的数据结构,它以数组的形式存储数据元素,具有随机访问和插入删除方便的特点。

本实验旨在深入理解顺序表的实现原理和操作方法,并通过实验验证其性能。

二、实验目的1. 掌握顺序表的基本概念和实现原理;2. 熟悉顺序表的插入、删除、查找等操作;3. 分析顺序表的时间复杂度,并进行性能测试。

三、实验过程1. 顺序表的定义和初始化顺序表是一种线性表,它以一组连续的存储单元来存储数据元素。

在实验中,我们使用数组来实现顺序表。

首先,定义一个结构体来表示顺序表,包括数据元素和当前长度等信息。

然后,通过动态分配内存来初始化顺序表。

2. 插入元素顺序表的插入操作是将一个新元素插入到指定位置,同时移动后面的元素。

在实验中,我们可以通过循环将后面的元素依次向后移动,然后将新元素放入指定位置。

3. 删除元素顺序表的删除操作是将指定位置的元素删除,并将后面的元素依次向前移动。

在实验中,我们可以通过循环将后面的元素依次向前移动,然后将最后一个元素置为空。

4. 查找元素顺序表的查找操作是根据指定的值查找元素所在的位置。

在实验中,我们可以通过循环遍历顺序表,逐个比较元素的值,找到匹配的位置。

五、实验结果与分析在实验中,我们通过插入、删除、查找等操作对顺序表进行了测试,并记录了操作所需的时间。

通过分析实验结果,我们可以得出以下结论:1. 顺序表的插入操作的时间复杂度为O(n),其中n为元素的个数。

因为插入操作需要移动后面的元素,所以时间复杂度与元素个数成正比。

2. 顺序表的删除操作的时间复杂度也为O(n),与插入操作相同,需要移动后面的元素。

3. 顺序表的查找操作的时间复杂度为O(n),需要逐个比较元素的值。

六、结论通过本次实验,我们深入理解了顺序表的实现原理和操作方法。

顺序表以数组的形式存储数据,具有随机访问和插入删除方便的特点。

数据结构顺序表操作实验报告

数据结构顺序表操作实验报告

实验1 顺序表的操作一、实验要求1.输入一组整型元素序列,建立顺序表。

2.实现该顺序表的遍历。

3.在该顺序表中进行顺序查找某一元素,查找成功返回1,否则返回0。

4.判断该顺序表中元素是否对称,对称返回1,否则返回0。

5.实现把该表中所有奇数排在偶数之前,即表的前面为奇数,后面为偶数。

6.* 输入整型元素序列利用有序表插入算法建立一个有序表。

7.* 利用算法6建立两个非递减有序表并把它们合并成一个非递减有序表。

8.编写一个主函数,调试上述算法。

二、源代码#include"stdio.h"#include"stdlib.h"#define ElemType int//int类型宏定义#define MAXSIZE 100//顺序结构typedef struct{ElemType elem[MAXSIZE]; //元素数组int length; //当前表长}SqList;//建立顺序表void BuildList(SqList &L){int n;printf("请输入建立顺序表的大小。

n=");scanf("%d",&n);L.length=n;printf("\n开始建立顺序表...\n");for(int i=0;i<L.length;i++)//循环建立顺序表{printf("\n请输入第%d个元素:",i+1);scanf("%d",&L.elem[i]);}printf("\n建立顺序表完毕!...\n");}//遍历顺序表void ShowList(SqList &L){int i;printf("\n开始遍历顺序表...\n");for(i=0;i<L.length;i++)printf("%d ",L.elem[i]);printf("\n遍历结束...\n");}//在顺序表中寻找X元素int FindList(SqList &L,int x){int a=0;for(int i=0;i<L.length;i++){if(L.elem[i]==x)a=1;}if(a==1)printf("1\n");elseprintf("0\n");return 0;}//判断是否对称int Duichen(SqList &L){int j,b=1,n;n=L.length;if(n%2==0){for(j=0;j<n/2;j++){if(L.elem[j]!=L.elem[L.length-j-1])b=0;}}elsefor(j=0;j<(n-1)/2;j++){if(L.elem[j]!=L.elem[L.length-j-1])b=0;}if(b==1)printf("1\n");elseprintf("0\n");return 0;}//前面为奇数,后面为偶数void PaixuList(SqList &L){int i,j,a;for(i=1;i<L.length;i++){if(L.elem[i]%2==1){a=L.elem[i];for(j=i;j>0;j--){L.elem[j]=L.elem[j-1];}L.elem[0]=a;i++;}}for(i=0;i<L.length;i++)printf("%d ",L.elem[i]);printf("\n");}int main(){SqList List;int n;while(1){printf("\n 实验一:顺序表\n");printf("\n******************************************************************");printf("\n 1.创建顺序表");printf("\n 2.遍历顺序表");printf("\n 3.在该顺序表中进行顺序查找某一元素,查找成功返回1,否则返回0");printf("\n 4.判断该顺序表中元素是否对称,对称返回1,否则返回0");printf("\n 5.该表中所有奇数排在偶数之前,即表的前面为奇数,后面为偶数");printf("\n 0.退出");printf("\n******************************************************************\n");printf("\n请输入选择序号:");scanf("%d",&n);switch(n){case 0:return 0;case 1:BuildList(List);break;case 2:ShowList(List);break;case 3:int X;printf("请输入要查找值:X=");scanf("%d",&X);FindList(List,X);break;case 4:Duichen(List);break;case 5:PaixuList(List);break;default:printf(" 请输入数字0-5 \n");}}return 0;}三、运行结果1)程序主界面2)选择1建立顺序表3)选择2遍历顺序表4)选择3查询元素X5)选择4判断是否对称6)选择5奇数在前,偶数在后7)选择0退出。

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

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

数据结构实验一顺序表实验报告数据结构实验一顺序表实验报告一、实验目的顺序表是一种基本的数据结构,本次实验的目的是通过实现顺序表的基本操作,加深对顺序表的理解,并掌握顺序表的插入、删除、查找等操作的实现方法。

二、实验内容1. 实现顺序表的创建和初始化操作。

2. 实现顺序表的插入操作。

3. 实现顺序表的删除操作。

4. 实现顺序表的查找操作。

5. 实现顺序表的输出操作。

三、实验步骤1. 创建顺序表的数据结构,包括数据存储数组和记录当前元素个数的变量。

2. 初始化顺序表,将当前元素个数置为0。

3. 实现顺序表的插入操作:- 判断顺序表是否已满,若已满则输出错误信息。

- 将插入位置之后的元素依次后移一位。

- 将要插入的元素放入插入位置。

- 当前元素个数加一。

4. 实现顺序表的删除操作:- 判断顺序表是否为空,若为空则输出错误信息。

- 判断要删除的位置是否合法,若不合法则输出错误信息。

- 将删除位置之后的元素依次前移一位。

- 当前元素个数减一。

5. 实现顺序表的查找操作:- 遍历顺序表,逐个比较元素值与目标值是否相等。

- 若找到目标值,则返回该元素的位置。

- 若遍历完整个顺序表仍未找到目标值,则返回错误信息。

6. 实现顺序表的输出操作:- 遍历顺序表,逐个输出元素值。

四、实验结果经过实验,顺序表的各项操作均能正确实现。

在插入操作中,可以正确将元素插入到指定位置,并将插入位置之后的元素依次后移。

在删除操作中,可以正确删除指定位置的元素,并将删除位置之后的元素依次前移。

在查找操作中,可以正确返回目标值的位置。

在输出操作中,可以正确输出顺序表中的所有元素。

五、实验总结通过本次实验,我深入了解了顺序表的原理和基本操作,并通过实际编程实现了顺序表的各项功能。

在实验过程中,我遇到了一些问题,如如何判断顺序表是否已满或为空,如何处理插入和删除位置的合法性等。

通过查阅资料和与同学讨论,我解决了这些问题,并对顺序表的操作有了更深入的理解。

数据结构实验报告顺序表

数据结构实验报告顺序表

数据结构实验报告顺序表数据结构实验报告:顺序表摘要:顺序表是一种基本的数据结构,它通过一组连续的存储单元来存储线性表中的数据元素。

在本次实验中,我们将通过实验来探索顺序表的基本操作和特性,包括插入、删除、查找等操作,以及顺序表的优缺点和应用场景。

一、实验目的1. 理解顺序表的概念和特点;2. 掌握顺序表的基本操作;3. 了解顺序表的优缺点及应用场景。

二、实验内容1. 实现顺序表的初始化操作;2. 实现顺序表的插入操作;3. 实现顺序表的删除操作;4. 实现顺序表的查找操作;5. 对比顺序表和链表的优缺点;6. 分析顺序表的应用场景。

三、实验步骤与结果1. 顺序表的初始化操作在实验中,我们首先定义了顺序表的结构体,并实现了初始化操作,即分配一定大小的存储空间,并将表的长度设为0,表示表中暂时没有元素。

2. 顺序表的插入操作接下来,我们实现了顺序表的插入操作。

通过将插入位置后的元素依次向后移动一位,然后将新元素插入到指定位置,来实现插入操作。

我们测试了在表中插入新元素的情况,并验证了插入操作的正确性。

3. 顺序表的删除操作然后,我们实现了顺序表的删除操作。

通过将删除位置后的元素依次向前移动一位,来实现删除操作。

我们测试了在表中删除元素的情况,并验证了删除操作的正确性。

4. 顺序表的查找操作最后,我们实现了顺序表的查找操作。

通过遍历表中的元素,来查找指定元素的位置。

我们测试了在表中查找元素的情况,并验证了查找操作的正确性。

四、实验总结通过本次实验,我们对顺序表的基本操作有了更深入的了解。

顺序表的插入、删除、查找等操作都是基于数组的操作,因此在插入和删除元素时,需要移动大量的元素,效率较低。

但是顺序表的优点是可以随机访问,查找效率较高。

在实际应用中,顺序表适合于元素数量不变或变化不大的情况,且需要频繁查找元素的场景。

综上所述,顺序表是一种基本的数据结构,我们通过本次实验对其有了更深入的了解,掌握了顺序表的基本操作,并了解了其优缺点及应用场景。

数据结构实验一(顺序表基本操作)题目和源程序

数据结构实验一(顺序表基本操作)题目和源程序

实验1:顺序表基本操作一、实验目的1.学会定义线性表的顺序存储类型,实现C程序的基本结构,对线性表的一些基本操作和具体的函数定义。

2.掌握顺序表的基本操作,实现顺序表的插入、删除、查找以及求并集等运算。

3.掌握对多函数程序的输入、编辑、调试和运行过程。

二、实验要求1.预习C语言中结构体的定义与基本操作方法。

2.对顺序表的每个基本操作用单独的函数实现。

3.编写完整程序完成下面的实验内容并上机运行。

4.整理并上交实验报告。

三、实验内容:1.编写程序实现顺序表的下列基本操作:(1)初始化顺序表La。

(2)将La置为空表。

(3)销毁La。

(4)在La中插入一个新的元素。

(5)删除La中的某一元素。

(6)在La中查找某元素,若找到,则返回它在La中第一次出现的位置,否则返回0。

(7)打印输出La中的元素值。

2.编写程序完成下面的操作:(1)构造两个顺序线性表La和Lb,其元素都按值非递减顺序排列。

(2)实现归并La和Lb得到新的顺序表Lc,Lc的元素也按值非递减顺序排列。

(3)假设两个顺序线性表La和Lb分别表示两个集合A和B,利用union_Sq操作实现A=A∪B。

四、思考与提高假设两个顺序线性表La和Lb分别表示两个集合A和B,如何实现A=A ∩B ?/*----------------------------------------* 01_顺序表.cpp -- 顺序表基本操作* 对顺序表的每个基本操作都用单独的函数来实现* 水上飘2009年写----------------------------------------*/// ds01.cpp : 定义控制台应用程序的入口点。

#include "stdafx.h"#include<iostream>#include<cstdlib>#include<iomanip>#include<ctime>#define LIST_INIT_SIZE 100#define LISTINCREMENT 10using namespace std;typedef struct {double *elem; //存储空间基址int length; //当前长度int listsize; //当前分配的存储容量}Sqlist;//构造一个空的线性表Sqlist InitList( Sqlist &L ){L.elem = (double *)malloc(LIST_INIT_SIZE * sizeof(double)) ;if( !L.elem ) exit( -2 ) ; //存储分配失败L.length = 0 ; //空表长度为0L.listsize = LIST_INIT_SIZE ; //初始存储容量return L ;}//给线性表随机赋值void Start( Sqlist &L, int a ){L.length = a ;for( int i = 0; i < a; i++ )L.elem[i] = rand( ) % 100 ;}//输出线性表的值void Output( Sqlist &L ){int m ;m = L.length ;for( int i = 0; i < m; i++ ){if( i % 10 == 0 )cout << endl ;cout << setw(5) << L.elem[i] ;}cout << endl ;}//使线性表按值非递减排列void Notdegression( Sqlist &L, int a ){int m, n ;n = a - 1 ;while( n ){for( int i = 0; i < (a-1); i++ ){if( L.elem[i] > L.elem[i+1] ){m = L.elem[i] ;L.elem[i] = L.elem[i+1] ;L.elem[i+1] = m ;}else continue ;}n-- ;a-- ;}}//归并La和Lb,得到元素也按非递减排列的Lcvoid Merger( Sqlist &La, Sqlist &Lb, Sqlist &Lc ){double *pa, *pb, *pc, *pa_last, *pb_last ;pa = La.elem ; //pa指向La的基地址pb = Lb.elem ; //pb指向Lb的基地址Lc.listsize = Lc.length = La.length + Lb.length ;pc = Lc.elem = (double *)malloc(Lc.listsize * sizeof(double)) ;if( !Lc.elem ) exit( -2 ) ; //存储分配失败pa_last = La.elem + La.length - 1 ; //La表尾元素的位置pb_last = Lb.elem + Lb.length - 1 ; //Lb表尾元素的位置while( pa <= pa_last && pb <= pb_last ) //归并La和Lb于Lc{if( *pa < *pb )*pc++ = *pa++ ;else*pc++ = *pb++ ;}while( pa <= pa_last )*pc++ = *pa++ ; //插入La的剩余元素while( pb <= pb_last )*pc++ = *pb++ ; //插入Lb的剩余元素}//实现A = A ∪Bvoid Union_sq( Sqlist &La, Sqlist &Lb ){double *pa, *pb, *pa_last, *pb_last, *p ;pa = La.elem ; //pa指向La的基地址pb = Lb.elem ; //pb指向Lb的基地址pb_last = Lb.elem + Lb.length - 1 ; //La表尾元素的位置pa_last = La.elem + La.length - 1 ; //Lb表尾元素的位置La.listsize += Lb.listsize ;while( pa < pa_last ) /*除去La中相等的元素,只留下相等元素中的一个*/{if( *pa == *(pa+1) ){p = pa ;for( ++p; p <= pa_last; p++ )*(p-1) = *p ; //被删除元素之后的元素左移La.length-- ;}pa++ ;}pa_last = La.elem + La.length - 1 ;while( pb <= pb_last ) //将Lb的元素插入到La中{while( *pa != *pb && pa <= pa_last )pa++ ; //判断*pb是否与La中的某一元素相等if( pa == (pa_last+1) ){*(pa++) = *pb++ ;La.length++ ; //La的当前长度增一}elsepb++ ;pa = La.elem ;pa_last = La.elem + La.length - 1 ;}}int main( ){Sqlist La; Sqlist Lb; Sqlist Lc ;int a, b ;cout << "请输入La的元素个数:" ;cin >> a ;cout << endl << "请输入Lb的元素个数:" ;cin >> b ;cout << endl ;srand(time(NULL)) ;La = InitList( La ) ; //构造线性表LaLb = InitList( Lb ) ; //构造线性表LbStart( La, a ) ;cout << "La随机生成的值:" << endl ;Output( La ) ;Start( Lb, b ) ;cout << "Lb随机生成的值:" << endl ;Output( Lb ) ;//cin.get();Notdegression( La, a ) ; //使La元素按非递减排列cout << "La的值按非递减顺序排列:" << endl ;Output( La ) ;Notdegression( Lb, b ) ; //使Lb元素按非递减排列cout << "Lb的值按非递减顺序排列:" << endl ;Output( Lb ) ;Merger( La, Lb, Lc ) ; //归并La和Lb于Lccout << "归并La和Lb于Lc,也为非递减排列:" << endl ;Output( Lc ) ;Union_sq( La, Lb ) ; //实现A = A ∪Bcout << "实现A = A ∪B:" << endl ;Output( La ) ;}。

数据结构实验一顺序表的实现

数据结构实验一顺序表的实现

数据结构实验⼀顺序表的实现数据结构实验⼀顺序表的实现数据结构实验⼀顺序表的实现班级学号姓名分数⼀、实验⽬的:1. 熟悉线性表的基本运算在两种存储结构(顺序结构和链式结构)上的实现;2. 以线性表的各种操作的实现为重点;3. 通过本次学习帮助学⽣加深C语⾔的使⽤,掌握算法分析⽅法并对已经设计出的算法进⾏分析,给出相应的结果。

⼆、实验要求:编写实验程序,上机运⾏本程序,保存程序的运⾏结果,结合程序进⾏分析并写出实验报告。

三、实验内容及分析:1.顺序表的建⽴建⽴⼀个含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。

程序如下:头⽂件SqList.h的内容如下:#include#include#define LIST_INIT_SIZE 100#define LISTINCREMENT 10#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int ElemType;typedef int Status;typedef struct{ElemType *elem;int length;int listsize;}SqList;L->length=0;L->listsize=LIST_INIT_SIZE;return OK;}Status CreatList_Sq(SqList *L,int n)1{int i;printf("输⼊%d个整数:\n",n);for(i=0;iscanf("\n%d",&L->elem[i]);return OK;}//以下是整个源程序:#include#include"SqList.h"int main(){int i,n;SqList a;SqList *l = &aif(InitList_Sq(l)==-2) printf("分配失败");printf("\n输⼊要建⽴的线性表l的长度n:");//输⼊线性表得长度scanf("%d",&n); l->length=n;printf("线性表的长度是:%d\n",l->length);CreatList_Sq(l,n);//⽣成线性表printf("输出线性表l中的元素值:");//输出线性表中的元素for(i=0;ilength;i++)printf("%7d",l->elem[i]);getchar();}程序的运⾏结果:利⽤前⾯的实验先建⽴⼀个顺序表L,然后再第i个位置插⼊元素,通过对⽐插⼊元素前后的线性表发⽣的变化,判断插⼊操作是否正确。

实验一 顺序表操作实现

实验一 顺序表操作实现

实验一顺序表操作实现实验日期:2017 年 3 月 6 日实验目的及要求1. 熟练掌握线性表的基本操作在顺序存储上的实现;2. 以线性表的各种操作(建立、插入、删除、遍历等)的实现为重点;3. 掌握线性表的顺序存储结构的定义和基本操作的实现;4. 通过本实验加深对C语言的使用(特别是函数调用的参数传递、指针类型的应用)。

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

(1)顺序表类型定义typedef struct {int xh; /*学号*/float sg; /*身高*/int sex; /*性别,0为男生,1为女生*/} datatype;typedef struct{datatype data[MAX]; /*存放顺序表元素的数组*/int last; /*表示data中实际存放元素个数*/}Seqlist;(2)基本运算函数原型void initList(Seqlist *lp);/*置一个空表*/void createList(Seqlist *lp);/*建一个学生顺序表*/void sort_xh(Seqlist *lp);/*按学号排序*/void Error(char *s);/*自定义错误处理函数*/void pntList(Seqlist *lp);/*输出学生表*/void save(Seqlist *lp,char strname[]);/*保存学生顺序表到指定文件*/任务一创建程序文件seqlist.cpp,其代码如下所示,理解顺序表类型Seqlist和基本运算函数后回答下列问题。

/*seqlist.cpp程序文件代码*/#include <stdio.h>#include <stdlib.h>#define MAX 50typedef struct {int xh; /*学号*/float sg; /*身高*/int sex; /*性别,0为男生,1为女生*/} datatype;typedef struct{datatype data[MAX]; /*存放顺序表元素的数组*/int last; /*表示data中实际存放元素个数*/}Seqlist;void initList(Seqlist *lp);/*置一个空表*/void createList(Seqlist *lp);/*建一个学生顺序表*/void sort_xh(Seqlist *lp);/*按学号排序*/void Error(char *s);/*自定义错误处理函数*/void pntList(Seqlist *lp);/*输出学生表*/void save(Seqlist *lp,char strname[]);/*保存学生顺序表到指定文件*//*置一个空表*/void initList(Seqlist *lp){ lp->last=0; }/*建一个学生顺序表*/void createList(Seqlist *lp){ FILE *fp;int xh ,sex;float sg;if((fp=fopen("records.txt","r"))==NULL){ Error("can not open file !");}while(!feof(fp)){ fscanf(fp,"%d%f%d",&xh,&sg,&sex);lp->data[lp->last].xh=xh;lp->data[lp->last].sg=sg;lp->data[lp->last].sex=sex;lp->last++;}fclose(fp);/*按学号排升序*/void sort_xh(Seqlist *lp){ int i,j,k;datatype st;for(i=0;i<lp->last-1;i++){k=i;for(j=i+1;j<lp->last;j++)if(lp->data[j].xh<lp->data[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("\n %s", s);exit(1); /*返回OS,该函数定义在stdlib.h中*/}/*输出学生顺序表*/void pntList(Seqlist *lp){ int i;for(i=0;i<lp->last ;i++)printf("%2d: %.2f %d\n",lp->data [i].xh,lp->data [i].sg,lp->data[i].sex); }/*保存学生顺序表到指定文件*/void save(Seqlist *lp,char strname[]){ FILE *fp;int i;if((fp=fopen(strname,"w"))==NULL){ Error("can not open file !");}for(i=0;i<lp->last ;i++){fprintf(fp,"%2d %5.2f %2d\n",lp->data[i].xh,lp->data[i].sg,lp->data[i].sex);}fclose(fp);}请回答下列问题:(1)由顺序表类型定义可知,该顺序表类型名为Seqlist ,其中存放的元素为学生信息,学生信息定义的类型名为datatype ,包含xh 、sg 、sex 三个成员(写出成员变量名),学生信息存储于data 数组,顺序表的表长变量为MAX 。

实验1-顺序表的实现

实验1-顺序表的实现

程序代码编写的要求
• 请首先建立project • 然后创建一个头文件×××.h,其中有你的程 序中要用的数据类型,以及实现各种操作的函 数的声明(不包括函数体)。 • 再创建一个×××.cpp,其中有各个函数的函 数体(具体实现)。 • 最后创建主函数(程序入口) ×××.cpp ,其 中有用于输入、输出的语句,和一些必要的测 试数据。它来调用上述的函数。
实验(1)顺序表的实现
实验目的
•熟悉使用C编写代码实现算法。 • 掌握结构体的使用。 • 熟悉在顺序表上进行的各种操作。
实验要求
• 编写C(C++)应用程序,实现顺序表 上的各自操作:初始化,销毁,插入, 删除,定位,求表长、“判空”以及 “存取第 i 个数据元素”。
实验报告的书写要求
• • • • • 实验目的 实验要求 实验环境 程序代码 程序的调试与分析

22级数据结构与算法实验1——顺序表

22级数据结构与算法实验1——顺序表

22级数据结构与算法实验1——顺序表顺序表是一种常见的数据结构,它是一种线性表,其中的元素按照顺序存放在一块连续的内存空间中。

顺序表具有随机访问的优势,可以通过下标直接访问任意位置的元素,同时也支持插入和删除操作。

在本篇文章中,我们将介绍顺序表的基本概念、实现方式以及常见操作。

一、顺序表的基本概念顺序表是由一组连续的存储单元组成,元素之间的逻辑关系通过元素在内存中的相对位置来表示。

顺序表的长度是固定的,一旦创建就无法改变。

顺序表中的元素可以是任意类型,如整数、浮点数、字符等。

二、顺序表的实现方式顺序表可以通过数组来实现,数组中的每个元素对应顺序表中的一个位置。

我们可以使用一维数组来存储顺序表中的元素,并使用一个变量记录当前顺序表的长度。

当插入或删除元素时,需要移动其他元素的位置,以保持顺序表的连续性。

三、顺序表的常见操作1. 初始化顺序表:创建一个空的顺序表,并初始化其长度为0。

2. 插入元素:在指定位置插入一个元素,需要将该位置后面的元素依次向后移动,并更新顺序表的长度。

3. 删除元素:删除指定位置的元素,需要将该位置后面的元素依次向前移动,并更新顺序表的长度。

4. 查找元素:根据元素的值查找其在顺序表中的位置,可以使用线性查找或二分查找等算法。

5. 修改元素:根据位置修改顺序表中的元素值。

6. 获取元素:根据位置获取顺序表中的元素值。

四、顺序表的优缺点1. 优点:顺序表支持随机访问,可以通过下标直接访问任意位置的元素,访问速度快。

同时,顺序表的实现简单,易于理解和实现。

2. 缺点:顺序表的长度固定,一旦创建就无法改变,当插入或删除元素时,需要移动其他元素的位置,效率较低。

另外,顺序表的插入和删除操作需要频繁地移动大量元素,对内存的要求较高。

五、顺序表的应用场景顺序表适用于元素数量不变且需要频繁访问的场景。

例如,存储学生成绩的表格可以使用顺序表来表示,每个学生对应一个表格的行,每门课程对应一个表格的列。

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

} default: flag=0; cout <<"程序结束,按任意键退出!" <<endl; } } } //初始化线性表 void initial(seqlist &v) { int i; cout <<"请输入初始线性表长度:n="; cin >>st; cout <<"请输入各元素/字符[中间用空格隔开](例如:a b c d): "; for(i=0;i<st;i++) cin >>&v.elem[i]; } //插入一个元素,成功返回True,失败返回False bool insert (seqlist &v,int loc,char ch) { int i; if((loc<1)||(loc>st+1)) { cout <<"插入位置不合理!" <<endl; //位置错误 return false; } else if(st>=Max) { cout <<"超出线性表最大容量!" <<endl; //溢满 return false; } else { for(i=st-1;i>=loc-1;i--) v.elem[i+1]=v.elem[i]; //插入位置后的元素后移 v.elem[loc-1]=ch; //插入元素 st++; //表长度加1
return true; } } //删除一个元素,成功返回True,并用ch返回该元素值,失败返回 False bool del(seqlist &v,int loc,char &ch) { int j; if(loc<1||loc>st) { cout <<"删除位置不合理!" <<endl; return false; } else { ch=v.elem[loc-1]; //将删除位置的元素赋给ch for(j=loc-1;j<st-1;j++) v.elem[j]=v.elem[j+1]; //删除位置后元素前移 st--; //表长度减1 return true; } } //在线性表中查找ch的位置,成功返回其位置,失败返回-1 int locate(seqlist v,char ch) { int i=0; while(i<st&&v.elem[i]!=ch) i++; if(v.elem[i]==ch) return i; else return (-1); } //显示线性表的所有元素 void print(seqlist v) { int i; for(i=0;i<st;i++)
四、程序的调试及运行结果
五、程序代码
#include <iostream> using namespace std; const int Max=100; //定义表的最大长度
typedef struct { char elem[Max]; int last; //last指示当前线性表的长度 }seqlist; void main() { void initial(seqlist &); //声明初始化线性表函数 bool insert(seqlist &,int ,char); //声明在线性表中插入元素的函数 bool del(seqlist &,int ,char &); //声明在线性表中删除元素的函数 int locate(seqlist,char); //声明在线性表中查找元素的函数 void print(seqlist); //声明显示线性表中所有元素的函数 seqlist s; int loc,flag=1; char j,ch; bool temp; cout <<"顺序结构的线性表,可以实现输出、查找、插入、删除等 操作." <<endl; cout <<endl; initial(s); //初始化线性表 while(flag) { cout <<endl; cout <<" 菜单 " <<endl; cout <<"---------------------------" <<endl; cout <<" 1.显示所有元素. " <<endl; cout <<" 2.插入一个元素." <<endl; cout <<" 3.删除一个元素." <<endl; cout <<" 4.查找一个元素." <<endl; cout <<" 5.结束程序." <<endl; cout <<"---------------------------" <<endl; cout <<"请选择:" ; cin >>j; switch(j) { case '1':print(s);break; //显示所有元素
cout <<v.elem[i] <<' '; cout <<: { cout <<"请输入插入位置和要插入的元素(一个字符)(例如:2 a): "; cin >>loc>>ch; //输入要插入的位置和插入的元素 temp=insert(s,loc,ch); //插入检查 if(temp==false) cout <<"插入失败." <<endl; else if(temp==true) print(s); break; } case '3': { cout <<"请输入要删除元素的位置: "; cin >>loc; //输入要删除的元素的位置 temp=del(s,loc,ch); //删除检查 if(temp==true) cout <<"删除了一个元素: " <<ch <<endl; else cout <<"该元素不存在!" <<endl; print(s); break; } case '4': { cout <<"请输入要查找的元素: " ; cin >>ch; //输入要查找的元素 loc=locate(s,ch); //寻找元素的位置 if(loc!=-1) { cout <<"该元素所在位置: " ; cout <<(loc+1) <<endl; } else cout <<"该元素不存在!" <<endl; break;
算法分析实验一
班级 学号 姓名 分数
顺序表的实现
1、 实验目的:
1.掌握线性表的顺序存储结构 2.能熟练地利用顺序存储结构实现线性表的基本操作 3.能熟练地掌握顺序存储结构中算法的实现
二、实验要求
熟悉线形表的基本操作,对线形表能够进行插入、删除、修改、查找等 操作。
三、实验内容及分析:
建立含有若干个元素的顺序表,并将结果在屏幕上输出。对刚建 立的顺序表实现插入、删除、修改、查找,并将结果在屏幕上输出。 内容分析:先建立一个顺序表,定义表的最大长度为100,程序可 以实现输出、查找、插入、删除操作。先定义一个整型变量i,用于初 始线性表的长度,再输入所有元素,选择菜单里的选项实现功能。插 入:选择需插入元素的位置,插入位置及后面的元素后移一位,再插入 元素;删除:选择要删除元素的位置,将要删除的元素移出顺序表,删 除位置后的元素前移一位;查找:输入要查找的元素,按顺序查找,当 查找到顺序表的第一个与要查找的元素相同时,输出结果。
相关文档
最新文档