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

合集下载

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

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

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

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

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

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

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

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

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

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

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

数据结构实验一_顺序表的基本操作实验报告

数据结构实验一_顺序表的基本操作实验报告

实验一顺序表的基本操作一、实验目的掌握线性表的顺序表基本操作:建立、插入、删除、查找、合并、打印等运算。

二、实验要求包含有头文件和main函数;1.格式正确,语句采用缩进格式;2.设计子函数实现题目要求的功能;3.编译、连接通过,熟练使用命令键;4.运行结果正确,输入输出有提示,格式美观。

三、实验设备、材料和工具1.奔腾2计算机或以上机型2.turboc2,win-tc四、实验内容和步骤1. 建立一个含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。

2. 往该顺序表中第i位置插入一个值为x的数据元素。

3. 从该顺序表中第j位置删除一个数据元素,由y返回。

4. 从该顺序表中查找一个值为e的数据元素,若找到则返回该数据元素的位置,否则返回“没有找到”。

五、程序#include<stdio.h>#include<stdlib.h>#define list_init_size 10#define increment 2typedef struct {int *elem;int length,listsize;}sqlist; //类型定义void initlist_sq(sqlist &L) //初始化顺序表{ }void output(sqlist L) //输出顺序表{ }void insertlist(sqlist &L,int i, int x) //顺序表中插入x{ }void deletelist(sqlist &L,int j, int y) //顺序表中删除y{ }int locateelem(sqlist &L,int e) //顺序表中查找e{ }void main(){ }【运行结果】void initlist_sq(sqlist &L) //初始化顺序表{L.elem=(int*)malloc(LIST_INIT_SIZE*sizeof(int));if(!L.elem) exit (OVERFLOW);L.length=0;L.listsize=LIST_INIT_SIZE;return OK;}void output(sqlist L) //输出顺序表{for(int i=0;i<=L.length-1;i++)printf("%d,",L.elem[i]);return OK;}void insertlist(sqlist &L,int i, int x) //顺序表中插入x{int p,q;if(i<1||i>L.length+1)return ERROR;if(L.length>=L.listsize){newbase=(int*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(int));if(!newbasde)exit(OVERFLOW);L.elem=newbase;L.listsize+=LISTINCREMENT;}q=&(L.elem[i-1];for(p=&(L.elem[L.length-1]);p>=q;--p*(p+1)=*p;*p=x;++L.length;return ok;}void deletelist(sqlist &L,int j, int y) //顺序表中删除y{int p,q;if(i<1||I>L.length+1) return ERROR;p=&(L.elem[i-1]);y=*p;q=L.elem+L.length-1;for(++p;p<=q;++p)*(p-1)=*p;--L.length;return ok;}int locateelem(sqlist &L,int e) //顺序表中查找e { int p;i=1;p=L.elem;while(i<=L.length&&!(*p++,e))++i;if(i<=L.length) return i;else return 0;}void main(){int d,p,a,b;int c;initlist_sq(&L);output( L);insertlist( &L, d, a);deletelist( &L, p, b);locateelem( &L, c);}。

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

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

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

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

操作系统为 Windows 10。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

实验1:线性表(顺序表的实现)一、实验项目名称顺序表基本操作的实现二、实验目的掌握线性表的基本操作在顺序存储结构上的实现。

三、实验基本原理顺序表是由地址连续的的向量实现的,便于实现随机访问。

顺序表进行插入和删除运算时,平均需要移动表中大约一半的数据元素,容量难以扩充四、主要仪器设备及耗材Window 11、Dev-C++5.11五、实验步骤1.导入库和一些预定义:2.定义顺序表:3.初始化:4.插入元素:5.查询元素:6.删除元素:7.销毁顺序表:8.清空顺序表:9.顺序表长度:10.判空:11.定位满足大小关系的元素(默认小于):12.查询前驱:13.查询后继:14.输出顺序表15.归并顺序表16.写测试程序以及主函数对顺序表的每一个操作写一个测试函数,然后在主函数用while+switch-case的方式实现一个带菜单的简易测试程序,代码见“实验完整代码”。

实验完整代码:#include <bits/stdc++.h>using namespace std;#define error 0#define overflow -2#define initSize 100#define addSize 10#define compareTo <=typedef int ElemType;struct List{ElemType *elem;int len;int listsize;}L;void init(List &L){L.elem = (ElemType *) malloc(initSize * sizeof(ElemType)); if(!L.elem){cout << "分配内存失败!";exit(overflow);}L.len = 0;L.listsize = initSize;}void destroy(List &L){free(L.elem);L.len = L.listsize = 0;}void clear(List &L){L.len = 0;}bool empty(List L){if(L.len == 0) return true;else return false;}int length(List L){return L.len;}ElemType getElem(List L,int i){if(i < 1 || i > L.len + 1){cout << "下标越界!";exit(error);}return L.elem[i - 1];}bool compare(ElemType a,ElemType b) {return a compareTo b;}int locateElem(List L,ElemType e) {for(int i = 0;i < L.len;i++){if(compare(L.elem[i],e))return i;}return -1;}int check1(List L,ElemType e){int idx = -1;for(int i = 0;i < L.len;i++)if(L.elem[i] == e)idx = i;return idx;}bool check2(List L,ElemType e){int idx = -1;for(int i = L.len - 1;i >= 0;i--)if(L.elem[i] == e)idx = i;return idx;}int priorElem(List L,ElemType cur_e,ElemType pre_e[]) {int idx = check1(L,cur_e);if(idx == 0 || idx == -1){string str = "";str = idx == 0 ? "无前驱结点" : "不存在该元素";cout << str;exit(error);}int cnt = 0;for(int i = 1;i < L.len;i++){if(L.elem[i] == cur_e){pre_e[cnt ++] = L.elem[i - 1];}}return cnt;}int nextElem(List L,ElemType cur_e,ElemType next_e[]){int idx = check2(L,cur_e);if(idx == L.len - 1 || idx == - 1){string str = "";str = idx == -1 ? "不存在该元素" : "无后驱结点";cout << str;exit(error);}int cnt = 0;for(int i = 0;i < L.len - 1;i++){if(L.elem[i] == cur_e){next_e[cnt ++] = L.elem[i + 1];}}return cnt;}void insert(List &L,int i,ElemType e){if(i < 1 || i > L.len + 1){cout << "下标越界!";exit(error);}if(L.len >= L.listsize){ElemType *newbase = (ElemType *)realloc(L.elem,(L.listsize + addSize) * sizeof(ElemType));if(!newbase){cout << "内存分配失败!";exit(overflow);}L.elem = newbase;L.listsize += addSize;for(int j = L.len;j > i - 1;j--)L.elem[j] = L.elem[j - 1];L.elem[i - 1] = e;L.len ++;}void deleteList(List &L,int i,ElemType &e){if(i < 1 || i > L.len + 1){cout << "下标越界!";exit(error);}e = L.elem[i - 1];for(int j = i - 1;j < L.len;j++)L.elem[j] = L.elem[j + 1];L.len --;}void merge(List L,List L2,List &L3){L3.elem = (ElemType *)malloc((L.len + L2.len) * sizeof(ElemType)); L3.len = L.len + L2.len;L3.listsize = initSize;if(!L3.elem){cout << "内存分配异常";exit(overflow);}int i = 0,j = 0,k = 0;while(i < L.len && j < L2.len){if(L.elem[i] <= L2.elem[j])L3.elem[k ++] = L.elem[i ++];else L3.elem[k ++] = L2.elem[j ++];}while(i < L.len)L3.elem[k ++] = L.elem[i ++];while(j < L2.len)L3.elem[k ++] = L2.elem[j ++];}bool visit(List L){if(L.len == 0) return false;for(int i = 0;i < L.len;i++)cout << L.elem[i] << " ";cout << endl;return true;}void listTraverse(List L){if(!visit(L)) return;}void partion(List *L){int a[100000],b[100000],len3 = 0,len2 = 0; memset(a,0,sizeof a);memset(b,0,sizeof b);for(int i = 0;i < L->len;i++){if(L->elem[i] % 2 == 0)b[len2 ++] = L->elem[i];elsea[len3 ++] = L->elem[i];}for(int i = 0;i < len3;i++)L->elem[i] = a[i];for(int i = 0,j = len3;i < len2;i++,j++) L->elem[j] = b[i];cout << "输出顺序表:" << endl;for(int i = 0;i < L->len;i++)cout << L->elem[i] << " ";cout << endl;}//以下是测试函数------------------------------------void test1(List &list){init(list);cout << "初始化完成!" << endl;}void test2(List &list){if(list.listsize == 0)cout << "线性表不存在!" << endl;else{int len;ElemType num;cout << "选择插入的元素数量:" << endl;cin >> len;cout << "依次输入要插入的元素:" << endl;for(int i = 1;i <= len;i++){cin >> num;insert(list,i,num);}cout << "操作成功!" << endl;}}void test3(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{cout << "请输入要返回的元素的下标" << endl;int idx;cin >> idx;cout << "线性表中第" << idx << "个元素是:" << getElem(L,idx) << endl;}}void test4(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{int idx;ElemType num;cout << "请输入要删除的元素在线性表的位置" << endl;cin >> idx;deleteList(L,idx,num);cout << "操作成功!" << endl << "被删除的元素是:" << num << endl; }}void test5(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{destroy(L);cout << "线性表已被销毁" << endl;}}void test6(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{clear(L);cout << "线性表已被清空" << endl;}}void test7(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else cout << "线性表的长度现在是:" << length(L) << endl;}void test8(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else if(empty(L))cout << "线性表现在为空" << endl;else cout << "线性表现在非空" << endl;}void test9(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{ElemType num;cout << "请输入待判定的元素:" << endl;cin >> num;cout << "第一个与目标元素满足大小关系的元素的位置:" << locateElem(L,num) << endl;}}void test10(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{ElemType num,num2[initSize / 2];cout << "请输入参照元素:" << endl;cin >> num;int len = priorElem(L,num,num2);cout << num << "的前驱为:" << endl;for(int i = 0;i < len;i++)cout << num2[i] << " ";cout << endl;}}void test11(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{ElemType num,num2[initSize / 2];cout << "请输入参照元素:" << endl;cin >> num;int len = nextElem(L,num,num2);cout << num << "的后继为:" << endl;for(int i = 0;i < len;i++)cout << num2[i] << " ";cout << endl;}}void test12(List list){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{cout << "输出线性表所有元素:" << endl;listTraverse(list);}}void test13(){if(L.listsize == 0)cout << "初始线性表不存在!" << endl; else{List L2,L3;cout << "初始化一个新线性表" << endl;test1(L2);test2(L2);cout << "归并两个线性表" << endl;merge(L,L2,L3);cout << "归并成功!" << endl;cout << "输出合并后的线性表" << endl;listTraverse(L3);}}void test14(){partion(&L);cout << "奇偶数分区成功!" << endl;}int main(){std::ios::sync_with_stdio(false);cin.tie(0),cout.tie(0);int op = 0;while(op != 15){cout << "-----------------menu--------------------" << endl;cout << "--------------1:初始化------------------" << endl;cout << "--------------2:插入元素----------------" << endl;cout << "--------------3:查询元素----------------" << endl;cout << "--------------4:删除元素----------------" << endl;cout << "--------------5:销毁线性表--------------" << endl;cout << "--------------6:清空线性表--------------" << endl;cout << "--------------7:线性表长度--------------" << endl;cout << "--------------8:线性表是否为空----------" << endl;cout << "--------------9:定位满足大小关系的元素--" << endl;cout << "--------------10:查询前驱---------------" << endl;cout << "--------------11:查询后继---------------" << endl;cout << "--------------12:输出线性表-------------" << endl;cout << "--------------13:归并线性表-------------" << endl;cout << "--------------14:奇偶分区---------------" << endl;cout << "--------------15: 退出测试程序-----------" << endl;cout << "请输入指令编号:" << endl; if(!(cin >> op)){cin.clear();cin.ignore(INT_MAX,'\n');cout << "请输入整数!" << endl;continue;}switch(op){case 1:test1(L);break;case 2:test2(L);break;case 3:test3();break;case 4:test4();break;case 5:test5();break;case 6:test6();break;case 7:test7();break;case 8:test8();break;case 9:test9();break;case 10:test10();break;case 11:test11();break;case 12:test12(L);break;case 13:test13();break;case 14:test14();break;case 15:cout << "测试结束!" << endl;default:cout << "请输入正确的指令编号!" << endl;}}return 0;}六、实验数据及处理结果1.初始化:2.插入元素3.查询元素(返回的是数组下标,下标从0开始)4.删除元素(位置从1开始)5.销毁顺序表6.清空顺序表7.顺序表长度(销毁或清空操作前)8.判空(销毁或清空操作前)9.定位满足大小关系的元素(销毁或清空操作前)说明:这里默认找第一个小于目标元素的位置且下标从0开始,当前顺序表的数据为:1 4 2 510.前驱(销毁或清空操作前)11.后继(销毁或清空操作前)12.输出顺序表(销毁或清空操作前)13.归并顺序表(销毁或清空操作前)七、思考讨论题或体会或对改进实验的建议通过本次实验,我掌握了定义线性表的顺序存储类型,加深了对顺序存储结构的理解,进一步巩固和理解了顺序表的基本操作,如建立、查找、插入和删除等。

数据结构 实验1顺序表和链表基本操作

数据结构   实验1顺序表和链表基本操作

实验一:线性表运算的实现一、实验预备知识1 复习C++中编写函数的相关内容。

2 复习如何用主函数将多个函数连在一起构成一个C++完整程序。

二、实验目的1 掌握线性表的顺序和链式存储结构2 熟练运用线性表在顺序存储方式下的初始化、创建、输出、插入和删除运算3 熟练运用线性表在链式存储方式下的创建、输出、插入和删除运算三、实验要求1 编写初始化并创建线性表和输出线性表的算法。

2 编写对线性表插入和删除运算算法,要判断位置的合法性和溢出问题。

3 编写一个主函数,将上面函数连在一起,构成一个完整的程序。

4将实验源程序调试并运行,写出输入、输出结果,并对结果进行分析。

四、实验步骤顺序表实验内容:1.给定的线性表为L=(12,25,7,42,19,38),元素由键盘输入。

2.初始化并建立顺序表。

3.编写顺序表输出算法。

(内存中开辟的单元数为8)4.依次插入3,21,15三个数,分别插入在第4,6和2位置,每插入一次都要输出一次顺序表。

5.删除第5,第3和第12个位置上的元素,每删除一个元素都要输出一次顺序表。

单链表实验内容:1.给定的线性表为L=(12,25,7,42,19,38),元素由键盘输入。

2.建立一个带表头结点的单链表(前插入法和尾插入法都可以)。

3.编写单链表输出算法。

4.依次插入3,21,15三个数,分别插入在第4,6和12位置,每插入一次都要输出一次单链表。

5.删除第5,第3和第12个位置上的元素,每删除一个元素都要输出一次单链表。

五、实验程序1..顺序表A.源代码:#include<iostream>const int Maxsize=20;typedef int DataType;typedef struct Seqlist{DataType data[Maxsize];int last;}Seqlist;using namespace std;Seqlist *InitList(){Seqlist *L;L=new Seqlist;if(L){L->last=0;return L;}else{cout<<"申请空间失败!"<<endl;return NULL;}}V oid Input_List(Seqlist *L){for(int i=0;i<6;i++)cin>>L->data[i];L->last+=6;}void Output_List(Seqlist *L){cout<<"当前表中存储数据如下:"<<endl;for(int i=0;i<L->last;i++)cout<<L->data[i]<<" ";cout<<endl;}int Ins_List(Seqlist *L,int i,DataType x){if(L->last==Maxsize-1){cout<<"对不起,当前表中可用空间已满!"<<endl;return -1;}I f(i<1||i>=L->last){cout<<"插入位置错误!"<<endl;return 0;}int j;for(j=L->last;j>=i-1;j--)L->data[j+1]=L->data[j];L->data[i-1]=x;L->last++;return 1;}void delete_List(Seqlist*L,int i){if(i<1||i>=L->last){cout<<"输入位置错误!"<<endl;return ;}else{for(int j=i-1;j<L->last;j++){L->data[j]=L->data[j+1];}L->last--;}}void main(){Seqlist *L;int j;DataType x;L=InitList();cout<<"请输入表中元素:"<<endl;Input_List(L);Output_List(L);cout<<"请输入插入元素的位置及其数值:"<<endl;for(int i=0;i<3;i++){cout<<"插入位置:";cin>>j;cout<<"元素数值:";cin>>x;Ins_List(L,j,x);Output_List(L);}cout<<"请输入要删除元素所在位置:"<<endl;for(i=0;i<3;i++){cout<<"元素位置:";cin>>j;delete_List(L,j);Output_List(L);}delete L;}B.运行结果示意图:2.链表A.源代码:#include<iostream>typedef int DataType;typedef struct LNode{DataType date;LNode *next;}*Linklist;int Lenth_list(LNode*);using namespace std;Linklist Creat_list(){LNode *H;H=NULL;DataType num;Linklist l,r;cout<<"请输入链表L,输入0结束输入:"<<endl;do{cin>>num;l=new LNode;if(l){if(H==NULL){l->date=num;l->next=NULL;H=l;r=l;}else{l->date=num;l->next=NULL;r->next=l;r=l;}}else{cout<<"申请空间失败!"<<endl;return NULL;}}while(num);return H;}void Output_list(LNode *H){cout<<"当前链表中所存储数据如下:"<<endl;LNode *p;p=H;while(p->next!=NULL){cout<<p->date<<" ";p=p->next;}cout<<endl;}void Ins_list(Linklist &H,int i,DataType x){if(i>Lenth_list(H)+1||i<1){cout<<"插入位置错误!"<<endl;return;}else{Linklist p,s;p=H;for(int j=0;j<i-2;j++)p=p->next;s=new LNode;if(s){if(i==1){s->date=x;s->next=H;H=s;}else{s->date=x;s->next=p->next;p->next=s;return;}}else{cout<<"申请失败!"<<endl;return;}}}int Lenth_list(LNode *H){if(H==NULL)return 0;else{Linklist p;int i=1;p=H;while(p->next!=NULL){p=p->next;i++;}return i;}}Linklist Delete_list(Linklist &H,int i){if(i>Lenth_list(H)||i<1){cout<<"位置错误!"<<endl;return NULL;}else{Linklist p,s;p=H;for(int j=0;j<i-2;j++)p=p->next;if(i==1){p=H;H=H->next;return p;}else{s=p->next;p->next=p->next->next;return s;}}}void main(){int i=0;DataType num=0;LNode *H;H=Creat_list();Output_list(H);cout<<"请输入插入元素的位置及其数值:"<<endl;for(int j=0;j<3;j++){cout<<"位置:";cin>>i;cout<<"数值:";cin>>num;Ins_list(H,i,num);Output_list(H);}cout<<"请输入删除元素所在位置:"<<endl;for(j=0;j<3;j++){cout<<"元素位置:";cin>>i;Delete_list(H,i);Output_list(H);}}B.运行结果示意图:六、总结本次实验是数据结构这门课程的第一次上机实验课,由于上课前未能很好地预习,以至于课上不能够完全明白老师所讲内容。

顺序表的实现实验报告

顺序表的实现实验报告

顺序表的实现实验报告顺序表的实现实验报告1. 引言顺序表是一种常见的数据结构,它可以用于存储一组有序的元素。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

数据结构实验⼀顺序表的实现数据结构实验⼀顺序表的实现数据结构实验⼀顺序表的实现班级学号姓名分数⼀、实验⽬的:1. 熟悉线性表的基本运算在两种存储结构(顺序结构和链式结构)上的实现;2. 以线性表的各种操作的实现为重点;3. 通过本次学习帮助学⽣加深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个位置插⼊元素,通过对⽐插⼊元素前后的线性表发⽣的变化,判断插⼊操作是否正确。

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

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

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

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

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

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

程序如下:头文件SqList.h的容如下:#include<stdio.h>#include<malloc.h>#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;Status InitList_Sq(SqList *L){L->elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L->elem) return(OVERFLOW);L->length=0;L->listsize=LIST_INIT_SIZE;return OK;}Status CreatList_Sq(SqList *L,int n){int i;printf("输入%d个整数:\n",n);for(i=0;i<n;i++)scanf("\n%d",&L->elem[i]);return OK;}//以下是整个源程序:#include<stdio.h>#include"SqList.h"int main(){int i,n;SqList a;SqList *l = &a;if(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;i<l->length;i++)printf("%7d",l->elem[i]);getchar();}程序的运行结果:2.顺序表的插入利用前面的实验先建立一个顺序表L,然后再第i个位置插入元素,通过对比插入元素前后的线性表发生的变化,判断插入操作是否正确。

参考程序:#include<stdio.h>#include<malloc.h>#include"SqList.h"Status ListInsert_Sq(SqList *L,int i,ElemType e){//在线性表L中的第i个位置前插入一个值为e的元素//i的取值围:1<=i<=ListLength_Sq(L)ElemType *newbase,*q,*p;if(i<1||i>L->length+1) return ERROR;//i值不合法if(L->length>=L->listsize){ //当前存储空间已满,增加分配量newbase=(ElemType*)realloc(L->elem,(L->listsize+LISTINCREMENT)*sizeof(ElemType));if(!newbase) return (OVERFLOW); //存储分配失败L->elem=newbase; //新基址L->length=+LISTINCREMENT; //增加存储容量}//ifq=&(L->elem[i-1]); //q为插入位置for(p=&(L->elem[L->length-1]);p>=q;--p) *(p+1)=*p;//插入位置及以后的元素右移*q=e; //插入e++L->length; //表长增1return OK;}//ListInsert_Sqint main(){int n,i,x;SqList *L,a;L=&a;InitList_Sq(L);printf("\n输入要建立的线性表L得长度:");scanf("%d",&n);L->length=n;CreatList_Sq(L,n);printf("\n插入元素之前线性表L的长度是:%d",L->length);printf("\n插入元素之前线性表L中的元素是:");for(i=0;i<L->length;i++)printf("%5d",L->elem[i]);printf("\n输入要插入元素的位置:");scanf("%d",&i);printf("\n输入要插入的元素的值:");scanf("\n %d",&x);if(ListInsert_Sq(L,i,x)>0){printf("\n插入元素之后线性表L的长度是: %d ",L->length);printf("\n插入元素之后线性表L的元素是:\n");for(i=0;i<L->length;i++)printf("%5d", L->elem[i]);}//ifelseprintf("不能插入这个元素!\n");getchar();}运行结果:4.单链表的实现新建链表,生成一个有一定结点的链表,并且顺序输出。

程序代码:#include"stdio.h"#include"stdlib.h"#include"string.h"#define null 0#define MAX 100 //最多元素个数#define LENGTH sizeof(struct Node)typedef int Elem ; //数据元素类型//单链表实现线性表struct Node{Elem data; //数据域struct Node *next; //指针域};typedef struct Node NODE;typedef struct Node *LINKLIST;//初始化链表,产生一个空链表LINKLIST InitList()//返回空链表的头指针{LINKLIST head;head=null;return head;}//新建链表,生成一个有一定结点的链表LINKLIST CreateList()//返回新链表的首地址(指针){LINKLIST head=null,p,q;int n,i;Elem temp;do{printf("请输入要建的结点数:");scanf("%d",&n);if(n<1 || n>MAX)printf("对不起!请输入的数在1-%d之间,请重新输入。

\n",MAX);}while(n<1 || n>MAX);for(i=0;i<n;i++){p=(LINKLIST)malloc(LENGTH); //开辟新结点空间printf("请输入第%d结点数据:",i+1);scanf("%d",&temp); //输入结点数据p->data=temp;if(head==null) //如果head指向空,则p结点为第一个结点{head=q=p;p->next=null;}else //不是第一个结点,则结点放到结尾并且,尾指针后移{p->next=null;q->next=p;q=p;}}return head; //返回新链表的首地址(指针)}//遍历打印链表int printList(LINKLIST h)//返回打印结果,0表示无数据,1表示成功打印完成{LINKLIST pt=h;if(pt==null) //没有数据直接返回{printf("对不起,没有数据!");return 0;}while(pt) //结点不为空就打印结点容{printf("%d ",pt->data);pt=pt->next;}printf("\n");return 1;}//求的链表的长度int ListLength(LINKLIST h)//求的链表长度,返回链表长度,若链表为空则返回0{LINKLIST pt=h;int len=0; //初始化计数器为0while(pt){len++;pt=pt->next;}return len; //返回链表长度}/*//向链表链表尾部添加结点,无输入LINKLIST AddNode(LINKLIST h,Elem e){LINKLIST head,pt,p;pt=head=h; //指向起始结点p=(LINKLIST)malloc(LENGTH); //开辟结点空间p->data=e; //向结点数据赋值p->next=null; //结点后继指向空if(pt==null) //若链表为空,直接作为第一个结点head=p;else //若不为空,将结点插在最后{while(pt->next){pt=pt->next;}pt->next=p;}return head; //返回头结点指针}*//*//向链表链表尾部添加结点,有输入LINKLIST AddNode(LINKLIST h){LINKLIST head,pt,p;pt=head=h; //指向起始结点p=(LINKLIST)malloc(LENGTH); //开辟结点空间printf("请输入要添加的数据:");scanf("%d",&p->data);p->next=null; //结点后继指向空if(pt==null) //若链表为空,直接作为第一个结点head=p;else //若不为空,将结点插在最后{while(pt->next){pt=pt->next;}pt->next=p;}return head; //返回头结点指针}*///将结点插入到链表的指定位置LINKLIST AddNode(LINKLIST h,int i,Elem e)//插入位置i,0<i,若i大于链表长度,则直接插在链表最后{LINKLIST head,pt,p;int j;pt=head=h;if(i<1) //插入位置错误(i<1),输出信息并结束程序{printf("程序出错,请检查参数!");exit(1);}if(pt && i>ListLength(h)) //链表不为空,且位置大于链表长度时{while(pt->next){pt=pt->next;}p=(LINKLIST)malloc(LENGTH); //开辟结点空间p->data=e; //向结点数据赋值p->next=null; //结点后继指向空pt->next=p;}else if(pt==null) //链表为空时{p=(LINKLIST)malloc(LENGTH); //开辟结点空间p->data=e; //向结点数据赋值p->next=null; //结点后继指向空head=p;}else //参数正确且链表不为空时{if(i==1) //插入点为第1个位置{p=(LINKLIST)malloc(LENGTH); //开辟结点空间p->data=e; //向结点数据赋值p->next=pt; //结点后继指向空head=p;}else //插入在链表中间位置时{p=(LINKLIST)malloc(LENGTH); //开辟结点空间p->data=e; //向结点数据赋值for(j=1;j<i-1;j++){pt=pt->next;}p->next=pt->next;pt->next=p;}}return head; //返回头结点指针}//删除链表中的某位置结点LINKLIST ListDelete(LINKLIST h,int i)//i在1到ListLength(h)之间{LINKLIST head,pt;int j=1;pt=head=h;if(h==null) //空表{printf("对不起,没有容!");return null;}if(i<1 || i>ListLength(h)) //检查i的围{printf("程序出错,请检查参数!");exit(1);}else //i合法,{if(i==1) //删除首结点{head=pt->next;free(pt);}else //删除中间节点或尾结点{while(j<i-1){pt=pt->next;j++;}pt->next=pt->next->next;}}return head; //返回头结点指针}//链表是否为空int ListEmpty(LINKLIST h)//返回0表示空,1表示链表不空{if(h==null)return 0;return 1;}//取得指定位置的元素的值Elem GetElem(LINKLIST h,int i)//返回结点的元素值{LINKLIST pt=h;int j=1;if(i>ListLength(h) || i<1) //检查参数{printf("程序出错,请检查参数!");exit(1);}while(j<i) //找到第i个结点{pt=pt->next;j++;}return (pt->data); //返回结点值}//链表的逆置LINKLIST Invert(LINKLIST h){LINKLIST head,middle,trail; //定义三个指针指向三个相邻的结点middle=null;while(h){ //循环交换相邻两个的指针指向trail=middle;middle=h;h=h->next;middle->next=trail;}head=middle; //将最后的结点变为链表头return head; //返回链表表头}//将两个链表合并为一个链表LINKLIST Union(LINKLIST La,LINKLIST Lb)//将La和Lb连接在一块,返回连接后的链表头指针{LINKLIST head,pa;if(La==null)head=Lb;else{head=pa=La;while(pa->next){pa=pa->next;}pa->next=Lb; //将Lb表头连接在链表La的结尾}return head; //返回链表表头}//将链表按非递减排序LINKLIST ToUpSort(LINKLIST h)//返回排好序后的头指针{LINKLIST p=h,q,temp;temp=(LINKLIST)malloc(LENGTH); //开辟临时交换结点while(p){q=p->next;while(q){if(q->data<p->data) //比较大小交换数据{temp->data=p->data;p->data=q->data;q->data=temp->data;}q=q->next;}p=p->next;}free(temp); //释放临时空间return h; //返回头结点}//将链表按非递增排序LINKLIST ToDownSort(LINKLIST h)//返回排好序后的头指针{LINKLIST p=h,q,temp;temp=(LINKLIST)malloc(LENGTH); //开辟临时交换结点while(p){q=p->next;while(q){if(q->data>p->data) //比较大小交换数据{temp->data=p->data;p->data=q->data;q->data=temp->data;}q=q->next;}p=p->next;}free(temp); //释放临时空间return h; //返回头结点}//比较结点大小int compare(NODE e1,NODE e2)//若e1>e2返回1,若e1=e2返回0,若e1<e2返回-1{return 0;}int main(){LINKLIST p,q;Elem n=8,i;p=CreateList();p=ToUpSort(p);printList(p);return 0;}运行结果:。

相关文档
最新文档