C语言顺序表实验报告

合集下载

数据结构C语言版 实验报告

数据结构C语言版 实验报告

数据结构C语言版实验报告一、实验目的本次实验旨在通过使用 C 语言实现常见的数据结构,加深对数据结构基本概念、原理和操作的理解,提高编程能力和解决实际问题的能力。

二、实验环境操作系统:Windows 10编程环境:Visual Studio 2019编程语言:C 语言三、实验内容1、线性表顺序表的实现与操作链表的实现与操作2、栈和队列栈的实现与应用(表达式求值)队列的实现与应用(模拟排队)3、树和二叉树二叉树的遍历(前序、中序、后序)二叉搜索树的实现与操作4、图图的存储结构(邻接矩阵、邻接表)图的遍历(深度优先搜索、广度优先搜索)四、实验步骤及结果1、线性表顺序表的实现与操作定义顺序表的数据结构,包括数组和表的长度。

实现顺序表的初始化、插入、删除、查找等操作。

测试顺序表的各种操作,输出操作结果。

```cinclude <stdioh>include <stdlibh>define MAX_SIZE 100typedef struct {int dataMAX_SIZE;int length;} SeqList;//初始化顺序表void initList(SeqList L) {L>length = 0;}//插入元素到顺序表int insertList(SeqList L, int pos, int element) {if (L>length >= MAX_SIZE || pos < 0 || pos > L>length) {return 0;}for (int i = L>length 1; i >= pos; i) {L>datai + 1 = L>datai;}L>datapos = element;L>length++;return 1;}//删除顺序表中的元素int deleteList(SeqList L, int pos) {if (pos < 0 || pos >= L>length) {return 0;}for (int i = pos; i < L>length 1; i++){L>datai = L>datai + 1;}L>length;return 1;}//查找顺序表中的元素int searchList(SeqList L, int element) {for (int i = 0; i < Llength; i++){if (Ldatai == element) {return i;}}return -1;}int main(){SeqList L;initList(&L);insertList(&L, 0, 10);insertList(&L, 1, 20);insertList(&L, 2, 30);printf("顺序表元素: ");for (int i = 0; i < Llength; i++){printf("%d ", Ldatai);}printf("\n");int pos = searchList(L, 20);if (pos!=-1) {printf("元素 20 在顺序表中的位置: %d\n", pos);} else {printf("顺序表中未找到元素 20\n");}deleteList(&L, 1);printf("删除元素后的顺序表元素: ");for (int i = 0; i < Llength; i++){printf("%d ", Ldatai);}printf("\n");return 0;}```实验结果:成功实现顺序表的初始化、插入、删除、查找等操作,输出结果符合预期。

顺序表的操作实验报告

顺序表的操作实验报告

顺序表的操作实验报告顺序表的操作实验报告一、引言顺序表是一种常见的数据结构,它在计算机科学中被广泛应用。

本实验旨在通过实际操作顺序表,探索其基本操作和性能。

二、实验目的1. 理解顺序表的基本原理和数据结构;2. 掌握顺序表的插入、删除、查找等操作;3. 分析顺序表操作的时间复杂度。

三、实验过程1. 初始化顺序表:首先,我们创建一个空的顺序表,并设定其初始长度为10。

2. 插入元素:在顺序表中插入若干个元素,观察插入操作的效果。

我们可以通过在表尾插入元素,或者在表中间插入元素来测试插入操作的性能。

3. 删除元素:从顺序表中删除指定位置的元素,并观察删除操作的效果。

我们可以选择删除表尾元素或者表中间元素来测试删除操作的性能。

4. 查找元素:在顺序表中查找指定元素,并返回其位置。

我们可以选择查找表头元素、表尾元素或者表中间元素来测试查找操作的性能。

5. 扩容操作:当顺序表的长度不足以容纳更多元素时,我们需要进行扩容操作。

在实验中,我们可以在插入元素时观察到扩容操作的效果。

四、实验结果与分析1. 初始化顺序表:成功创建了一个长度为10的空顺序表。

2. 插入元素:通过在表尾插入10个元素,我们观察到插入操作的时间复杂度为O(1)。

然而,当我们在表中间插入元素时,需要将插入位置之后的所有元素后移,时间复杂度为O(n)。

3. 删除元素:从表尾删除元素的时间复杂度为O(1),而从表中间删除元素需要将删除位置之后的所有元素前移,时间复杂度为O(n)。

4. 查找元素:在顺序表中查找元素的时间复杂度为O(n),因为需要逐个比较每个元素。

5. 扩容操作:当顺序表的长度不足以容纳更多元素时,我们需要进行扩容操作。

在实验中,我们观察到扩容操作的时间复杂度为O(n),因为需要将原有元素复制到新的更大的空间中。

五、实验总结通过本次实验,我们深入了解了顺序表的基本操作和性能。

顺序表的插入、删除和查找操作的时间复杂度与操作位置有关,需要注意选择合适的操作位置以提高效率。

实验一顺序表的基本操作实验报告

实验一顺序表的基本操作实验报告

元素之后的所有数据都前移一个位置,最将线性表长减1。

3.顺序表查找操作的基本步骤:要在顺序表中查找一个给定值的数据元素则可以采用顺序查找的方法,从表中第 1 个数据元素开始依次将值与给定值进行比较,若相等则返回该数据元素在顺序表中的位置,否则返回0 值。

线性表的动态分配顺序存储结构—C语言实现#define MaxSize 50//存储空间的分配量Typedef char ElemType;Typedef struct{ElemType data[MaxSize];int length; //表长度(表中有多少个元素)}SqList;动态创建一个空顺序表的算法:void InitList(SqList *&L) //初始化线性表{L=(SqList *)malloc(sizeof(SqList)); //分配存放线性表的空间L->length=0; //置空线性表长度为0}线性表的插入:status Sqlist_insert(Sqlist &L,int i,Elemtype x)/*在顺序表L中第i个元素前插入新元素x*/{ if (i<1||i>L.length+1) return ERROR; /*插入位置不正确则出错*/if (L.length>=MAXLEN)return OVERFLOW;/*顺序表L中已放满元素,再做插入操作则溢出*/for(j=L.length-1;j>=i-1;j--)L.elem[j+1]=L.elem[j]; /*将第i个元素及后续元素位置向后移一位*/L.elem[i-1]=x; /*在第i个元素位置处插入新元素x*/L.length++; /*顺序表L的长度加1*/return OK;}线性表的删除:status Sqlist_delete(Sqlist &L,int i,Elemtype &e)/*在顺序表L中删除第i个元素*{ if (i<1||i>L.length) return ERROR; /*删除位置不正确则出错*/for(j=i;j<=L.length-1;j++)L.elem[j-1]=L.elem[j]; /*将第i+1个元素及后继元素位置向前移一位*/L.length--;/*顺序表L的长度减1*/return OK;}线性表元素的查找:int LocateElem(SqList *L, ElemType e) //按元素值查找{int i=0;while (i<L->length && L->data[i]!=e)i++; //查找元素eif (i>=L->length) //未找到时返回0return 0;elsereturn i+1; //找到后返回其逻辑序号}输出线性表:void DispList(SqList *L) //输出线性表{int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf("%c ",L->data[i]);printf("\n");}输出线性表第i个元素的值:bool GetElem(SqList *L,int i,ElemType &e)//求线性表中某个数据元素值{if (i<1 || i>L->length)return false; //参数错误时返回falsee=L->data[i-1]; //取元素值return true; //成功找到元素时返回true}代码:#include <stdio.h>#include <malloc.h>#define MaxSize 50typedef char ElemType;typedef struct{ElemType data[MaxSize];int length;} SqList;void InitList(SqList *&L);void DestroyList(SqList *L);bool ListEmpty(SqList *L);int ListLength(SqList *L);void DispList(SqList *L);bool GetElem(SqList *L,int i,ElemType &e);int LocateElem(SqList *L, ElemType e);bool ListInsert(SqList *&L,int i,ElemType e);bool ListDelete(SqList *&L,int i,ElemType &e);void InitList(SqList *&L)//初始化线性表{L=(SqList *)malloc(sizeof(SqList));//分配存放线性表的空间L->length=0;//置空线性表长度为0 }void DestroyList(SqList *L)//销毁线性表{free(L);}bool 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->data[i]);printf("\n");}bool GetElem(SqList *L,int i,ElemType &e)//求线性表中某个数据元素值{if (i<1 || i>L->length)return false;//参数错误时返回falsee=L->data[i-1];//取元素值return true;//成功找到元素时返回true}int LocateElem(SqList *L, ElemType e)//按元素值查找{int i=0;while (i<L->length && L->data[i]!=e)i++;//查找元素eif (i>=L->length)//未找到时返回0return 0;elsereturn i+1;//找到后返回其逻辑序号}bool ListInsert(SqList *&L,int i,ElemType e)//插入数据元素{int j;if (i<1 || i>L->length+1)return false;//参数错误时返回falsei--;//将顺序表逻辑序号转化为物理序号for (j=L->length;j>i;j--)//将data[i]及后面元素后移一个位置L->data[j]=L->data[j-1];L->data[i]=e;//插入元素eL->length++;//顺序表长度增1return true;//成功插入返回true}bool ListDelete(SqList *&L,int i,ElemType &e)//删除数据元素{int j;if (i<1 || i>L->length)//参数错误时返回falsereturn false;i--;//将顺序表逻辑序号转化为物理序号e=L->data[i];for (j=i;j<L->length-1;j++)//将data[i]之后的元素前移一个位置L->data[j]=L->data[j+1];L->length--;//顺序表长度减1return true;//成功删除返回true}void main(){SqList *L;ElemType e;printf("顺序表的基本运算如下:\n");printf(" (1)初始化顺序表L\n");InitList(L);printf(" (2)依次采用尾插法插入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(" (3)输出顺序表L:");DispList(L);printf(" (4)顺序表L长度=%d\n",ListLength(L));printf(" (5)顺序表L为%s\n",(ListEmpty(L)?"空":"非空"));GetElem(L,3,e);printf(" (6)顺序表L的第3个元素=%c\n",e);实验结果:心得体会:通过本次实验,实现了数据结构在程序设计上的作用,了解了数据结构语言,加深了对c语言的认识掌并掌握了线性表的顺序存储结构的表示和实现方法,掌握顺序表基本操作的算法实现,同时了解了顺序表的应用。

C语言顺序表实验报告

C语言顺序表实验报告

实验报告要求一、实验目的二、实验内容三、程序流程图四、实验结果(要求检测所有情况的正确性,写出测试条件及相应的测试结果)五、完成思考题实验一顺序表的基本操作(2学时)一、实验目的了解顺序表的逻辑特征,掌握顺序表的描述方法、特点及有关的概念,掌握顺序表上的插入和删除等基本操作算法。

二、实验内容在顺序表List []中,实现顺序表的基本操作,包括:初始化顺序表,在表中插入元素、删除元素。

基本要求:(1)顺序表的元素个数可随意设定;(2)可连续测试任意多个元素的插入、删除,(插入、删除位置及要插入元素数值均从键盘输入);(3)任一操作结束后将顺序表中的内容输出;(4)可由用户选择退出程序。

三、实验要点及说明顺序表又称为线性表的顺序存储结构,它是用一组地址连续的存储单元依次存放线性表的各个元素。

可按如下格式定义顺序表:#define MAXLEN 50 /*定义顺序表最大元素个数50 */ typedef struct{datatype List[MAXLEN]; /* 定义顺序表List */int Num; /* 定义顺序表表长*/}Seqlist;模块划分:(1)initiq( )函数:初始化顺序表(2)insertq( )函数:实现插入功能(3)deleteq( )函数:实现删除功能(4)print( )函数:实现输出功能四、参考源程序#include <>#define MAXLEN 50typedef int datatype;typedef struct{datatype List[MAXLEN];int Num;}Seqlist;void initiq(Seqlist *la );int insertq(Seqlist *la,int n);int deleteq(Seqlist *la,int n);int print(Seqlist *la);void main(){ Seqlist la;i nt s,n; /* s 选择输入, n 插入或删除数据的个数*/p rintf("请输入你的选择: 1---initiate 2---insert 3---delete 4---print 5---exit\nyour choice =");s canf("%d",&s);w hile(s!=5){ if(s==1){ initiq( &la );printf("完成初始化 !\n"); }else if(s==2){ printf("请输入待插入的数据个数:");scanf("%d",&n);insertq(&la,n);print(&la); }else if(s==3){ printf("请输入待删除的数据个数:");scanf("%d",&n);deleteq(&la,n);print(&la); }else if(s==4){ print(&la); }elseprintf("你的选择是错误的!\n ");printf("请输入你的选择: 1---initiate 2---insert 3---delete 4---print 5---exit\nyour choice =");scanf("%d",&s); } }/*初始化*/void initiq(Seqlist *la ){ la-> Num=0; }/*插入*/int insertq(Seqlist *la,int n){ int i,j; /* i 插入位置, j 顺序表下标 */d atatype x; /* x 插入数据 */w hile(n){ if (la->Num>=MAXLEN-1){ printf ("\n 表满,不能插入!插入未完成,还有%d个数据未插入\n",n);return 0; }printf("请输入插入的位置和数据:");scanf("%d%d",&i,&x);if (i<0||i>la->Num){ printf ("\n 插入位置不合理!\n"); } else{ if (i== la->Num)la->List[i]=x;else{ for ( j=la->Num; j>i; j--)la->List[j]=la->List[j-1];la->List[i]=x; }la->Num++;n--; } }p rintf("插入完成\n");r eturn 1; }/*删除*/int deleteq(Seqlist *la,int n){ int i,j; /* i 删除位置, j 顺序表下标 */w hile(n){ if (la->Num<=0){ printf ("\n 表空,不能删除!\n");return 0; }printf("请输入删除的位置:");scanf("%d",&i);if (i<0||i>=la->Num){ printf ("\n 删除位置错误!\n"); }else{ for ( j=i+1; j<la->Num; j++)la->List[j-1]=la->List[j];la->Num--;n--; } }p rintf("删除完成!\n");r eturn 1; }/*显示输出*/int print (Seqlist *la){ int m;i f (la->Num<=0){ printf("顺序表为空!\n");return 0; }e lse{ printf("当前的顺序表为:\n");for(m=0;m<la->Num;m++)printf("List[%d]=%d ",m,la->List[m]);printf("\n表长为%d\n",la->Num);return 1; } }五、思考题1.设顺序表L中的数据元素按递增排列,编写一个算法,将数据元素x插入到顺序表L的适当位置上,以保持顺序表的有序性。

顺序表实验报告

顺序表实验报告

顺序表实验报告1. 简介顺序表是一种常用的数据结构,它在计算机科学中有着重要的应用。

本实验旨在通过实践操作顺序表,深入理解其原理和实现方式。

2. 实验目的本次实验有以下几个目的:- 学习使用顺序表来存储和操作数据;- 掌握顺序表的插入、删除、查找等基本操作;- 理解顺序表的实现原理,并分析其优缺点。

3. 实验环境和工具本实验所用环境为Windows系统,编程语言为C++。

编程工具可以选择Visual Studio或者其他C++开发工具。

4. 实验步骤4.1 实验准备首先,我们需要定义顺序表的数据结构。

例如,我们可以定义一个结构体,其中包含一个数组和一个指示当前表中元素个数的变量。

4.2 插入操作接下来,我们可以编写插入操作的函数。

插入操作的目的是将一个元素插入到指定位置,并保持表中其他元素的顺序。

可以使用循环将需要移动的元素逐个后移,然后将新元素插入到指定位置。

4.3 删除操作与插入操作类似,删除操作也需要保持表中其他元素的顺序。

可以使用循环将需要删除的元素之后的元素逐个前移,然后将最后一个元素的位置置为空。

4.4 查找操作查找操作可以通过循环遍历表中的元素,并与目标元素进行比较,直到找到相等的元素或者遍历到表尾。

5. 实验结果与分析经过实验,我们可以发现使用顺序表存储数据的效率较高。

顺序表的插入和删除操作时间复杂度为O(n),其中n为表中元素个数。

这是因为插入或删除一个元素后,需要移动其他元素以保持顺序。

而查找操作的时间复杂度为O(n),在最坏的情况下需要遍历整个表才能找到目标元素。

此外,顺序表还具有便于随机访问的优点。

由于顺序表中元素在内存中连续存储,可以直接通过索引访问表中的任意元素,因此查找效率较高。

然而,顺序表也有一些缺点。

首先,插入和删除操作需要移动大量元素,当表中元素个数较大时,操作的时间复杂度会较高。

其次,由于顺序表必须预先分配一定大小的连续空间,因此当表中元素个数超过初始大小时,需要进行动态扩容操作。

c语言顺序表实验报告

c语言顺序表实验报告

c语言顺序表实验报告
C语言顺序表实验报告
实验目的:通过对C语言顺序表的实验,掌握顺序表的基本操作和实现方法,加深对数据结构的理解。

实验内容:本次实验主要包括以下内容:
1. 顺序表的创建与初始化
2. 顺序表的插入与删除
3. 顺序表的查找与修改
4. 顺序表的销毁与清空
实验步骤:
1. 创建顺序表:首先定义一个结构体来表示顺序表,包括表头指针、表长和表的最大长度等信息。

然后利用malloc函数为顺序表分配内存空间,并初始化表长和各元素的值。

2. 插入与删除操作:通过编写插入和删除函数来实现在顺序表中插入和删除元素的操作。

插入操作需要考虑插入位置的合法性和表的扩容问题,删除操作需要考虑删除位置的合法性和表的缩容问题。

3. 查找与修改操作:编写查找和修改函数来实现在顺序表中查找和修改元素的操作。

查找操作可以采用顺序查找或二分查找的方法,修改操作需要考虑修改位置和修改值的合法性。

4. 销毁与清空操作:编写销毁和清空函数来实现销毁和清空顺序表的操作。

销毁操作需要释放表的内存空间,清空操作需要将表的长度置零。

实验结果:经过实验,成功实现了顺序表的创建、插入、删除、查找、修改、
销毁和清空等基本操作。

通过实验,加深了对顺序表的理解和掌握,提高了对C语言和数据结构的应用能力。

实验总结:通过本次实验,我深刻认识到了数据结构在程序设计中的重要性,掌握了顺序表的基本操作和实现方法。

在今后的学习和工作中,我将继续加强对数据结构和算法的学习,不断提升自己的编程能力和解决问题的能力。

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

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

数据结构实验一顺序表实验报告一、实验目的本次实验的主要目的是通过实现顺序表的基本操作,深入理解线性表的逻辑结构和存储结构,掌握顺序表的插入、删除、查找等操作的实现方法,提高编程能力和问题解决能力。

二、实验环境本次实验使用的编程语言为 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 语言项目。

顺序表的操作实验报告

顺序表的操作实验报告

实验二顺序表的操作实验报告班级xxxx 学号xxxx 姓名xxxx实验名称顺序表的操作实验目的掌握线性表的顺序存储结构的基本概念、基本操作和应用实验环境硬件环境:微型计算机软件环境:Windows 2000或以上版本,turboc2.0实验内容1.创建顺序表,顺序表的元素的值由用户从键盘输入。

2.在已经创建的顺序表中插入一个元素。

从键盘读入元素值和插入位置,在指定的位置前插入。

3.在已经创建的顺序表中删除一个元素。

从键盘读入欲删除的元素位置,在指定的位置删除元素。

实验步骤及结果线性表的插入线性表的删除#include <stdio.h>#define OK 1#define ERROR 0#define ElemType int#define LIST_INT_SIZE 100#define LISTINCREMENT 10typedef struct{ElemType *elem;int length;int listsize;}SqList;int InitList_Sq(SqList *L){L->elem=(ElemType*)malloc(LIST_INT_SIZE*sizeof(ElemType));if (!L->elem) return OK;L->length=0;L->listsize=LIST_INT_SIZE;return OK;}int ListInsert_Sq(SqList *L,int i,ElemType e){ElemType *p, *q, *newbase;if (i < 1 || i > L->length+1) return ERROR;if (L->length >= L->listsize){ newbase = (ElemType *)realloc(L->elem,(L->listsize+LISTINCREMENT)*sizeof(ElemType));#include <stdio.h>#define OK 1#define ERROR 0#define ElemType int#define LIST_INT_SIZE 100#define LISTINCREMENT 10typedef struct{ElemType *elem;int length;int listsize;}SqList;int InitList_Sq(SqList *L){L->elem=(ElemType*)malloc(LIST_INT_SIZE*sizeof(ElemType));if (!L->elem) return OK;L->length=0;L->listsize=LIST_INT_SIZE;return OK;}int ListDelete_Sq(SqList *L, int i, ElemTypee){ElemType *p, *q;if (i<1 || i>L->length) return ERROR;p = &(L->elem[i-1]);e = *p;q = L->elem+L->length-1;for (++p; p<=q; ++p) *(p-1) = *p;if (!newbase) return ERROR;L->elem = newbase;L->listsize += LISTINCREMENT; }q = &(L->elem[i-1]);for (p = &(L->elem[L->length-1]); p>=q;--p) *(p+1) = *p;*q = e;++L->length;return OK;}int main(){SqList *L;int i,e;if (! InitList_Sq(L)) return ERROR;printf("Please input the length of thelist(1-100) : ");scanf("%d",& L->length);for(i=0;i< L->length;i++)scanf("%d",& L-> elem[i]);printf("The old Sqlist is : \n");for(i=0;i< L->length;i++)printf("%d ",L-> elem[i]); printf("\nPlease input the location to insert(1 to L->length+1) : \n");scanf("%d",&i);while(i<1||i> L->length+1){printf("Please input the location toinsert (1 to 11) : \n ");scanf("%d",&i);}printf("Please input the integer to insert(eg,58) : ");scanf("%d",&e);if(ListInsert_Sq(L,i,e)){printf("The new Sqlist is : ");for(i=0;i< L->length;i++)printf("%d ",L-> elem[i]);}}--L->length;return OK;}int main(){SqList *L;int i,e;if (! InitList_Sq(L)) return ERROR; printf("Please input the length of thelist(1-100) : ");scanf("%d",&L->length);for(i=0;i< L->length;i++)scanf("%d",& L-> elem[i]);printf("The old Sqlist is : \n");for(i=0;i< L->length;i++)printf("%d ",L-> elem[i]); printf("\nPlease input the location to outsert (1 to L->length-1) : \n");scanf("%d",&i);while(i<1||i> L->length+1){printf("Please input the location to insert (1 to L.length-1) : \n ");scanf("%d",&i);}if(ListDelete_Sq(L,i,e)){printf("The new Sqlist is : ");for(i=0;i< L->length;i++)printf("%d ",L-> elem[i]);}}运行结果:运行时,它会提示“Please input the length of the list(1-100) :”我们就可以输入一个值为1-100中的任意一个数。

顺序表,链表实验报告.总结

顺序表,链表实验报告.总结

顺序表,链表实验报告.总结实验报告实验目的:学生管理系统(顺序表)实验要求:1.建表2.求表长3.插入4.查找5.删除6.列表7.退出源程序:#include#include#include#define MaxSize 1000typedef struct{char xh[40];char xm[40];int cj;}DataType; //学生的结构typedef struct {DataType data[MaxSize]; //定义表的数据类型int length; //数据元素分别放置在data[0]到data[length-1]当中} SqList; //表的结构void liebiao(SqList *L) //建立表格{int k,n;char q;printf("请输入,输入学生的个数:\n");fflush(stdin);scanf("%d",&n);for(k=0;k<=n-1;k++){printf("请输入学生学号\n");scanf("%s",L->data[k].xh);printf("请输入学生名字\n");scanf("%s",L->data[k].xm);printf("请输入学生成绩\n");scanf("%d",&L->data[k].cj);}L->length=n;}void qb(SqList *L) //全部输出{int k,w;for(k=0;klength;k++){w=k+1;printf("第%d位学生:",w);printf("%s %s %d\n",L->data[k].xh,L->data[k].xm,L->da ta[k].cj);}}int cr(SqList *L,DataType *xs,int i) //插入信息{int j;if(L->length==MaxSize){printf("没有!");return 0;}else if((i<0)||(i>L->length)){printf("程序溢出,不符合");return 0;}else{for(j=L->length-1;j>=i;j--){strcpy(L->data[j+1].xh,L->data[j].xh); strcpy(L->data[j+1].xm,L->data[j].xm); L->data[j+1].cj=L->data[j].cj;}strcpy(L->data[i].xh,xs->xh);strcpy(L->data[i].xm,xs->xm);L->data[i].cj=xs->cj;L->length=L->length+1;}return 0;}int cz(SqList *L) //查找信息{char xh[40];char xm[40];int cj;int i=0,u;printf(" 1、按学号查询 \n");printf(" 1、按姓名查询 \n");printf(" 1、按成绩查询 \n");printf("请选择:");fflush(stdin);scanf("%d",&u);if (u==1){printf("请输入要查找学生的学号:"); scanf("%s",xh);for(i=0;ilength;i++){if(strcmp(L->data[i].xh,xh)==0) return i;}}if (u==2){printf("请输入要查找学生的姓名:"); scanf("%s",xm);for(i=0;ilength;i++){if(strcmp(L->data[i].xm,xm)==0) return i;}}if (u==3){printf("请输入要查找学生的成绩:"); scanf("%s",cj);for(i=0;ilength;i++){if(L->data[i].cj,&cj)return i;}}return -1;//*如果没找到,返回-1}int cz2(SqList *L) //删除查找的函数{char xh[40];char xm[40];int i=0,h;printf(" 1、按学号删除 \n");printf(" 2、按姓名删除 \n");printf("请选择:");fflush(stdin);scanf("%d",&h);if (h==1){printf("请输入要删除学生的学号:");scanf("%s",xh);for(i=0;ilength;i++){if(strcmp(L->data[i].xh,xh)==0) //判断输入和已知学号一样不return i;}}else if (h==2){printf("请输入要删除学生的姓名:");scanf("%s",xm);for(i=0;ilength;i++){if(strcmp(L->data[i].xm,xm)==0) //判断输入姓名和已知姓名一样不return i;}}return -1;}void sc(SqList *L) //删除函数{int i,j;printf("请先选择您要删除的学生信息的方式:\n");scanf("%d",&j);i=cz2(L);if(i==-1){printf("没有查到要删除的学生信息");return;}for(j=i;jlength;j++) // 要删除学生以后的学生整体上调一位{L->data[j].cj=L->data[j+1].cj; //就是后一个覆盖了前一个strcpy(L->data[j].xh,L->data[j+1].xh);strcpy(L->data[j].xm,L->data[j+1].xm);}L->length--;printf("该学生信息已被删除!\n");}int bc(SqList *L){return (L->length);}int main() //主体大函数{int i,k;SqList *L; //定义顺序表的指针DataType *xs;L=(SqList *)malloc(sizeof(SqList)*MaxSize); char q;ee:rewind(stdin);{printf(" 学生管理系统 \n"); //函数的各个结构printf(" \n");printf(" \n");printf(" \n");printf(" 建立表格请输入1 \n");printf(" 求表长请输入2 \n");printf(" 插入请输入3 \n");printf(" 查找请输入4 \n");printf(" 删除请输入5 \n");printf(" 列表请输入6 \n");printf(" 退出请按0 \n");printf(" 请输入");scanf("%c",&q);}if(q=='1'){rewind(stdin);liebiao(L);goto ee;}if(q=='2'){rewind(stdin);bc(L);printf("共%d个学生\n",L->length);goto ee;}if(q=='3'){rewind(stdin);printf(" 插入 \n");printf("\t\t 请输入要添加的学生信息: \n"); xs=(DataType *)malloc(sizeof(DataType)); printf("请输入学生学号\n");scanf("%s",xs->xh);printf("请输入学生名字\n");scanf("%s",xs->xm);printf("请输入学生成绩\n");scanf("%d",&xs->cj);printf("请输入要插入的位置:\n"); rewind(stdin);scanf("%d",&i);cr(L,xs,i);goto ee;}if(q=='4'){rewind(stdin);printf(" 查找 \n");printf(" 查询学生信息 \n");i=cz(L);if(i!=-1){printf("%s %s %d\n",L->data[i].xh,L->data[i].x m,L->data[i].cj);}else{printf("信息不存");}goto ee;}if(q=='5'){rewind(stdin);printf(" 删除 \n"); printf(" 删除学生信息 \n");sc(L);goto ee;}if(q=='6'){rewind(stdin);printf(" 列表 \n");qb(L);goto ee;}if(q=='0') {printf("谢谢使用\n");}if(!(q=='1'||q=='2'||q=='3'||q=='4'||q=='5'||q=='5'||q=='0 ')) {goto ee;}system ("pause"); return 0;}主程序:输入1--6n=1 n=2n=3n=4n=5n=6退出建表求表长插入查找删除列表建表:是否输入学生个数n ,变量k k=0; k<=n-1;输入学号,姓名,成绩k=k+1 结束输入查找学号n,变量k k=0n=k是否k=k+1输出是否是否输入插入位置n 表长L 变量kn<=Lk=0n=kk=k+1strcpy(L->data[j+1].xh,L->data[j].xh);strcpy(L->data[j+1].xm,L->data[j].xm);L->data[j+1].cj=L->data[j].cj输入错误结束是否否是输入删除的位置n 变量k 表长Ln<=Lk=0n=k k=k+1strcpy(L->data[j].xh,L->data[j-1].xh);strcpy(L->data[j].xm,L->data[j-1].xm); L->data[j].cj=L->data[j-1].cj输入错误结束。

数据结构实验报告(C语言)顺序表__排序

数据结构实验报告(C语言)顺序表__排序
//冒泡排序 void BubbleSort(SqeList *L){
int i,j,n,x,change; n=L->length; change=1; for(i=1;i<=n-1 && change;++i){
change=0; for(j=1;j<=n-i-1;++j)
if(L->r[j] > L->r[j+1]){ x=L->r[j]; L->r[j]=L->r[j+1]; L->r[j+1]=x; change=1;
void QuickSort(SqeList *L,int low,int high){ int mid; if(low<high){ mid=Partition(L,low,high); QuickSort(L,low,mid-1); QuickSort(L,mid+1,high); }
}
//直接选择排序
printf("\n7-直接选择排序结果为:\n"); SelectSort(&l); PrintList(&l); printf("\n"); printf("\n8-二路归并结果为:\n"); MergeSort(&l);
PrintList(&l); printf("\n"); } else printf("请输入大于 0 的值: "); return 0; }
} else{
MR->r[k]=R->r[j]; ++j; } ++k; } while(i<=mid) MR->r[k++]=R->r[i++]; while(j<=high) MR->r[k++]=R->r[j++]; }

数据结构顺序表实验报告

数据结构顺序表实验报告

《顺序表的一些基本操作-实验报告》实验内容:实现顺序表的初始化,数据元素的遍历,增、删、改、查等功能。

操作环境:C语言编程环境操作系统:win10源码:#include<stdio.h>#include<stdlib.h>#include<conio.h>#define OVERFLOW -2#define LISTINCREMENT 10#define ListSize 50typedef struct{//结构的定义int * elem;//数据域int length;//当前表长int listsize;}SeqList;void Create(SeqList &L,int n){//顺序表建立L.elem=(int*)malloc((ListSize+1)*sizeof(int));if (!L.elem){exit(0);}L.listsize=ListSize;printf("请输入%d 组数据:\n",n);for(int i=1;i<=n;i++){scanf("%d",&L.elem[i]);}L.length=n;}void Print(SeqList L){//打印函数printf("下面为你的顺序表:\n");for(int i=1;i<=L.length;i++){printf("%d ",L.elem[i]);}}int Find(SeqList L,int x){//查找for(int i=1;i<=L.length;i++){if((L.elem[i])==x){return i;}}return 0;}void Insert(SeqList &L,int i,int e){//插入int *p;int *q;int *newbase;if(i>=1&&i<=L.length+1){if(L.length>=L.listsize){newbase=(int*)realloc(L.elem,(LISTINCREMENT+L.listsize)*sizeof(int));if(!newbase){exit(OVERFLOW);}L.elem=newbase;L.listsize += LISTINCREMENT;}q=&(L.elem[i]);for(p=&(L.elem[L.length]);p>=q;--p){*(p+1)=*p;}*q=e;++L.length;}else{printf("操作失败.");}}void Delete(SeqList &L,int i){//删除int *p;int *q;if((i>=1)&&(i<=L.length)){p=&(L.elem[i]);q=L.elem+L.length;for(++p;p<=q;++p){*(p-1)=*p;}--L.length;}else{printf("操作失败.");}}int main(){SeqList L;L.length=0;int i,x;int n;system("cls"); //清屏//1.创建顺序表printf("请输入数据数量:\n");scanf("%d",&n);Create(L,n);Print(L);//2.查找printf("\n请输入欲查找数据的位置:");scanf("%d",&x);i=Find(L,x);printf("%d 位置的数据为%d",x,i);//3.插入printf("\n请输入数据插入位置:\n");scanf("%d",&i);printf("\n请输入要插入的数据\n");scanf("%d",&x);Insert(L, i, x);Print(L);//打印//4.删除printf("\n请输入要删除数据的位置:\n");scanf("%d",&i);Delete(L,i);Print(L); //打印getchar();return 0;}运行截图创建查找插入删除。

顺序表基本算法实验报告

顺序表基本算法实验报告

C语言程序设计实践综合题目:顺序表基本算法班级:姓名:同组人员:提交日期:一、程序功能:1、建立一个顺序表。

2、对建立好的顺序表进行一些基本的操作,如:a.顺序表的类型定义。

b.求顺序表长操作。

c.取顺序表元素操作。

d.按值查找操作。

e.显示元素操作。

f.插入操作。

g.删除操作。

h.显示元素操作。

二、算法设计思想:用一组存储单元来存放线性表中的数据元素,把顺序表中的所有元素按照其逻辑结构顺序依次储存到从计算机储存器中指定储存位置开始的一块连续的储存空间。

线性表中的第一个位置储存在数组的起始位置(下标为0)在定义一个顺序表时,除了定义一个数组来储存线性表中的所有元素,还需要定义一个整型变量来储存线性表的实际长度。

然后通过对数组元素中的元素进行操作,对顺序表进行基本算法。

三、算法运行结果1、显示整个功能2、设置顺序表的长度:3、求出并返回顺序表的长度:4、在顺序表中取出某个位置的元素并返回其值:5、显示顺序表中的元素:6、在顺序表的某个位置插入元素:7、删除顺序表中的某个元素8、输出顺序表9、将顺序表逆序输出10、退出对顺序表的操作:四、收获及体会通过对顺序表的几个基本运算的调用,实现顺序表的几个基本算法。

同时也懂得如何定义顺序表,还有顺序表的用法。

五、算法源代码#include<stdio.h>#include<stdlib.h>#define MaxSize 50typedef int ElemType ;typedef struct{ElemType data[MaxSize];int length;}SqList; //顺序表类型void InitList(SqList *& L); //初始化顺序表void CreateList(SqList*& L,ElemType a[],ElemType n); //建立顺序表bool ListEmpty(SqList *L); //判断顺序表是否为空表int ListLength(SqList *L); //求顺序表长度void DispList(SqList *L); //输出顺序表bool GetElem(SqList *L,ElemType i,ElemType &e); //求顺序表中某个元素值int LocateElem(SqList *L,ElemType e); //按照元素值查找bool ListInsert(SqList *& L,ElemType i,ElemType e); //插入元素ebool ListDelete(SqList *& L,int i,ElemType &e); //删除元素void DestroyList(SqList *&L); //销毁顺序表void InitList(SqList *& L) //初始化顺序表{L=(SqList*)malloc(sizeof(SqList));L->length=0;}void CreateList(SqList*& L,ElemType a[],ElemType n) //建立顺序表 2 {int i;L=(SqList *)malloc(sizeof(SqList));for(i=0;i<n;i++)L->data[i]=a[i];L->length=n;}bool ListEmpty(SqList *L) //判断顺序表是否为空表{return(L->length==0);}int ListLength(SqList *L) //求顺序表长度{return(L->length);}void DispList(SqList *L) //输出顺序表{int i;for(i=0;i<L->length;i++)printf("%3d",L->data[i]);printf("\n");}bool GetElem(SqList *L,ElemType i,ElemType &e) //求顺序表中某个元素值{if(i<1||i>L->length)return false;e=L->data[i-1];return true;}int LocateElem(SqList *L,ElemType e) //按照元素值查找{int i=0;while(i<L->length&&L->data[i]!=e)i++;if(i>L->length)return 0;elsereturn i+1;}bool ListInsert(SqList *& L,ElemType i,ElemType e) //插入元素e{int j;if(i<1||i>L->length+1)return false;i--;for(j=L->length;j>i;j--)L->data[j]=L->data[j-1];L->data[i]=e;L->length++;return true;}bool ListDelete(SqList *& L,int i,ElemType &e) //删除元素{int j;L = NULL;if(i<1||i>L->length)return false;i--;e=L->data[i];for(j=i;j<L->length-1;j++)L->data[j]=L->data[j+1];L->length--;return true;}void DestroyList(SqList *&L) //销毁顺序表{free(L);L = NULL;}。

顺序表实验报告

顺序表实验报告

顺序表实验报告实验名称:顺序表的实现与操作实验目的: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;}实验结果:经过上述实验操作,成功实现了顺序表的初始化、插入、删除、查找、修改、清空等操作,并能够正确输出结果。

c语言顺序表实验报告

c语言顺序表实验报告

c语言顺序表实验报告C语言顺序表实验报告引言:C语言是一种广泛应用于软件开发领域的编程语言,其灵活性和高效性备受开发者青睐。

在本次实验中,我们将探索C语言中的一种数据结构——顺序表。

顺序表是一种线性表的存储结构,通过数组实现,具有快速访问元素的特点。

本实验将通过实际操作,深入了解顺序表的创建、插入、删除和查找等基本操作,并对其性能进行评估。

实验目的:1. 掌握顺序表的创建和初始化方法;2. 熟悉顺序表的插入、删除和查找等基本操作;3. 评估顺序表在不同操作下的性能。

实验步骤:1. 创建顺序表在C语言中,可以通过定义一个结构体来表示顺序表,其中包含一个数组和一个记录当前元素个数的变量。

通过动态内存分配,可以根据需要调整顺序表的大小。

```ctypedef struct {int* data; // 数组指针int length; // 当前元素个数int capacity; // 顺序表的容量} SeqList;```在主函数中,可以通过调用malloc函数为顺序表分配内存空间,并对其进行初始化。

```cSeqList* createSeqList(int capacity) {SeqList* list = (SeqList*)malloc(sizeof(SeqList));list->data = (int*)malloc(capacity * sizeof(int));list->length = 0;list->capacity = capacity;return list;}```2. 插入元素顺序表的插入操作需要考虑插入位置的合法性以及顺序表是否已满的情况。

在插入元素时,需要将插入位置之后的元素后移一位,为新元素腾出空间。

```cvoid insert(SeqList* list, int position, int element) {if (position < 0 || position > list->length) {printf("插入位置非法!");return;}if (list->length >= list->capacity) {printf("顺序表已满,无法插入!");return;}for (int i = list->length - 1; i >= position; i--) {list->data[i + 1] = list->data[i];}list->data[position] = element;list->length++;}```3. 删除元素顺序表的删除操作需要考虑删除位置的合法性以及顺序表是否为空的情况。

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

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

顺序表的基本操作和实现实验报告顺序表的基本操作和实现实验报告引言顺序表是一种常用的数据结构,它能够在连续的存储空间中存储元素,并通过索引来访问和修改这些元素。

本实验旨在通过实现基本操作,包括插入、删除、获取等,来深入理解顺序表的原理和实现方式。

实验目的1.掌握顺序表的基本操作2.理解顺序表的实现原理3.学习使用编程语言实现顺序表实验过程1.创建顺序表–使用数组作为底层存储结构,设置一个指针指向数组的起始位置,并初始化顺序表的长度为0。

2.插入元素–通过移动元素的方式,在指定位置插入一个新元素。

–更新顺序表的长度。

3.删除元素–通过覆盖元素的方式,删除指定位置的元素。

–更新顺序表的长度。

4.获取元素–根据指定位置,返回对应的元素。

5.更新元素–根据指定位置,修改对应的元素的值。

–不改变顺序表的长度。

6.打印顺序表–遍历顺序表中的元素,并输出到控制台。

实验结果根据以上操作,我们成功实现了一个顺序表,并在各基本操作上进行了测试和验证。

实验结果表明,顺序表能够高效地支持元素的插入、删除、获取和更新等操作,并能够正确地保存和展示数据。

实验总结通过本次实验,我们深入学习了顺序表的基本操作和实现方式。

顺序表作为一种简单而有用的数据结构,在实际应用中有着广泛的应用。

同时,我们也体会到了数据结构与算法的设计和实现的重要性,它们对于程序性能和可读性都有着关键的影响。

参考文献1.《数据结构与算法分析》2.《算法导论》3.《C++ Primer》实验环境•编程语言: C++•开发环境: Visual Studio Code•操作系统: Windows 10实验步骤1.创建顺序表的类SeqList,并定义私有属性int* data和intlength。

2.定义构造函数SeqList(int size),用于初始化顺序表的大小。

3.实现插入元素的方法void insert(int pos, int value),根据指定位置和值,在顺序表中插入新元素。

数据结构实验报告顺序表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、对顺序表进行初始化,创建一个空的顺序表。

实验一顺序表的基本操作实验报告

实验一顺序表的基本操作实验报告

元素之后的所有数据都前移一个位置,最将线性表长减1。

3.顺序表查找操作的基本步骤:要在顺序表中查找一个给定值的数据元素则可以采用顺序查找的方法,从表中第 1 个数据元素开始依次将值与给定值进行比较,若相等则返回该数据元素在顺序表中的位置,否则返回0 值。

线性表的动态分配顺序存储结构—C语言实现#define MaxSize 50//存储空间的分配量Typedef char ElemType;Typedef struct{ElemType data[MaxSize];int length; //表长度(表中有多少个元素)}SqList;动态创建一个空顺序表的算法:void InitList(SqList *&L) //初始化线性表{L=(SqList *)malloc(sizeof(SqList)); //分配存放线性表的空间L->length=0; //置空线性表长度为0}线性表的插入:status Sqlist_insert(Sqlist &L,int i,Elemtype x)/*在顺序表L中第i个元素前插入新元素x*/{ if (i<1||i>L.length+1) return ERROR; /*插入位置不正确则出错*/if (L.length>=MAXLEN)return OVERFLOW;/*顺序表L中已放满元素,再做插入操作则溢出*/for(j=L.length-1;j>=i-1;j--)L.elem[j+1]=L.elem[j]; /*将第i个元素及后续元素位置向后移一位*/L.elem[i-1]=x; /*在第i个元素位置处插入新元素x*/L.length++; /*顺序表L的长度加1*/return OK;}线性表的删除:status Sqlist_delete(Sqlist &L,int i,Elemtype &e)/*在顺序表L中删除第i个元素*{ if (i<1||i>L.length) return ERROR; /*删除位置不正确则出错*/for(j=i;j<=L.length-1;j++)L.elem[j-1]=L.elem[j]; /*将第i+1个元素及后继元素位置向前移一位*/L.length--;/*顺序表L的长度减1*/return OK;}线性表元素的查找:int LocateElem(SqList *L, ElemType e) //按元素值查找{int i=0;while (i<L->length && L->data[i]!=e)i++; //查找元素eif (i>=L->length) //未找到时返回0return 0;elsereturn i+1; //找到后返回其逻辑序号}输出线性表:void DispList(SqList *L) //输出线性表{int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf("%c ",L->data[i]);printf("\n");}输出线性表第i个元素的值:bool GetElem(SqList *L,int i,ElemType &e)//求线性表中某个数据元素值{if (i<1 || i>L->length)return false; //参数错误时返回falsee=L->data[i-1]; //取元素值return true; //成功找到元素时返回true}代码:#include <stdio.h>#include <malloc.h>#define MaxSize 50typedef char ElemType;typedef struct{ElemType data[MaxSize];int length;} SqList;void InitList(SqList *&L);void DestroyList(SqList *L);bool ListEmpty(SqList *L);int ListLength(SqList *L);void DispList(SqList *L);bool GetElem(SqList *L,int i,ElemType &e);int LocateElem(SqList *L, ElemType e);bool ListInsert(SqList *&L,int i,ElemType e);bool ListDelete(SqList *&L,int i,ElemType &e);void InitList(SqList *&L)//初始化线性表{L=(SqList *)malloc(sizeof(SqList));//分配存放线性表的空间L->length=0;//置空线性表长度为0 }void DestroyList(SqList *L)//销毁线性表{free(L);}bool 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->data[i]);printf("\n");}bool GetElem(SqList *L,int i,ElemType &e)//求线性表中某个数据元素值{if (i<1 || i>L->length)return false;//参数错误时返回falsee=L->data[i-1];//取元素值return true;//成功找到元素时返回true}int LocateElem(SqList *L, ElemType e)//按元素值查找{int i=0;while (i<L->length && L->data[i]!=e)i++;//查找元素eif (i>=L->length)//未找到时返回0return 0;elsereturn i+1;//找到后返回其逻辑序号}bool ListInsert(SqList *&L,int i,ElemType e)//插入数据元素{int j;if (i<1 || i>L->length+1)return false;//参数错误时返回falsei--;//将顺序表逻辑序号转化为物理序号for (j=L->length;j>i;j--)//将data[i]及后面元素后移一个位置L->data[j]=L->data[j-1];L->data[i]=e;//插入元素eL->length++;//顺序表长度增1return true;//成功插入返回true}bool ListDelete(SqList *&L,int i,ElemType &e)//删除数据元素{int j;if (i<1 || i>L->length)//参数错误时返回falsereturn false;i--;//将顺序表逻辑序号转化为物理序号e=L->data[i];for (j=i;j<L->length-1;j++)//将data[i]之后的元素前移一个位置L->data[j]=L->data[j+1];L->length--;//顺序表长度减1return true;//成功删除返回true}void main(){SqList *L;ElemType e;printf("顺序表的基本运算如下:\n");printf(" (1)初始化顺序表L\n");InitList(L);printf(" (2)依次采用尾插法插入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(" (3)输出顺序表L:");DispList(L);printf(" (4)顺序表L长度=%d\n",ListLength(L));printf(" (5)顺序表L为%s\n",(ListEmpty(L)?"空":"非空"));GetElem(L,3,e);printf(" (6)顺序表L的第3个元素=%c\n",e);实验结果:心得体会:通过本次实验,实现了数据结构在程序设计上的作用,了解了数据结构语言,加深了对c语言的认识掌并掌握了线性表的顺序存储结构的表示和实现方法,掌握顺序表基本操作的算法实现,同时了解了顺序表的应用。

顺序表的基本操作实验报告

顺序表的基本操作实验报告

顺序表的基本操作实验报告顺序表的基本操作实验报告引言:顺序表是一种常见的数据结构,它以连续的存储空间来存储数据元素,具有随机访问的特点。

在本次实验中,我们将通过实践来学习顺序表的基本操作,包括插入、删除、查找等,以加深对顺序表的理解和运用。

实验目的:1. 掌握顺序表的插入操作;2. 掌握顺序表的删除操作;3. 掌握顺序表的查找操作;4. 熟悉顺序表的基本操作的时间复杂度。

实验材料和方法:1. 实验材料:计算机、编程环境;2. 实验方法:使用编程语言实现顺序表的基本操作,并进行测试。

实验过程:1. 插入操作:在顺序表中插入一个元素,需要将插入位置之后的元素依次后移,并将新元素插入到指定位置。

实现代码如下:```pythondef insert_element(seq_list, index, value):seq_list.append(None) # 在顺序表末尾添加一个空位for i in range(len(seq_list)-1, index, -1):seq_list[i] = seq_list[i-1]seq_list[index] = value```通过测试,我们可以验证插入操作的正确性和时间复杂度。

2. 删除操作:顺序表的删除操作需要将删除位置之后的元素依次前移,并将最后一个元素删除。

实现代码如下:```pythondef delete_element(seq_list, index):for i in range(index, len(seq_list)-1):seq_list[i] = seq_list[i+1]seq_list.pop()```通过测试,我们可以验证删除操作的正确性和时间复杂度。

3. 查找操作:顺序表的查找操作可以通过遍历整个顺序表来实现,也可以利用有序性进行优化。

实现代码如下:```pythondef search_element(seq_list, value):for i in range(len(seq_list)):if seq_list[i] == value:return ireturn -1```通过测试,我们可以验证查找操作的正确性和时间复杂度。

顺序表的操作实验报告

顺序表的操作实验报告

顺序表的操作实验报告一、实验目的。

本实验旨在通过对顺序表的操作进行实验,加深对顺序表的理解,掌握顺序表的基本操作方法,提高编程能力。

二、实验内容。

1. 初始化顺序表。

2. 插入元素。

3. 删除元素。

4. 查找元素。

5. 修改元素。

6. 输出顺序表。

三、实验步骤。

1. 初始化顺序表。

首先,我们需要定义一个顺序表的结构体,包括数据元素和表长两个成员变量。

然后,通过malloc函数为顺序表分配内存空间,并初始化表长为0,表示顺序表为空表。

2. 插入元素。

插入元素是指在顺序表的指定位置插入一个新的元素。

首先,需要判断插入位置是否合法,然后将插入位置后的元素依次向后移动一位,腾出位置给新元素,最后将新元素插入到指定位置。

3. 删除元素。

删除元素是指在顺序表中删除指定位置的元素。

同样需要判断删除位置是否合法,然后将删除位置后的元素依次向前移动一位,覆盖被删除的元素,最后将表长减一。

4. 查找元素。

查找元素是指在顺序表中查找指定数值的元素,并返回其位置。

可以通过顺序遍历顺序表,逐个比较元素的数值,找到匹配的元素后返回其位置。

5. 修改元素。

修改元素是指在顺序表中修改指定位置的元素的数值。

首先需要判断修改位置是否合法,然后直接修改指定位置的元素数值即可。

6. 输出顺序表。

输出顺序表是指将顺序表中的所有元素依次输出。

可以通过循环遍历顺序表,逐个输出元素的数值。

四、实验结果。

经过实验操作,我们成功实现了顺序表的初始化、插入、删除、查找、修改和输出操作。

通过实验,我们加深了对顺序表的理解,掌握了顺序表的基本操作方法。

五、实验总结。

顺序表是一种基本的数据结构,具有较高的操作效率。

通过本次实验,我们进一步理解了顺序表的内部实现原理,掌握了顺序表的基本操作方法,提高了编程能力。

在今后的学习和工作中,我们将进一步应用顺序表的相关知识,提高自己的编程水平。

六、参考资料。

1. 《数据结构与算法分析》。

2. 《C语言程序设计》。

以上为本次顺序表的操作实验报告内容,希望能对大家有所帮助。

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

实验报告要求
一、实验目的
二、实验内容
三、程序流程图
四、实验结果(要求检测所有情况的正确性,写出测试条件及相应的测试结果)
五、完成思考题
实验一顺序表的基本操作(2学时)
一、实验目的
了解顺序表的逻辑特征,掌握顺序表的描述方法、特点及有关的概念,掌握顺序表上的插入和删除等基本操作算法。

二、实验内容
在顺序表List[]中,实现顺序表的基本操作,包括:初始化顺序表,在表中插入元素、删除元素。

基本要求:
(1)顺序表的元素个数可随意设定;
(2)可连续测试任意多个元素的插入、删除,(插
入、删除位置及要插入元素数值均从键盘输入);
(3)任一操作结束后将顺序表中的内容输出;
(4)可由用户选择退出程序。

三、实验要点及说明
顺序表又称为线性表的顺序存储结构,它是用一组地址连续的存储单元依次存放线性表的各个元素。

可按如下格式定义顺序表:
#define MAXLEN 50 /* 定义顺序表最大元素个数50 */
typedef struct{
datatype List[MAXLEN];/* 定义顺序表List */
int Num; /* 定义顺序表表长*/
}Seqlist;
模块划分:(1)initiq( )函数:初始化顺序表
(2)insertq( )函数:实现插入功能
(3)deleteq( )函数:实现删除功能
(4)print( )函数:实现输出功能
四、参考源程序
#include <>
#define MAXLEN 50
typedef int datatype;
typedef struct{
datatype List[MAXLEN];
int Num;
}Seqlist;
void initiq(Seqlist *la );
int insertq(Seqlist *la,int n);
int deleteq(Seqlist *la,int n);
int print(Seqlist *la);
void main()
{ Seqlist la;
int s,n; /* s 选择输入,n 插入或删除数据的个数*/
printf("请输入你的选择: 1---initiate 2---insert 3---delete 4---print 5---exit\nyour choice =");
scanf("%d",&s);
while(s!=5)
{ if(s==1)
{ initiq( &la );
printf("完成初始化!\n"); }
else if(s==2)
{ printf("请输入待插入的数据个数:");
scanf("%d",&n);
insertq(&la,n);
print(&la); }
else if(s==3)
{ printf("请输入待删除的数据个数:");
scanf("%d",&n);
deleteq(&la,n);
print(&la); }
else if(s==4)
{ print(&la); }
else
printf("你的选择是错误的!\n ");
printf("请输入你的选择: 1---initiate 2---insert 3---delete 4---print 5---exit\nyour choice =");
scanf("%d",&s); } }
/*初始化*/
void initiq(Seqlist *la )
{ la-> Num=0; }
/*插入*/
int insertq(Seqlist *la,int n)
{ int i,j; /* i 插入位置,j 顺序表下标*/
datatype x; /* x 插入数据*/
while(n)
{ if (la->Num>=MAXLEN-1)
{ printf ("\n 表满,不能插入!插入未完成,还有%d个数据未插入\n",n);
return 0; }
printf("请输入插入的位置和数据:");
scanf("%d%d",&i,&x);
if (i<0||i>la->Num)
{ printf ("\n 插入位置不合理!\n"); }
else
{ if (i== la->Num)
la->List[i]=x;
else
{ for ( j=la->Num; j>i; j--)
la->List[j]=la->List[j-1];
la->List[i]=x; }
la->Num++;
n--; } }
printf("插入完成\n");
return 1; }
/*删除*/
int deleteq(Seqlist *la,int n)
{ int i,j; /* i 删除位置,j 顺序表下标*/
while(n)
{ if (la->Num<=0)
{ printf ("\n 表空,不能删除!\n");
return 0; }
printf("请输入删除的位置:");
scanf("%d",&i);
if (i<0||i>=la->Num)
{ printf ("\n 删除位置错误!\n"); }
else
{ for ( j=i+1; j<la->Num; j++)
la->List[j-1]=la->List[j];
la->Num--;
n--; } }
printf("删除完成!\n");
return 1; }
/*显示输出*/
int print (Seqlist *la)
{ int m;
if (la->Num<=0)
{ printf("顺序表为空!\n");
return 0; }
else
{ printf("当前的顺序表为:\n");
for(m=0;m<la->Num;m++)
printf("List[%d]=%d ",m,la->List[m]);
printf("\n表长为%d\n",la->Num);
return 1; } }
五、思考题
1.设顺序表L中的数据元素按递增排列,编写一个算法,将数据元素x插入到顺序表L的适当位置上,以保持顺序表的有序性。

2.设计一算法实现删除顺序表a中第i个元素起的k个元素。

typedef struct
{ int datatype[100];
int length; /*顺序表的长度*/
}SqList;
3.设已有线性表la 的数据结构定义同上,编写一个算法,删除顺序表la中所有值为x的数据元素。

4.如何用程序实现将两个不同的顺序表复制到一个顺序表中。

相关文档
最新文档