数据结构实验报告 顺序表
数据结构实验一顺序表实验报告
数据结构实验一顺序表实验报告
数据结构是计算机科学中的一门基础课程，在学习数据结构的过程中，顺序表是我们必须深入了解和掌握的重要数据结构之一。
在实验一中，我们对顺序表进行了一系列的操作，实现了增删改查等基本操作。
我们先来介绍一下顺序表的基本概念。
顺序表是将线性表中的数据存储在一段连续的存储空间中的数据结构，其查找效率高，但插入和删除操作效率较低。
顺序表需要预先分配一定的存储空间，当存储空间不足时需要进行动态扩容，即重新申请更大的存储空间并将原有数据复制到新的存储空间中。
在实验中，我们首先学习了顺序表的实现方式，包括顺序表的结构体定义、创建顺序表、插入元素、删除元素、修改元素以及查询元素等基本操作。
我们通过 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.归并顺序表（销毁或清空操作前）七、思考讨论题或体会或对改进实验的建议通过本次实验，我掌握了定义线性表的顺序存储类型，加深了对顺序存储结构的理解，进一步巩固和理解了顺序表的基本操作，如建立、查找、插入和删除等。
数据结构实验报告-顺序表的创建、遍历及有序合并操作
数据结构实验报告-顺序表的创建、遍历及有序合并操作二、实验内容与步骤实现顺序表的创建、遍历及有序合并操作，基本数据结构定义如下：typedef int ElemType;#define MAXSIZE 100#define FALSE 0#define TRUE 1typedef struct{ElemType data[MAXSIZE];int length;}seqlist;创建顺序表，遍历顺序表#include<stdio.h>#include<stdlib.h>#define MAXSIZE 100#define Icreament 20#define FALSE 0#define TRUE 1typedef int ElemType; //用户自定义数据元素类型// 顺序表结构体的定义typedef struct{ElemType *elem; //顺序表的基地址int length; //顺序表的当前长度int listsize; //预设空间容量}SqList; //线性表的顺序存储结构SqList* InitList() //创建空的顺序表{SqList* L = (SqList*)malloc(sizeof(SqList));//定义顺序表Lif(!L){printf("空间划分失败，程序退出\n");return NULL;}L->elem=(ElemType *)malloc(MAXSIZE*sizeof(ElemType));if(!L->elem){printf("空间划分失败，程序退出\n");return NULL;}L->length=0;L->listsize=MAXSIZE;return L;}int CreateList(SqList* L) //创建顺序表（非空）{int number; //顺序表中元素的个数int i; //循环变量printf("请输入顺序表中元素的个数：");scanf("%d",&number);if(number > MAXSIZE) //一定要判断输入的个数是否大于顺序表的最大长度{printf("输入个数大于顺序表的长度\n");return 0;}for(i=0;i<number;i++){printf("输入第%d个数: ",i+1);scanf("%d",L->elem+i); //L->elem+i：每次的输入都保存在顺序表元素中的下一个地址，而不是一直放在元素的首地址}//给顺序表中每个数据元素赋值L->length=number; //当前顺序表的长度return 1;}void print(SqList* L) //遍历顺序表{int i;printf("\n开始遍历顺序表\n");for(i=0;i<L->length;i++){printf("%d",*(L->elem + i)); //L->elem+i：和输入是一个道理}printf("\n遍历结束\n");printf("\n");}int main(){SqList* L = InitList(); //申请一个指向顺序表的指针，并对其初始化if(!L) //判断申请是否成功{printf("初始化线性表失败\n");return 1;}if(!CreateList(L)) //判断创建顺序表是否成功{printf("创建顺序表失败\n");return 1;}print(L); //打印顺序表与上面遍历顺序表相对应，若没有就不遍历free(L->elem); //释放申请的顺序表元素的内存free(L); //释放申请的顺序表内存return 0;}表的有序合并#include <stdio.h>#include <stdlib.h>#define MAXSIZE 100typedef int ElemType;//顺序表结构体的定义typedef struct{ElemType data[MAXSIZE] ;int size;}seqlist;//函数声明void init(seqlist *slt) ;void display(seqlist slt) ;void sort(seqlist *s) ;void combine( seqlist *s1 ,seqlist *s2 ,seqlist *s3) ;//顺序表的初始化函数void init(seqlist *slt){slt->size=0 ;}//顺序表的显示函数void display(seqlist slt){int i;if(!slt.size){printf("\n顺序表为空") ;}else{for(i=0;i<slt.size;i++)printf("\n%d\n",slt.data[i]) ;}}//顺序表排序void sort(seqlist *s){int i ;int j ;int temp ;for(i=0;i<s->size-1;i++){for(j=i+1;j<s->size;j++){if(s->data[i]>=s->data[j]){temp=s->data[i];s->data[i]=s->data[j];s->data[j]=temp;}}}}//两个有序顺序表连接函数void combine(seqlist *s1 , seqlist *s2 , seqlist *s3 ) {int i=0 ;int j=0 ;int k=0 ;while( i < s1->size && j < s2->size) {if(s1->data[i]<=s2->data[j]){s3->data[k]=s1->data[i];i++;}else{s3->data[k]=s2->data[j];j++;}k++;}if(i==s1->size){while(j<s2->size){s3->data[k]=s2->data[j];k++;j++;}}if(j==s2->size){while(i<s1->size){s3->data[k]=s1->data[i];k++;i++;}}s3->size=k;}//主函数int main(){int i ;int j ;int x ;int n ;seqlist list1 ;seqlist list2 ;seqlist list3 ;init(&list1);printf("第一个顺序表元素个数：\n"); scanf("%d" ,&n) ;printf("第一个顺序表输入：\n");for(i=0 ; i<n ; i++){scanf("%d",&list1.data[i]) ;list1.size++ ;}sort(&list1);//第一个表排序init(&list2);printf("第二个顺序表元素个数：\n"); scanf("%d" ,&n) ;printf("第二个顺序表输入：\n");for(i=0 ; i<n ; i++){scanf("%d",&list2.data[i]) ;list2.size++ ;}sort(&list2);//第二个表排序init(&list3) ;combine(&list1 ,&list2 ,&list3) ;printf("表一与表二连接后:\n") ;display(list3) ;return 0;}。
数据结构-顺序表-实验报告
实验报告课程数据结构及算法实验项目 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已存在。
数据结构实验一顺序表实验报告
数据结构实验一顺序表实验报告一、实验目的本次实验的主要目的是通过实现顺序表的基本操作，深入理解线性表的逻辑结构和存储结构，掌握顺序表的插入、删除、查找等操作的实现方法，提高编程能力和问题解决能力。
二、实验环境本次实验使用的编程语言为 C 语言，编程环境为 Visual Studio 2019。
三、实验原理顺序表是一种线性表的存储结构，它使用一组连续的存储单元依次存储线性表中的元素。
在顺序表中，元素的逻辑顺序与物理顺序是一致的。
顺序表的基本操作包括初始化、插入、删除、查找、遍历等。
在实现这些操作时，需要考虑顺序表的存储空间是否已满、插入和删除元素时元素的移动等问题。
四、实验内容（一）顺序表的定义｀｀｀cdefine MAXSIZE 100 ／／定义顺序表的最大长度typedef struct ｛int dataMAXSIZE; ／／存储顺序表的元素int length; ／／顺序表的当前长度｝ SeqList;｀｀｀（二）顺序表的初始化｀｀｀cvoid InitList(SeqList L) ｛L>length ＝ 0;｝｀｀｀（三）顺序表的插入操作｀｀｀cint InsertList(SeqList L, int i, int e) ｛if （L>length ＝＝ MAXSIZE) ｛／／顺序表已满return 0;｝if （i ＜ 1 ｜｜ i ＞ L>length ＋ 1) ｛／／插入位置不合法return 0;｝for （int j ＝ L>length; j ＞＝ i; j) ｛／／移动元素L>dataj ＝ L>dataj 1;｝L>datai 1 ＝ e; ／／插入元素L>length+＋；return 1;｝｀｀｀（四）顺序表的删除操作｀｀｀cint DeleteList(SeqList L, int i, int e) ｛if （L>length ＝＝ 0) ｛／／顺序表为空return 0;｝if （i ＜ 1 ｜｜ i ＞ L>length) ｛／／删除位置不合法｝e ＝ L>datai 1; ／／取出被删除的元素for （int j ＝ i; j ＜ L>length; j+＋）｛／／移动元素L>dataj 1 ＝ L>dataj;｝L>length;return 1;｝｀｀｀（五）顺序表的查找操作｀｀｀cint SearchList(SeqList L, int e) ｛for （int i ＝ 0; i ＜ Llength; i+＋）｛if （Ldatai ＝＝ e) ｛return i ＋ 1;｝｝｝｀｀｀（六）顺序表的遍历操作｀｀｀cvoid TraverseList(SeqList L) ｛for （int i ＝ 0; i ＜ Llength; i+＋）｛printf(＂％d ＂， Ldatai)；｝printf(＂＼n"）；｝｀｀｀五、实验步骤1、打开 Visual Studio 2019，创建一个新的 C 语言项目。
数据结构实验一顺序表问题及实验报告模板 - Copy
else l = m + 1;
}
return NONE;
}
public static void main(String[] args) {
String[] word1 = {"dog", "cat", "rat", "pig", "fox", "eel"};
for (int t = 0; t < testcases.length; t++) {
String target = testcases[t];
System.out.println(target
+ " " + linearSearch1(word1, left1, right1, target) + " "
}
public static int linearSearch2(Comparable[] a, int left, int right, Comparable val)
{
for (int i = left; i <= right; i++)
{ int comp = pareTo(a[i]);
String target = testcases[t];
System.out.println(target
+ " " + linearSearch1(word1, left1, right1, target) + " "
+ linearSearch2(word2, left2, right2, target)
数据结构顺序表链表试验报告
数据结构顺序表链表试验报告数据结构试验报告一、引言数据结构是计算机科学中非常重要的一个概念，它用于组织和存储数据，以便能够高效地进行检索和操作。
顺序表和链表是两种常见的数据结构，它们在实际应用中都有各自的优势和局限性。
本报告将对顺序表和链表进行试验比较，以评估它们在不同场景下的性能和适合性。
二、实验目的本次试验的目的是比较顺序表和链表在插入、删除和查找操作上的性能差异，并分析其时间复杂度和空间复杂度。
通过实验结果，可以对不同场景下选择合适的数据结构提供参考。
三、实验内容1. 顺序表实验a. 创建一个包含100个元素的顺序表；b. 在表尾插入一个元素；c. 在表头插入一个元素；d. 在表的中间位置插入一个元素；e. 删除表尾的一个元素；f. 删除表头的一个元素；g. 删除表的中间位置的一个元素；h. 查找一个元素；i. 遍历整个顺序表。
2. 链表实验a. 创建一个包含100个节点的链表；b. 在链表尾部插入一个节点；c. 在链表头部插入一个节点；d. 在链表的中间位置插入一个节点；e. 删除链表尾部的一个节点；f. 删除链表头部的一个节点；g. 删除链表的中间位置的一个节点；h. 查找一个节点；i. 遍历整个链表。
四、实验结果与分析1. 顺序表实验结果a. 在表尾插入一个元素的平均时间为0.1ms；b. 在表头插入一个元素的平均时间为0.2ms；c. 在表的中间位置插入一个元素的平均时间为0.5ms；d. 删除表尾的一个元素的平均时间为0.1ms；e. 删除表头的一个元素的平均时间为0.2ms；f. 删除表的中间位置的一个元素的平均时间为0.5ms；g. 查找一个元素的平均时间为1ms；h. 遍历整个顺序表的平均时间为10ms。
2. 链表实验结果a. 在链表尾部插入一个节点的平均时间为0.2ms；b. 在链表头部插入一个节点的平均时间为0.1ms；c. 在链表的中间位置插入一个节点的平均时间为0.5ms；d. 删除链表尾部的一个节点的平均时间为0.2ms；e. 删除链表头部的一个节点的平均时间为0.1ms；f. 删除链表的中间位置的一个节点的平均时间为0.5ms；g. 查找一个节点的平均时间为2ms；h. 遍历整个链表的平均时间为5ms。
数据结构 顺序表 实验报告
五、主要代码（略） ....................................................7
六、测试结果及说明 ....................................................7
重庆交通大学计算机与信息学院
数据结构实验报告
实验名称： 顺序表操作
实验性质： 课程安排实验
所属课程： 数 据 结 构
指导教师：
班 级： 2008级3班
七、实验体会 ...................................................10
一、实验目的
培养学生在程序设计方面知识的综合应用能力及程序设计能力（包括编制能力及程序调试能力）
二、实验内容及要求
（1）以顺序存储方式实现线性表进行简单的图书管理，图书信息由学生自行定义。
7) 自主加入了文件的读入函数，由list类入口，再调用book类的读入函数。
3、设计主函数，显示操作方式，调用各个类的成员函数
1) 显示本程序能实现的各项功能，并实现循环操作；
2) 通过定义的一个list类型对象调用各个函数实现程序功能；
3) 为实现不同的编程方式，用了很久以前的直接定义函数功能，在主程序中定义了一个函数，不属于book类，也不属于list类，它实现保存数据的功能。
3) list类的共有成员函数类似book类的定义风格，包括了受保护成员值的设定以及读取，同样重载了list类型数据的赋值即顺序表的拷贝；
4) 保留了教材上对于顺序表的判空、判满等共有成员函数；
顺序表实验报告
顺序表实验报告实验名称：顺序表的实现与操作实验目的：1.理解顺序表的概念、特点和实现方式。
2.掌握顺序表的基本操作，包括初始化、插入、删除、查找、修改、清空等操作。
3.提高编程能力，加深对数据结构的理解。
实验原理：顺序表是数据结构中的一种线性表，采用连续的存储方式来存储元素，其具有访问速度快的特点。
在顺序表中，元素在物理存储上是连续的，每个元素占据一定的存储空间。
顺序表的实现需要使用数组，可以通过数组下标查找具体元素，也可以通过数组长度限定表的大小。
实验步骤：1.定义顺序表结构体struct SeqList{int size;//表的大小int length;//表的长度int *data;//存储数据的指针};2.初始化操作void initSeqList(SeqList &list,int size){list.size = size;list.length = 0;list.data = new int[size];}3.插入操作void insertSeqList(SeqList &list,int pos,int elem){ if(pos<1 || pos>list.length+1){cout<<"位置不合法"<<endl;return;}if(list.length>=list.size){cout<<"顺序表已满"<<endl;return;}for(int i=list.length-1; i>=pos-1; i--){list.data[i+1] = list.data[i];}list.data[pos-1] = elem;list.length++;}4.删除操作void deleteSeqList(SeqList &list,int pos){ if(pos<1 || pos>list.length){cout<<"位置不合法"<<endl;return;}for(int i=pos-1; i<list.length-1; i++){ list.data[i] = list.data[i+1];}list.length--;}5.查找操作int searchSeqList(SeqList list,int elem){for(int i=0; i<list.length; i++){if(list.data[i] == elem){return i+1;}}return 0;}6.修改操作void modifySeqList(SeqList &list,int pos,int elem){ if(pos<1 || pos>list.length){cout<<"位置不合法"<<endl;return;}list.data[pos-1] = elem;}7.清空操作void clearSeqList(SeqList &list){list.length = 0;}实验结果：经过上述实验操作，成功实现了顺序表的初始化、插入、删除、查找、修改、清空等操作，并能够正确输出结果。
数据结构实验报告顺序表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）掌握链表的概念，学会对链表进⾏操作。
数据结构顺序表实验报告
}SeqList;
3.模块划分
(1)创建顺序表输入函数：void Input(SeqList *L，int n)；
(2）创建顺序表输出函数：void Output（SeqList＊L）；
(3)创建顺序表的内容查找函数：int Locate（SeqList L,ElemType e)；
｛printf("插入位置不合法\n”）;
return(ERROR)；
｝
if（L-〉last>= MAXSIZE—1）
｛printf（”表已满无法插入"）；
return（ERROR);
}
for(k=L-〉last；k>=i—1；k--）//为插入元素而移动位置
L-〉elem[k+1］=L—>elem［k]；
scanf(”％d”，＆m）;
DelList（la，m，＆num）；
printf（”删除成功,删除的元素为％d”，num);
printf(”\n”）;
Output（la）;
｝
5。测试数据及结果
实验总结：
经过调试与测试，实验结果与测试预期一致.顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。
洛阳理工学院实验报告
系别
计算机
班级
学号
姓名
课程名称
数据结构
实验日期
10/23
实验名称
顺序表的基本操作
成绩
Байду номын сангаас实验目的：
熟悉掌握线性表顺序存储结构，掌握与应用顺序表的查找、插入、删除等基本操作算法,训练和提高结构化程序设计能力及程序调试能力.
实验报告 顺序表实验
《数据结构》实验报告1.上机题目：顺序表实验2.需求分析实现顺序表的建立、输出、查找、插入、删除、合并几项功能。
明确说明程序的开发环境和功能要求。
针对主要功能，给出如下说明：（1）输入参数的格式和合法取值范围输入参数范围输入格式菜单选择数字 0—6， getche()接受键盘上对应的按钮数据输入 0—9999 scanf（“%s”，data）程序是否执行 y n getche()接受键盘上对应按键（2）输出的格式输出参数输出格式文字输出 printf（“******”）；数据输出 printf（“%d”，data[i]）（3）测试数据能够完成顺序表的建立、输出、查找、插入、删除、合并几项功能。
********************************* 1.建立一个顺序表 ** 2.输出一个顺序表 ** 3.在顺序表中查找 ** 4.向顺序表中插入一个元素 ** 5.删除顺序表中的一个元素 ** 6.将两个顺序表合并 ** 0.退出 *********************************（4）开发环境Vc6.03.详细设计（1）确定存储结构，并给出所用数据类型的数据结构定义采用顺序表存储的线性表。
利用内存中的一片起始位置确定的连续存储区域来存放表中的所以元素。
可以根据需要对表中的任何数据元素进行访问，元素的插入，删除可以在表中任何位置进行。
typedef struct {ElemType data[MAXSIZE];int length;}SqList;（2）给出所用数据类型中每个操作的伪码算法A．初始化建立的顺序表Void InitList(SqList &L)置 L.length 为 0B．建立新的顺序表Void CreatSqlist(SqList &L,int n)开辟一个数据结构空间，容量是MAXSIZEif str 是四位正整数记录else重新输入正确值C．输出顺序表int Output(SqList L)if L.length 等于 0return 0elsereturn 1D. 在顺序表中按位置取值int GetElem(SqList L,int i)if 取值不在线性表范围内return -9999;elsereturn L.data[i];E．在顺序表中按位置取值int LocateElem(SqList L,ElemType x)While x=L.data[k]if(k<L.length)return k;elsereturn -1;F．在i处插入元素int Insert(SqList &L,ElemType x,int i)if 不在k的范围内插入return 0;else在 i处插入元素return 1;G．在i处删除元素int Delete(SqList &L,int i)if i不在L.length范围内return 0;else删除i处的元素return 1;H. 合并la lb两个顺序表Void MergeList(SqList la,SqList lb,SqList &lc) la，lb升序排序la先存在lclb再存在lc4.调试分析（1）调试过程中主要遇到哪些问题？是如何解决的？A．在程序结束时如果按书上的代码printf("继续执行吗Y(1)/N(0): ");scanf("%d",&k);if(!k)return;只要不输入0都会继续执行代码，所以我想让此时的程序只识别 y 和 n 两个按键通过查找 y的键盘值是 0x0079N的键盘值是 0x006e通过 key=getche()，判断key的值来决定标志位的值来。
顺序表的实验报告
顺序表的实验报告顺序表的实验报告一、引言顺序表是一种常见的数据结构，它可以用来存储一组具有相同数据类型的元素，并且这些元素在内存中是连续存储的。
在本次实验中，我们将通过编写一个简单的顺序表程序来深入了解顺序表的原理和使用方法。
二、实验目的1. 掌握顺序表的基本概念和特点；2. 熟悉顺序表的操作，包括插入、删除、查找等；3. 理解顺序表的存储结构和算法。
三、实验过程1. 定义顺序表结构首先，我们需要定义一个顺序表的结构。
顺序表由两部分组成：一个数组用于存储元素，一个变量用于记录当前元素个数。
我们可以使用C语言的结构体来定义顺序表结构：```c#define MAX_SIZE 100 // 定义顺序表的最大容量typedef struct {int data[MAX_SIZE]; // 用数组存储元素int length; // 记录当前元素个数} SeqList;```2. 初始化顺序表在使用顺序表前，我们需要对其进行初始化，即将长度置为0。
可以编写一个初始化函数来完成这个操作：```cvoid init(SeqList *list) {list->length = 0;}```3. 插入元素顺序表的插入操作是将一个元素插入到指定位置上，并将后面的元素依次后移。
我们可以编写一个插入函数来实现这个操作：```cvoid insert(SeqList *list, int position, int value) {if (position < 0 || position > list->length) {printf("插入位置无效！\n");return;}if (list->length >= MAX_SIZE) {printf("顺序表已满，无法插入！\n");return;}for (int i = list->length; i > position; i--) {list->data[i] = list->data[i - 1];}list->data[position] = value;list->length++;}```4. 删除元素顺序表的删除操作是将指定位置上的元素删除，并将后面的元素依次前移。
数据结构实验报告顺序表
数据结构实验报告顺序表数据结构实验报告：顺序表一、引言数据结构是计算机科学的重要基础，它研究数据的组织方式和操作方法。
顺序表是一种常见的数据结构，它以数组的形式存储数据元素，具有随机访问和插入删除方便的特点。
本实验旨在深入理解顺序表的实现原理和操作方法，并通过实验验证其性能。
二、实验目的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.实验环境：●操作系统：Windows 10●编程语言：C/C++●开发工具：Visual Studio Code3.实验内容：3.1 初始化顺序表●定义顺序表结构体●实现创建顺序表的函数●实现销毁顺序表的函数3.2 插入元素●实现在指定位置插入元素的函数●实现在表尾插入元素的函数3.3 删除元素●实现删除指定位置元素的函数●实现删除指定值元素的函数3.4 查找元素●实现按值查找元素的函数●实现按位置查找元素的函数3.5 修改元素●实现修改指定位置元素的函数3.6 打印顺序表●实现打印顺序表中所有元素的函数4.实验步骤：4.1 初始化顺序表●定义顺序表结构体，并分配内存空间●初始化顺序表中的数据和长度4.2 插入元素●调用插入元素函数，在指定位置或表尾插入元素4.3 删除元素●调用删除元素函数，删除指定位置或指定值的元素4.4 查找元素●调用查找元素函数，按值或位置查找元素4.5 修改元素●调用修改元素函数，修改指定位置的元素4.6 打印顺序表●调用打印顺序表函数，输出顺序表中的所有元素5.实验结果：经过测试，顺序表的基本操作均能正确执行。
插入元素、删除元素、查找元素、修改元素和打印顺序表等功能都能正常运行。
6.实验总结：本实验通过实现顺序表的基本操作，巩固了对数据结构顺序表的理论知识，并加深了对算法的理解和应用能力。
顺序表是一种简单、易于实现的数据结构，适用于元素数量变化较少的情况下。
7.附件：无8.法律名词及注释：●顺序表：一种基本的线性数据结构，数据元素按照其逻辑位置依次存储在一片连续的存储空间中。
●初始化：为数据结构分配内存空间并进行初始化，使其具备基本的数据存储能力。
●插入元素：将一个新元素插入到已有元素的合适位置，使得数据结构保持有序或符合特定要求。
数据结构实验一顺序表实验报告
数据结构实验一顺序表实验报告数据结构实验一顺序表实验报告一、实验目的顺序表是一种基本的数据结构，本次实验的目的是通过实现顺序表的基本操作，加深对顺序表的理解，并掌握顺序表的插入、删除、查找等操作的实现方法。
二、实验内容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)理解线形表的逻辑结构特征(2)理解并掌握顺序表(3)了解顺序表的各种基本运算二、实验项目摘要编写一个程序algo2-1.cpp，实现顺序表的各种基本运算，并在此基础上设计一个主程序并完成如下功能：（1）初始化顺序表L；（2）依次采用尾插法插入a,b,c,d,e元素；（3）输出顺序表L；（4）输出顺序表L长度；（5）判断顺序表L是否为空；（6）输出顺序表L的第3个元素；（7）输出元素’a’的位置；（8）在第4个元素位置上插入’f’元素；（9）输出顺序表L；（10）删除L的第3个元素；（11）输出顺序表L；（12）释放顺序表L。
三、实验预习内容顺序表基本运算，包括：建立顺序表、顺序表基本运算算法（初始化线形表、销毁线形表、判断线形表是否为空表、求线形表的长度、输出线形表、球现行表中某个数据元素值、按元素值查找、插入元素数据、删除数据元素）三、实验结果与分析#include <stdio.h>#include <malloc.h>#define MaxSize 50typedef int ElemType;typedef struct{ ElemType elem[MaxSize];int length;} SqList;void InitList(SqList *&L){ L=(SqList *)malloc(sizeof(SqList));L->length=0;}void DestroyList(SqList *L){free(L);}int 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->elem[i]);printf("\n");}int GetElem(SqList *L,int i,ElemType &e) { if (i<1 || i>L->length)return 0;e=L->elem[i-1];return 1;}int LocateElem(SqList *L, ElemType e) {int i=0;while (i<L->length && L->elem[i]!=e) i++; if (i>=L->length)return 0;elsereturn i+1;}int ListInsert(SqList *&L,int i,ElemType e) { int j;if (i<1 || i>L->length+1)return 0;i--;for (j=L->length;j>i;j--)L->elem[j]=L->elem[j-1];L->elem[i]=e;L->length++;}int ListDelete(SqList *&L,int i,ElemType &e){ int j;if (i<1 || i>L->length)return 0;i--;e=L->elem[i];for (j=i;j<L->length-1;j++)L->elem[j]=L->elem[j+1];L->length--;return 1;}void main(){SqList *L;ElemType e;printf("初始化顺序表L\n");InitList(L);printf("依次采用尾插法插入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("输出顺序表L:");DispList(L);printf("顺序表L长度=%d\n",ListLength(L));printf("顺序表L为%s\n",(ListEmpty(L)?"空":"非空")); GetElem(L,3,e);printf("顺序表L的第3个元素=%c\n",e);printf("元素a的位置=%d\n",LocateElem(L,'a'));printf("在第4个元素位置上插入f元素\n"); ListInsert(L,4,'f');printf("输出顺序表L:");DispList(L);printf("删除L的第3个元素\n");ListDelete(L,3,e);printf("输出顺序表L:");DispList(L);printf("释放顺序表L\n");}注：空间不够，可以增加页码。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
(此文档为word格式，下载后您可任意编辑修改！)江西理工大学软件学院计算机类课程实验报告课程名称：数据结构班级：姓名：学号：江西理工大学软件学院实验二：顺序表2012年11月10日一. 实验目的掌握顺序表的逻辑结构、存储结构、以及操作。
二. 问题描述线性表是由n(n≥0)个元素（结点）a1, a2, …, a n组成的有限序列，其中a i中的i称为该数据元素的位置（序号），n为数据元素的个数（表的长度），当n等于0时称为空表。
按逻辑次序依次把数据元素存放在一组连续的地址存储单元里的线性表称为顺序表。
在这里，我们通过C++中的动态数组来实现顺序表的存放，并通过建立顺序表类实现它的各种操作。
三. 实验要求实现顺序表的三个框架操作：随机生成，用已有顺序表初始化另一个顺序表，输入顺序表。
以及十个基本操作：在第i个元素之前插入元素，判断是否为空，求元素个数，取第i个元素，查找第一个与e满足compare()关系的元素，返回元素的前驱，返回后继，删除第i个元素，把一个顺序表赋值给另一个顺序表，置空顺序表。
四. 实验环境3323机房OS：WxpC环境：1、TC2.02、VC++ 6.0 五．运行结果程序开始界面1.随机生成顺序表（元素值为0到99之间的整数）2. 用已有的顺序表初始化另一个顺序表3. 输入顺序表基本操作：1.在第i个元素之前插入一个元素2. 判断顺序表是否为空3. 求顺序表中元素的个数4. 取第i个元素5. 查找第一个与之满足compare()关系的元素序号6. 返回某元素的前驱7. 返回某元素的后继8. 删除第i个元素9. 把一个顺序表复制给另一个顺序表10. 把顺序表置空11.顺序表的运用六．实验心得熟悉最基本的数据类型——顺序表，同时我们让我们熟练C++的基本操作，模板的使用，以及模块化的设计思想。
同时也运用顺序表做一些简单的运用，比如顺序表的并交差运算，学生管理系统等等。
在这次的实验中，我掌握了很多C++的特性，在运用顺序表时，由于水平的原因，只是把简单的并交差运算写完，我想通过以后的学习，我们能够将其实现学生管理系统。
在实验中我也遇到很多的问题，输入输出的重载，输出格式的控制等等，在以后的实验中吸取经验和教训，提高自己的水平。
五．实验代码基类：SqList.;public:构造函数，析构函数，拷贝构造函数的声明SqList();virtual ~SqList();SqList(const SqList<ElemType>& otherL);顺序表的方法有序顺序表的折半查找int bin_Search(ElemType key);把顺序表置空void clear();删除第i个元素Status deleteElem(int i,ElemType& e);取第i个元素int getElem(int i,ElemType& e);求顺序表中元素的个数int getLength();求顺序表存储空间的大小int getListSize();在第i个元素之前插入一个元素Status insert(int i,ElemType e);判断顺序表是否为空bool isEmpty();查找第1个与e满足compare关系的元素的序号int locateElem(ElemTypee,Status(*compare)(ElemType,ElemType));返回某个元素的后继Status nextElem(ElemType e,ElemType& next_e);重载复制运算符SqList<ElemType> operator =(SqList<ElemType> rightL);返回某个元素的前驱Status priorElem(ElemType e,ElemType& prior_e);在顺序表中顺序查找某个元素、int sequentialSearch(ElemType e);};顺序表的方法有序顺序表的折半查找template <typename ElemType>int SqList<ElemType>::bin_Search(ElemType key){int low,mid,-1;while(low<= mid+1;else if(elem[mid]<key)low=mid+1;else 0;把顺序表置空template <typename ElemType>void SqList<ElemType>::clear(){n=0;}删除第i个元素template <typename ElemType>Status SqList<ElemType>::deleteElem(int i,ElemType& e) {if(i<1||i>n) return ERROR;e=elem[i-1];for(int j=i+1;j<=n;++j)elem[j-2]=elem[j-1];--n;return OK;}取第i个元素template <typename ElemType>Status SqList<ElemType>::getElem(int i,ElemType& e) {if(i<1||i>n) return ERROR;e=elem[i-1];return OK;}求顺序表中元素的个数template <typename ElemType>int SqList<ElemType>::getLength(){return n;取顺序表存储空间的大小template <typename ElemType>int SqList<ElemType>::getListSize(){return listSize;}在第i元素之前插入一个元素template <typename ElemType>Status SqList<ElemType>::insert(int i,ElemType e){ElemType *newbase;if(i<1||i>n+1)return ERROR;if(n>=listSize){newbase =new ElemType[listSize+LISTINCERMENT];assert(newbase!=0);for(int j=1;j<n;++j)newbase[j-1]=elem[j-1];delete[] elem;elem = newbase;listSize+=LISTINCERMENT;}for(int j=n;j>=i;--j)elem[j]=elem[j-1];elem[i-1]=e;++n;return OK;}判断顺序表是否为空template <typename ElemType>bool SqList<ElemType>::isEmpty(){return n?false:true;}查找第1个与某元素e满足compare()关系元素template <typename ElemType>int SqList<ElemType>::locateElem(ElemType e,Status(*compare)(ElemType,ElemType)){int i;for(i=1;i<=n&&!(*compare)(elem[i-1],e);++i);if(i<=n)return i;elsereturn 0;}返回某个元素的后继template <typename ElemType>Status SqList<ElemType>::nextElem(ElemType e,ElemType& next_e){int i=locateElem(e,equal);if(i<1||i==n)return ERROR;elsegetElem(i+1,next_e);return OK;}重载运算符的定义template <typename ElemType>SqList<ElemType>SqList<ElemType>::operator=(SqList<ElemType>rightL) {if(this!=&rightL){if(listSize<rightL.listSize){delete[] elem;elem=new ElemType[rightL.listSize];assert(elem!=0);listSize=rightL.listSize;}n=rightL.n;for(int i=1;i<=n;++i)elem[i-1]=rightL.elem[i-1];}return *this;}返回某个元素的前驱template <typename ElemType>Status SqList<ElemType>::priorElem(ElemType e,ElemType& prior_e){int i=locateElem(e,equal);if(i<=1)return ERROR;elsegetElem(i-1,prior_e);return OK;}在顺序表中顺序查找某个元素template <typename ElemType>int SqList<ElemType>::sequentialSearch(ElemType key){for(int i=1;i<n&& key!=elem[i-1];i++);if(i<=n)return i;elsereturn 0;}构造函数的实现template <typename ElemType>SqList<ElemType>::SqList(){elem =new ElemType[LIST_MAX_SIZE];assert(elem!=0);listSize=LIST_MAX_SIZE;n=0;}析构函数的实现template <typename ElemType>SqList<ElemType>::~SqList(){delete[] elem;}拷贝构造函数的实现template <typename ElemType>SqList<ElemType>::SqList(const SqList<ElemType>& otherL) {elem=new ElemType[otherL.listSize];assert(elem!=0);listSize=otherL.listSize;n=otherL.n;for(int i=1;i<=n;i++)elem[i-1]=otherL.elem[i-1];}派生类MySqList.);显示数据void display(ostream& out)const;生成随机顺序表Status randSql(int n,MySqList<ElemType>& otherS);};派生类的实现输入template <typename ElemType>void MySqList<ElemType>::read(istream& in){cout<<"请输入要建立的顺序表的元素个数：";cin>>n;for(int i=0;i<n;i++){cout<<n<<endl;cout<<"请输入顺序表的第"<<i+1<<"个元素：";in>>elem[i];n++;}cout<<endl;}template <typename ElemType>istream& operator >>(istream& in,MySqList<ElemType>& iL) {iL.read(in);return in;}输出template <typename ElemType>void MySqList<ElemType>::display(ostream& out) const {for(int i=0;i<n;i++)out<<"["<<i+1<<"]"<<"\t";out<<endl;for(int i=0;i<n;i++)out<<elem[i]<<"\t";out<<endl<<endl;}template <typename ElemType>ostream& *MySqList<ElemType>::*operator <<(ostream& out,const MySqList<ElemType>& oL){oL.display(out);return out;}生成随机数顺序表template <typename ElemType>Status MySqList<ElemType>::randSql(intn,MySqList<ElemType>& otherS){errno_t err;unsigned int number;int max=100;if(n<1||n>otherS.listSize) return ERROR;else{for(int i=0;i<n;i++){err = rand_s(&number);if (err != 0){printf_s("The rand_s function failed!\n");}otherS.elem[i]=(unsigned int)((double)number ((double) UINT_MAX + 1 ) * 100.0) + 1;}otherS.n=n;}return OK;}21。