顺序表的查找、插入与删除实验报告
顺序表的基本操作实验报告

顺序表的基本操作实验报告一、实验目的本次实验旨在深入理解和掌握顺序表的基本操作,包括顺序表的创建、插入、删除、查找和遍历等功能,并通过实际编程实现,加深对数据结构中顺序存储结构的理解和应用能力。
二、实验环境本次实验使用的编程语言为 C 语言,编程环境为 Visual Studio 2019。
三、实验原理顺序表是一种线性表的顺序存储结构,它使用一组连续的存储单元依次存储线性表中的元素。
在顺序表中,元素的逻辑顺序与物理顺序是一致的。
顺序表的基本操作包括:1、创建顺序表:为顺序表分配存储空间,并初始化相关参数。
2、插入操作:在指定位置插入元素,需要移动后续元素以腾出空间。
3、删除操作:删除指定位置的元素,并将后续元素向前移动。
4、查找操作:在顺序表中查找指定元素,返回其位置或表示未找到。
5、遍历操作:依次访问顺序表中的每个元素。
四、实验步骤1、定义顺序表的数据结构```cdefine MAXSIZE 100 //定义顺序表的最大长度typedef struct {int dataMAXSIZE; //存储顺序表元素的数组int length; //顺序表的当前长度} SeqList;```2、顺序表的创建```cvoid InitList(SeqList L) {L>length = 0; //初始化顺序表长度为 0}```3、顺序表的插入操作```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++;//顺序表长度增加 1return 1;}```4、顺序表的删除操作```cint DeleteList(SeqList L, int i) {if (i < 1 || i > L>length) {//删除位置不合法return 0;}for (int j = i; j < L>length; j++){//移动元素填补删除位置L>dataj 1 = L>dataj;}L>length; //顺序表长度减少 1return 1;}```5、顺序表的查找操作```cint SearchList(SeqList L, int e) {for (int i = 0; i < Llength; i++){if (Ldatai == e) {//找到元素return i + 1;}}return 0; //未找到元素}```6、顺序表的遍历操作```cvoid TraverseList(SeqList L) {for (int i = 0; i < Llength; i++){printf("%d ", Ldatai);//输出顺序表中的元素}printf("\n");}```五、实验结果与分析1、测试创建顺序表```cSeqList L;InitList(&L);```创建成功,顺序表初始长度为 0。
数据结构实验一_顺序表的基本操作实验报告

实验一顺序表的基本操作一、实验目的掌握线性表的顺序表基本操作:建立、插入、删除、查找、合并、打印等运算。
二、实验要求包含有头文件和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);}。
线性顺序表的插入与删除(实验报告)

一、实验目的和要求通过对顺序表的编程练习,加强对顺序表的特点、顺序存储结构及其基本运算的理解和掌握。
提前了解实验相关的c语言的知识。
使用C语言根据相应算法编写一个程序,实现建立线性顺序表、插入和删除等基本操作。
要求仔细阅读下面的内容,编写一个C程序,上机调试通过,并观察其结果,写出实验报告书。
二、实验内容和原理内容:建立一个容量10的顺序表,在其中插入3个元素,然后作删除运算。
原理:在第i个元素前插入元素,从第i个元素开始到最后一个元素均向后移动一个位置,然后将新元素插入到第i个位置,将线性表的长度加1。
删除第i个元素,从第i+1个元素开始到最后一个元素均向前移动一个位置,然后将线性表的长度减1。
三、主要仪器设备计算机一台四、实验主程序#include<stdio.h>#include<stdlib.h>struct List{int size;int n;int *head;};void init(struct List *pl,int size){pl->size=size;pl->n=0;pl->head=malloc(size*sizeof(int)); }void in(int i,int val,struct List *pl){int k;if(pl->n==pl->size){printf("list is full.\n");return;}if(i>pl->n)i=pl->n+1;if(i<1)i=1;for(k=pl->n-1;k>=i-1;--k)pl->head[k+1]=pl->head[k];pl->head[i-1]=val;++pl->n;}void out(int i,struct List *pl){int k;if(pl->n==0){printf("list is empty.\n");return;}if(i<1||i>pl->n){printf("this element is not in the list.\n");return;}for(k=i;k<=pl->n;++k)pl->head[k-1]=pl->head[k];--pl->n;return;}void print(const struct List *pl) {int i;for(i=0;i!=pl->n;++i)printf("%d ",pl->head[i]);printf("\n");}int main(void){int i;struct List list;init(&list,10);for(i=0;i!=5;++i)in(i+1,i,&list);print(&list);in(1,5,&list);print(&list);in(10,4,&list);print(&list);in(5,50,&list);print(&list);out(1,&list);print(&list);out(list.n,&list);print(&list);out(3,&list);print(&list);getchar();return 0;}实验结果五、实验心得通过实验学习,我理解了线性顺序表的插入与删除的算法,了解到线性顺序表的插入与删除得效率低下,感到受益匪浅。
顺序表实验报告

顺序表实验报告顺序表是一种线性数据结构,它以连续的存储空间来存储数据元素,通过元素在数组中的相对位置来表示数据元素之间的逻辑关系。
在这个实验中,我们使用顺序表的实现来进行实验。
首先我们先了解一下顺序表的结构。
顺序表由两部分组成:表头和表体。
表头包含顺序表的一些基本信息,如顺序表的长度和当前表体的容量;表体是一个一维数组,用来存储数据元素。
在这个实验中,我们主要实现顺序表的插入操作和删除操作。
插入操作是指将一个新的数据元素插入到顺序表的某个位置;删除操作是指在顺序表中删除某个位置的数据元素。
实验步骤如下:1. 首先,我们需要定义一个顺序表的数据结构,包含表头和表体。
表头中需要有顺序表的长度和当前表体的容量,表体是一个一维数组。
2. 接下来,我们实现插入操作。
插入操作需要输入要插入的数据元素和插入的位置。
我们首先需要判断插入的位置是否合法,即位置在顺序表的范围内。
如果位置不合法,就返回插入失败。
如果位置合法,我们需要判断当前表体的容量是否已满。
如果已满,我们需要重新分配更大的内存空间来存储数据。
然后我们将插入位置后面的数据元素依次往后移动一位,给新的数据元素腾出位置。
最后,我们将要插入的数据元素放入指定位置处,并更新顺序表的长度。
3. 然后,我们实现删除操作。
删除操作需要输入要删除的位置。
首先我们需要判断删除的位置是否合法。
如果位置不合法,就返回删除失败。
如果位置合法,我们需要将删除位置后面的数据元素依次往前移动一位。
最后,我们更新顺序表的长度即可。
4. 最后,我们编写测试用例来检验我们实现的代码是否正确。
我们可以对插入和删除进行多次操作,然后查看顺序表的状态是否符合预期。
通过这个实验,我们可以更加深入地理解顺序表的原理和实现细节。
顺序表的插入和删除操作是非常常见的操作,掌握了这些操作,我们就能更加灵活地应用顺序表来解决实际问题。
同时,这个实验也锻炼了我们的编程能力和调试能力,提高了我们的代码质量和效率。
顺序表基本算法实验报告

顺序表基本算法实验报告顺序表基本算法实验报告一、实验目的本次实验旨在深入了解顺序表的基本操作和算法,包括顺序表的创建、插入、删除、遍历等操作,通过实际操作加深对顺序表的理解和应用能力。
二、实验内容和步骤1.顺序表的创建我们首先需要创建一个顺序表。
顺序表在内存中以数组的形式存在。
我们定义一个数组,并使用数组的索引来访问和操作其中的元素。
def create_sequential_list(size):sequential_list = []for i in range(size):sequential_list.append(0)return sequential_list2.插入操作顺序表的插入操作包括在指定位置插入一个元素。
这个操作需要注意插入位置及其前后的元素的处理。
def insert_sequential_list(sequential_list, index, value):sequential_list.insert(index, value)3.删除操作删除操作则是从顺序表中移除一个指定位置的元素。
这个操作需要注意被删除元素的前后元素的处理。
def delete_sequential_list(sequential_list, index):sequential_list.pop(index)4.遍历操作遍历操作则是访问顺序表中的每一个元素。
我们可以使用for循环来遍历顺序表中的所有元素。
def traverse_sequential_list(sequential_list):for element in sequential_list:print(element)三、实验结果和分析通过以上实验,我们成功实现了顺序表的创建、插入、删除和遍历操作。
插入和删除操作的时间复杂度为O(n),其中n为顺序表的大小。
遍历操作的时间复杂度为O(n)。
顺序表是一种简单高效的数据结构,适用于元素数量固定且频繁进行插入、删除和遍历操作的场景。
顺序表的基本操作--实验报告

实验报告附:源程序:#include<stdio.h>#define Maxsize 100#define error 0#define ok 1typedef struct{int elem[Maxsize];int last;}SeqList;int InsList(SeqList *L,int a,int i); int Locate(SeqList L,int e);int Del(SeqList *L,int i);void main(){int i,e,a;int list1,list2;SeqList L;st=0;for(i=0;i<100;i++){printf("请输入顺序表元素\n");scanf("%d",&L.elem[i]);if(L.elem[i]==-1)break;st++;}if(L.elem[st]==-1)st--;printf("要插入的元素,位置为\n"); scanf("%d,%d",&a,&i);list1=InsList(&L,a,i);if(list1){printf("插入后的顺序表为:\n");for(i=0;i<=st;i++)printf("%d",L.elem[i]);printf("\n");}elseprintf("插入失败!");printf("要查找的元素为\n");scanf("%d",&e);list2=Locate(L,e);if(!list2)printf("该元素不存在\n");elseprintf("该元素所在位置的序号为:%d\n",list2);/*删除元素*/printf("是否要删除该元素?<是请输入1 ,否请输入0 >\n");int m;scanf("%d",&m);if(m){Del(&L,list2);printf("删除后的顺序表为:\n");for(i=0;i<=st;i++)printf("%d",L.elem[i]);printf("\n");}else printf("未删除元素%d\n",e);}int InsList(SeqList *L,int a,int i)//i位置,下标i-1{int p;if(L->last>=Maxsize-1){printf("表已满,无法插入");return(error);}for(p=L->last;p>=i-1;p--)L->elem[p+1]=L->elem[p];L->elem[i-1]=a;L->last++;return(ok);}int Locate(SeqList L,int e){int i=0;while((i<=st)&&(L.elem[i]!=e)) i++;if (i<=st)return(i+1);else return(error);}int Del(SeqList *L,int i){int k;for(k=i;k<=L->last;k++)L->elem[k-1]=L->elem[k];L->last--;return ok;}。
顺序表的操作实验报告

顺序表的操作实验报告顺序表的操作实验报告一、引言顺序表是一种常见的数据结构,它在计算机科学中被广泛应用。
本实验旨在通过实际操作顺序表,探索其基本操作和性能。
二、实验目的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. 简介顺序表是一种常用的数据结构,它在计算机科学中有着重要的应用。
本实验旨在通过实践操作顺序表,深入理解其原理和实现方式。
2. 实验目的本次实验有以下几个目的:- 学习使用顺序表来存储和操作数据;- 掌握顺序表的插入、删除、查找等基本操作;- 理解顺序表的实现原理,并分析其优缺点。
3. 实验环境和工具本实验所用环境为Windows系统,编程语言为C++。
编程工具可以选择Visual Studio或者其他C++开发工具。
4. 实验步骤4.1 实验准备首先,我们需要定义顺序表的数据结构。
例如,我们可以定义一个结构体,其中包含一个数组和一个指示当前表中元素个数的变量。
4.2 插入操作接下来,我们可以编写插入操作的函数。
插入操作的目的是将一个元素插入到指定位置,并保持表中其他元素的顺序。
可以使用循环将需要移动的元素逐个后移,然后将新元素插入到指定位置。
4.3 删除操作与插入操作类似,删除操作也需要保持表中其他元素的顺序。
可以使用循环将需要删除的元素之后的元素逐个前移,然后将最后一个元素的位置置为空。
4.4 查找操作查找操作可以通过循环遍历表中的元素,并与目标元素进行比较,直到找到相等的元素或者遍历到表尾。
5. 实验结果与分析经过实验,我们可以发现使用顺序表存储数据的效率较高。
顺序表的插入和删除操作时间复杂度为O(n),其中n为表中元素个数。
这是因为插入或删除一个元素后,需要移动其他元素以保持顺序。
而查找操作的时间复杂度为O(n),在最坏的情况下需要遍历整个表才能找到目标元素。
此外,顺序表还具有便于随机访问的优点。
由于顺序表中元素在内存中连续存储,可以直接通过索引访问表中的任意元素,因此查找效率较高。
然而,顺序表也有一些缺点。
首先,插入和删除操作需要移动大量元素,当表中元素个数较大时,操作的时间复杂度会较高。
其次,由于顺序表必须预先分配一定大小的连续空间,因此当表中元素个数超过初始大小时,需要进行动态扩容操作。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
《数据结构》实验报告一
学院:班级:
学号:姓名:
日期:程序名
一、上机实验的问题和要求:
顺序表的查找、插入与删除。
设计算法,实现线性结构上的顺序表的产生以及元素的查找、插入与删除。
具体实现要求:
1.从键盘输入10个整数,产生顺序表,并输入结点值。
2.从键盘输入1个整数,在顺序表中查找该结点的位置。
若找到,输出结点的位置;若找
不到,则显示“找不到”。
3.从键盘输入2个整数,一个表示欲插入的位置i,另一个表示欲插入的数值x,将x插
入在对应位置上,输出顺序表所有结点值,观察输出结果。
4.从键盘输入1个整数,表示欲删除结点的位置,输出顺序表所有结点值,观察输出结果。
二、源程序及注释:
#include <stdio.h>
#include <stdlib.h>
/*顺序表的定义:*/
#include<iostream.h>
#define ListSize 100 /*表空间大小可根据实际需要而定,这里假设为100*/
typedef int DataType; /*DataType可以是任何相应的数据类型如int, float或char*/ typedef struct
{ DataType data[ListSize]; /*向量data用于存放表结点*/
int length; /*当前的表长度*/
}SeqList;
void main()
{
SeqList L;
int i,x;
int n=10; /*欲建立的顺序表长度*/
L.length=0;
void CreateList(SeqList *L,int n);
void PrintList(SeqList L,int n);
int LocateList(SeqList L,DataType x);
void InsertList(SeqList *L,DataType x,int i);
void DeleteList(SeqList *L,int i);
CreateList(&L,n); /*建立顺序表*/
PrintList(L,n); /*打印顺序表*/
printf("输入要查找的值:");
scanf("%d",&x);
i=LocateList(L,x); /*顺序表查找*/
printf("输入要插入的位置:");
scanf("%d",&i);
printf("输入要插入的元素:");
scanf("%d",&x);
InsertList(&L,x,i); /*顺序表插入*/
PrintList(L,n); /*打印顺序表*/
printf("输入要删除的位置:");
scanf("%d",&i);
DeleteList(&L,i); /*顺序表删除*/
PrintList(L,n); /*打印顺序表*/ }
/*顺序表的建立:*/
void CreateList(SeqList *L,int n)
{
int i;
for(i=0;i<n;i++)
scanf ("%d",&L->data[i]);
L->length=n;
}
/*顺序表的打印:*/
void PrintList(SeqList L,int n)
{
int i;
for(i=0;i<L.length;i++)
cout<<L.data[i]<<endl;
}
/*顺序表的查找:*/
int LocateList(SeqList L,DataType x)
{
int i=0;
while (i<L.length && L.data [i]!=x)
++i;
if (i<L.length)
return i+ 1;
else return 0;
}
/*顺序表的插入:*/
void InsertList(SeqList *L,DataType x,int i) {
int j;
if(i<1 || i>L->length +1)
{
printf("插入位置非法\n");
exit(0);
}
if(L->length >=ListSize)
{
printf("表空间溢出,退出运行\n");
exit(0);
}
for(j =L->length-1; j>=i-1;j--)
L->data[j+1]=L->data[j];
L->data[i-1]=x;
L->length++;
}
/*顺序表的删除:*/
void DeleteList(SeqList *L,int i)
{
int j;
if (L->length ==0)
{
printf("现行表为空,退出运行\n");
exit(0);
}
if (i<1 || i>L->length)
{
printf("删除位置非法\n");
exit(0);
}
for(j=i;j<=L->length -1;j++)
L->data[j-1]=L->data[j];
L->length --;
}
三、运行输出结果:
四、调试和运行程序过程中产生的问题及采取的措施:。