实验一 顺序表的基本算法
顺序表基本算法实验报告
顺序表基本算法实验报告顺序表基本算法实验报告一、实验目的本次实验旨在深入了解顺序表的基本操作和算法,包括顺序表的创建、插入、删除、遍历等操作,通过实际操作加深对顺序表的理解和应用能力。
二、实验内容和步骤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)。
顺序表是一种简单高效的数据结构,适用于元素数量固定且频繁进行插入、删除和遍历操作的场景。
实现顺序表的各种基本运算的算法
实现顺序表的各种基本运算的算法1. 初始化顺序表算法实现:初始化操作就是将顺序表中所有元素的值设置为默认值,对于数值类型,可以将其设置为0,对于字符类型,可以将其设置为空格字符。
初始化的时间复杂度为O(n),其中n为顺序表的长度。
2. 插入操作算法实现:顺序表的插入操作就是在指定位置上插入一个元素,需要将该位置后面的元素全部后移,在指定位置上插入新元素。
若顺序表已满,则需要进行扩容操作,将顺序表长度扩大一倍或者按一定的比例扩大。
插入操作的时间复杂度为O(n),其中n为顺序表长度。
3. 删除操作算法实现:顺序表的删除操作需要将指定位置上的元素删除,并将该位置后面的元素全部前移。
删除操作后,如果顺序表的实际长度小于等于其总长度的1/4,则需要进行缩容操作,将顺序表长度缩小一倍或者按一定的比例缩小。
删除操作的时间复杂度为O(n),其中n为顺序表长度。
4. 修改操作算法实现:顺序表的修改操作就是将指定位置上的元素赋予新的值。
修改操作的时间复杂度为O(1)。
5. 查找操作算法实现:顺序表的查找操作就是在顺序表中找到指定位置的元素,并返回其值。
查找操作的时间复杂度为O(1)。
6. 遍历操作算法实现:顺序表的遍历操作就是依次访问顺序表中的每个元素,遍历操作的时间复杂度为O(n),其中n为顺序表的长度。
7. 合并操作算法实现:顺序表的合并操作就是将两个顺序表合并成一个新的顺序表,新的顺序表的长度为两个顺序表的长度之和。
合并操作的时间复杂度为O(n),其中n为两个顺序表的长度之和。
总结:顺序表是一种简单而高效的数据结构,其基本运算包括初始化、插入、删除、修改、查找、遍历和合并等操作。
其中,插入、删除、遍历和合并操作的时间复杂度比较高,需要进行相应的优化处理。
同时,在实际应用中,还需要注意顺序表的扩容和缩容操作,避免造成资源浪费或者性能下降。
数据结构实验一顺序表
数据结构实验一1、实验目的∙掌握线性表的逻辑特征∙掌握线性表顺序存储结构的特点,熟练掌握顺序表的基本运算2、实验内容:建立顺序表,完成顺序表的基本操作:初始化、插入、删除、逆转、输出、销毁, 置空表、求表长、查找元素、判线性表是否为空;1.问题描述:利用顺序表,设计一组输入数据(假定为一组整数),能够对顺序表进行如下操作:∙创建一个新的顺序表,实现动态空间分配的初始化;∙根据顺序表结点的位置插入一个新结点(位置插入),也可以根据给定的值进行插入(值插入),形成有序顺序表;∙根据顺序表结点的位置删除一个结点(位置删除),也可以根据给定的值删除对应的第一个结点,或者删除指定值的所有结点(值删除);∙利用最少的空间实现顺序表元素的逆转;∙实现顺序表的各个元素的输出;∙彻底销毁顺序线性表,回收所分配的空间;∙对顺序线性表的所有元素删除,置为空表;∙返回其数据元素个数;∙按序号查找,根据顺序表的特点,可以随机存取,直接可以定位于第i 个结点,查找该元素的值,对查找结果进行返回;∙按值查找,根据给定数据元素的值,只能顺序比较,查找该元素的位置,对查找结果进行返回;∙判断顺序表中是否有元素存在,对判断结果进行返回;.编写主程序,实现对各不同的算法调用。
2.实现要求:∙“初始化算法”的操作结果:构造一个空的顺序线性表。
对顺序表的空间进行动态管理,实现动态分配、回收和增加存储空间;∙“位置插入算法”的初始条件:顺序线性表L 已存在,给定的元素位置为i,且1≤i≤ListLength(L)+1 ;操作结果:在L 中第i 个位置之前插入新的数据元素e,L 的长度加1;∙“位置删除算法”的初始条件:顺序线性表L 已存在,1≤i≤ListLength(L) ;操作结果:删除L 的第i 个数据元素,并用e 返回其值,L 的长度减1 ;∙“逆转算法”的初始条件:顺序线性表L 已存在;操作结果:依次对L 的每个数据元素进行交换,为了使用最少的额外空间,对顺序表的元素进行交换;∙“输出算法”的初始条件:顺序线性表L 已存在;操作结果:依次对L 的每个数据元素进行输出;∙“销毁算法”初始条件:顺序线性表L 已存在;操作结果:销毁顺序线性表L;∙“置空表算法”初始条件:顺序线性表L 已存在;操作结果:将L 重置为空表;∙“求表长算法”初始条件:顺序线性表L 已存在;操作结果:返回L 中数据元素个数;∙“按序号查找算法”初始条件:顺序线性表L 已存在,元素位置为i,且1≤i≤ListLength(L)操作结果:返回L 中第i 个数据元素的值∙“按值查找算法”初始条件:顺序线性表L 已存在,元素值为e;操作结果:返回L 中数据元素值为e 的元素位置;∙“判表空算法”初始条件:顺序线性表L 已存在;操作结果:若L 为空表,则返回TRUE,否则返回FALSE;分析: 修改输入数据,预期输出并验证输出的结果,加深对有关算法的理解。
顺序表的基本运算
顺序表的基本运算
顺序表是一种常见的数据结构,它可以存储一组具有相同数据类型的元素,并支持一系列的基本操作。
顺序表的基本运算包括插入、删除、查找和遍历等操作。
1. 插入操作:顺序表的插入操作通常有两种方式,一种是在表尾插入元素,另一种是在表中的任意位置插入元素。
对于表尾插入元素,需要先判断表是否已满,如果未满,则将元素插入表尾。
对于在表中任意位置插入元素,需要先将插入位置及其之后的元素后移,然后再将要插入的元素放入合适的位置。
2. 删除操作:顺序表的删除操作也有两种方式,一种是删除表尾元素,另一种是删除表中的任意元素。
对于删除表尾元素,直接将表尾元素删除即可。
对于删除表中任意元素,需要先找到要删除的元素的位置,然后将该位置之后的元素前移,最后将表中的元素个数减1。
3. 查找操作:顺序表的查找操作可以根据元素的值或者位置进行。
如果是根据元素的值进行查找,则需要遍历整个表,逐一比较元素的值。
如果是根据位置进行查找,则直接返回该位置的元素值即可。
4. 遍历操作:顺序表的遍历操作可以遍历整个表,也可以只遍历部分元素。
遍历整个表可以使用循环结构,依次输出每个元素的值。
遍历部分元素则可以通过设置起始位置和结束位置来实现。
- 1 -。
顺序表的建立与基本算法
顺序表的建立与基本算法
顺序表是数据结构中最基本、最常见的存储结构。
它是一组在一起的有组织地存储在内存中的相关数据项,以便快速访问和修改。
顺序表的建立与基本算法主要包括以下几点:
一、建立顺序表
1.定义存储空间大小:首先要确定存储空间大小,根据实际情况来确定。
2.申请内存空间:将需要的内存空间分配给顺序表,用于存放后面的数据元素。
3.初始化顺序表:将顺序表的长度初始化为0,表示此时顺序表是空表,然后给顺序表的数据元素赋初值,例如-1、0、NULL等。
4.插入数据元素:在指定位置插入数据元素到顺序表上。
5.释放内存空间:当顺序表使用完毕,需要释放顺序表所申请的内存空间,回收内存。
二、顺序表的基本算法
1.查找算法:在顺序表中查找特定的数据元素,通过遍历顺序表的方式来查找,可以通过比较元素的特征值来区分,查找的时间复杂度为O(n)。
2.插入算法:在顺序表中插入数据元素,需要先判断顺序表是否已满,如果未满则在指定位置插入数据元素,需要将插入位置后面的元素都后移一个位置,插入的时间复杂度为O(n)。
3.删除算法:在顺序表中删除数据元素,需要先判断顺序表是否为空,如果非空则在指定位置删除数据元素,需要将删除位置后面的元素都前移一个位置,删除的时间复杂度为O(n)。
4.更新算法:更新顺序表中的数据元素,需要先查找到特定的元素,然后根据需要更新数据元素,更新的时间复杂度也是O(n)。
总的来说,顺序表的建立与基本算法包括建立顺序表,查找算法,插入算法,删除算法,更新算法等几个方面,都要结合实际情况具体
操作,时间复杂度都是O(n)。
数据结构与算法实验一顺序表
数据结构与算法实验一顺序表
本实验主要是针对顺序表的操作进行实践。
顺序表是一种线性表,其元素是按照一定顺序排列的。
顺序表的实现基于数组,因此支持随机访问,但插入和删除元素时需要移动大量元素,效率较低。
本实验主要包含以下内容:
1. 创建顺序表:通过动态分配内存,创建一个指定大小的顺序表。
2. 插入元素:在指定位置插入一个元素,需要注意顺序表已满
的情况。
3. 删除元素:删除指定位置的元素,需要注意顺序表为空的情况。
4. 查找元素:按照指定方式查找符合条件的元素,例如查找最
大值、最小值、指定值等。
5. 排序:按照指定方式对顺序表进行排序,例如冒泡排序、选
择排序、插入排序等。
通过本实验的实践,可以加深对顺序表的理解,并掌握常用的操作方式。
同时,实践过程中还需要注意代码的规范性和注释的清晰性,提高编程能力。
- 1 -。
顺序表基本算法实验报告
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.掌握线性表的基本操作:初始化、建立、显示、判断空、判断满、插入、删除等运算在顺序存储结构上的实现。
二、实验内容1.用结构体定义线性表2.实现初始化、建立、显示、判断空、判断满、求表长、查找、插入、删除等基本操作三、实验要求1.认真阅读和理解本实验的程序。
2.上机输入、调试、运行下列程序。
/*#include<stdio.h>#include<conio.h> */#define MAXSIZE 100#define FALSE 0#define TRUE 1/* 定义ElemType为int类型*/typedef int ElemType;/*顺序表存储空间的总分配量*//* 顺序存储类型*/typedef struct{ElemType data[MAXSIZE]; /*存放线性表的数组*/int length; /* length是顺序表的长度*/}SqList;SqList L;/* 初始化顺序表*/SqList SqListInit( ){SqList L;L.length=0;return L;}/* 追加顺序表*/SqList ListCreate(SqList L){ int i,n;printf("请输入数字个数");scanf("%d",&n);for(i=0;i<n;i++){scanf("%d",&L.data[i]); L.length++;} return L;}/* 求顺序表长度*/int ListLength(SqList L){return(L.length);}/* 检查顺序表是否为空*/int ListEmpty(SqList L){if(L.length) return(FALSE);else return(TRUE);}/*检查顺序表是否为满*/int ListFull(SqList L){if(L.length==MAXSIZE) return(TRUE);else return(FALSE);}/* 显示遍历顺序表*/void ListTraverse(SqList L){int i;if(L.length<=0) printf("顺序表为空\n");else {printf("当前顺序表中的元素为:\n");for(i=0;i<L.length;i++) printf("%d ",L.data[i]); printf("\n");}}/* 从顺序表中查找元素*/ElemType ListGet(SqList L ,int i){ElemType e;e=L.data[i-1]; return(e);}/* 从顺序表中查找与给定元素值相同的元素在顺序表中的位置*/ int ListLocate(SqList L, ElemType x){int i=0;while(i<L.length && L.data[i]!=x)i++;if (i<L.length) return (i+1);else return 0;}/* 向顺序表中插入元素*/SqList ListInsert(SqList L,int i,ElemType x){int j;if(L.length==MAXSIZE)printf("表满,不能插入\n");else if(i<1||i>L.length+1)printf("插入位置不正确\n");else { for(j=L.length-1;j>=i-1;j--)L.data[j+1]=L.data[j];L.data[i-1]=x;L.length++;}return L;}/* 从顺序表中删除元素*/SqList ListDelete(SqList L,int i){int j;ElemType x;if (i<1||i>L.length)printf("删除位置不正确\n");else {x=L.data[i-1];for(j=i;j<=L.length-1;j++)L.data[j-1]=L.data[j];L.length--;printf("%d已被删除\n",x);}return L;}/*顺序表逆序排列 */SqList nixu(SqList L){ int j,t;for(j=0;j<L.length/2;j++){t=L.data[j];L.data[j]=L.data[L.length-1-j]; L.data[L.length-1-j]=t;}return L;}int scan(){int d;printf("1. 顺序表的初始化 2.连续追加元素建表 3.求顺序表长度\n");printf("4. 检查顺序表是否为空 5.检查顺序表是否为满 6.显示顺序表\n");printf("7. 从顺序表中查找元素 8.给定元素值找位置 9.向顺序表中插入元素\n"); printf("10.从顺序表中删除元素 11.逆序其他键退出......\n"); printf("\n");printf("\n\n请选择所要进行的操作\n");scanf("%d",&d);return(d);}main(){int quit=0;int i,location;ElemType e,prior,next;printf("第一次操作需选择初始化\n\n\n");while(!quit){switch(scan()){case 1:L=SqListInit(); printf("\n\n线性表已经初始化!\n\n\n");break;case 2:L=ListCreate(L);break;case 3:printf("顺序表的长度为%d\n",L.length);break;case 4:if(ListEmpty(L))printf("顺序表为空\n");else printf("顺序表不为空\n");break;case 5:if(ListFull(L))printf("顺序表满\n");else printf("顺序表不满\n");break;case 6:ListTraverse(L);break;case 7:printf("请输入要查找的元素的位置\n");scanf("%d",&i);if(L.length==0) printf("顺序表已空\n");else if(i<=0||i>L.length) printf("查找的位置不正确\n");else printf("顺序表中第%d个元素的值为:%d\n",i,ListGet(L,i));break;case 8:printf("请输入要查找的元素的值\n");scanf("%d",&e);if(L.length==0) printf("顺序表已空\n");else{location=ListLocate(L,e);if(location==0) printf("顺序表中不存在值为%d的元素\n",e);else printf("顺序表中%d的位置是:%d\n",e,ListLocate(L,e));}break;case 9:printf("请输入要插入的元素的位置和其值:\n");scanf("%d%d",&i,&e);L=ListInsert(L,i,e);break;case 10:printf("请输入要删除的元素的位置:\n");scanf("%d",&i);L=ListDelete(L,i);break;case 11:L=nixu(L) ; break;default:quit=1;}/*getchar();getchar();clrscr(); */}}四、写出该程序的功能和运行结果。
顺序表的算法
顺序表的算法
顺序表是一种线性数据结构,它的存储结构是一段连续的内存空间。
在顺序表中,数据元素的物理地址是连续的,因此可以通过下标直接随机访问元素。
顺序表的算法包括插入、删除、查找、排序等。
1. 插入算法:
在顺序表中插入元素可以分为两种情况:
(1)在表尾插入元素:这种情况比较简单,只需要将新元素赋值给表尾即可。
(2)在表中插入元素:这种情况需要将插入位置后面的元素都向后移动一个位置,然后将新元素插入到指定位置。
2. 删除算法:
在顺序表中删除元素也可以分为两种情况:
(1)删除表尾元素:这种情况比较简单,只需要将表尾元素删除即可。
(2)删除表中元素:这种情况需要将删除位置后面的元素都向前移动一个位置,然后将删除位置处的元素删除。
3. 查找算法:
在顺序表中查找元素可以使用顺序查找和二分查找两种方法。
(1)顺序查找:从表头开始依次遍历每个元素,直到找到目标元素或者遍历完整个表。
(2)二分查找:要求表中的元素已经按照一定规则排好序,通过将表分为两半的方式不断缩小查找范围,最终找到目标元素或者确
定目标元素不存在于表中。
4. 排序算法:
在顺序表中排序可以使用冒泡排序、选择排序、插入排序和快速排序等算法。
这些算法可以根据不同的时间复杂度、空间复杂度和排序效率进行选择。
顺序表是一种简单、易于实现的数据结构,可以应用于各种场景中。
在实际应用中,需要根据具体情况选择合适的算法,以提高程序的效率和性能。
顺序表的基本操作和实现实验报告
顺序表的基本操作和实现实验报告顺序表的基本操作和实现实验报告引言顺序表是一种常用的数据结构,它能够在连续的存储空间中存储元素,并通过索引来访问和修改这些元素。
本实验旨在通过实现基本操作,包括插入、删除、获取等,来深入理解顺序表的原理和实现方式。
实验目的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。
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、编写程序,构造一个存储整数序列的线性表即建立整数顺序表,要求实现以下基本操作:置空、初始化、插入、删除、求长度、定位(返回指定位置的数据)、查找(返回给定数据在顺序表中的位置)等。
其他基本操作自行完成如排序等。
结合P259 三、(1)程序#include <stdio.h>#include <conio.h>#include <stdlib.h>#define LIST_INIT_SIZE 9#define LISTINCREMENT 3#define TRUE 1#define FALSE 0#define OK 1#define ERROR -1#define OVERFLOW -2typedef int Status;typedef int ElemType;typedef struct{int *elem;int length;int listsize;} SqList;void Converts(SqList &L){ int i,k,x;k=L.length/2;for(i=1;i<=k;i++){ x=L.elem[i];L.elem[i]= L.elem[L.length-i+1];L.elem[L.length-i+1]=x;}}/*求顺序表的长度*/ElemType ListLength(SqList L){return(L.length);}/*求顺序表中元素的前驱*/ElemType SqListPrior(SqList L,ElemType e) {int i=0;while(i)i++;if(i==0){printf("第一个元素没有前驱\n");return 0;}elseif(i<=L.length-1)return(L.elem[i-1]);else{printf("不存在值为%d的元素\n",e);return 0;}}/*求顺序表中元素的后继*/ElemType SqListNext(SqList L,ElemType e) {int i=0;while(i)i++;if(i==L.length-1){printf("最后一个元素没有后继\n");return 0;}elseif(i)return(L.elem[i+1]);else{printf("不存在值为%d的元素\n",e);return 0;}}Status Initlist_Sq(SqList &L) /*初始化顺序表*/{L.elem = (ElemType *) malloc(LIST_INIT_SIZE * sizeof (ElemType));if (L.elem == NULL)exit(OVERFLOW);L.length = 0;L.listsize = LIST_INIT_SIZE;return OK;}void Destroylist(SqList &L) /*销毁顺序表*/{free(L.elem);}void Clearlist_Sq(SqList &L) /*清空顺序表*/{L.length = 0;}Status Listempty_Sq(SqList L) /*测试顺序表是否为空*/ {if (L.length == 0)return TRUE;elsereturn FALSE;}Status ListInsert_Sq(SqList &L, int i,ElemType e) /*在第i个位置上插入一个元素*/{int *q, *p;if (i < 1 || i > L.length + 1)return ERROR;if (L.length >= L.listsize) {int *newbase;newbase = (ElemType *) realloc(L.elem, (LIST_INIT_SIZE + LISTINCREMENT) * sizeof (ElemType));if (newbase == NULL)exit(OVERFLOW);L.elem = newbase;/*L.length += LISTINCREMENT;*/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 LocateElem_Sq(SqList L,ElemType e) /*返回元素e在顺序表中的位置*/{int i = 0;for (i = 0; i < L.length; i++) {if (L.elem[i] == e)return i + 1;}return FALSE;}Status ListDelete_Sq(SqList &L, int i, int &e) /*删除第i个位置上的元素*/{if (i < 1 || i > L.length)return ERROR;int *p, *q;p = &(L.elem[i - 1]);e = *p;q = L.elem + L.length - 1;for (++p; p <= q; ++p)*(p - 1) = *p;--L.length;return OK;}void Print_Sq(SqList L) /*输出顺序表*/{int i;if (Listempty_Sq(L)) {printf("\nSequential List's length is %d. It's empty!",L.length);return; /*返回*/}printf("\nSequential List's length is %d. These element are:\n",L.length);for(i = 0; i < L.length; i++)printf("%d ",L.elem[i]);printf("\n");}void menu(){printf("\n");printf("\n* * * * * * * * * * * * * * * * * * * * * * * * * *\n");printf(" 1 ------- 打印顺序表.\n");printf(" 2 ------- 插入一个数据进入顺序表.\n");printf(" 3 ------- 删除一个数据进入顺序表.\n");printf(" 4 ------- 获得一个元素的位置.\n");printf(" 5 ------- 清空顺序表.\n");printf(" 7 -------顺序表的长度.\n");printf(" 8 -------获得 i的前驱.\n");printf(" 6 -------获得 i的后继.\n");printf(" 9------- 逆转顺序表.\n");printf("* * * * * * * * * * * * * * * * * * * * * * * * * *\n");printf("\n");}void menuselect(SqList L){int k, i, done = 1;SqList La;ElemType e,prior,next;while (done) {menu();printf("Please choose: ");scanf("%d", &k);getchar();switch(k) {case 1: Print_Sq(L); break;case 2: {printf("\nInput the location and data you want to Insert: ");scanf("%d,%d",&i,&e);if (ListInsert_Sq(L,i,e)==ERROR)printf("Insert location is not correct!\n");break;}case 3: {printf("\nInput the location you want to delete data: ");scanf("%d", &i);if (ListDelete_Sq(L,i,e)==ERROR)printf("Delete location is not exit!\n"); elseprintf("\nDelete data is %d.",e);break;}case 4: {printf("\nInput the data you want to find: "); scanf("%d", &e);if (LocateElem_Sq(L, e)!=FALSE)printf("\nData %d location in the Sequential List is %d.", e,LocateElem_Sq(L,e));elseprintf("\nData %d is not in the Sequential List.\n", e);break;}case 5: Clearlist_Sq(L); break;case 9: Converts(L);break;case 7:printf("顺序表的长度为%d\n",ListLength(L));break;case 8:printf("此元素的的前驱\n");scanf("%d",&e);prior=SqListPrior(La,e);if(prior) printf("%d的前驱是:%d\n",e,prior);break;case 6:printf("此元素的的后继\n");scanf("%d",&e);next=SqListNext(La,e);if(next) printf("%d的后继是:%d\n",e,next);break;}}}void main(){ElemType e,prior,next;SqList La;int *elem;int n, i=0 ;char ch;Initlist_Sq(La);printf("Input a number of the element in the Sequential List (n<=%d):\n", LIST_INIT_SIZE);scanf("%d", &n);while(n > LIST_INIT_SIZE){printf("Input a number of the element in the Sequential List (n<=%d):\n", LIST_INIT_SIZE);scanf("%d", &n);}for(i = 1;i <= n; i++){printf("Enter the elements(%d):" ,i);scanf("%d", &e);ListInsert_Sq(La, i, e);}menuselect(La);getch();}。
数据结构C语言版实验一 顺序表的基本运算
(8)求顺序表中一个元素前驱算法的实现;
(9)求顺序表中一个元素后继算法的实现;
(10)求顺序表第i个元素算法的实现。
可运行程序:
#include <stdio.h>
#include <malloc.h>
#include <stdio.h>
#include <malloc.h>
for(int i=0;i<L.length;i++)
printf("%c",L.elem[i]);
printf("\n");}
//(8)求顺序表中一个元素前驱算法的实现;
int PriorElem_Sq(SqList L,ElemType cur_e,ElemType &pre_e){
ListInsert_Sq(L,1,'B');
ListInsert_Sq(L,1,'C');//改变主函数,使插入的元素序列为CBA
Disp_Sq(L);
printf("请输入一个元素求其前驱后继:");
scanf("%c",&cur_e);
i=PriorElem_Sq(L,cur_e,pre_e);
return 1;
}
}
//(9)求顺序表中一个元素后继算法的实现;
int NextElem_Sq(SqList L,ElemType cur_e,ElemType &next_e){
int i=1;
ElemType *p=L.elem;
数据结构实验报告-实验一顺序表、单链表基本操作的实现
数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现l 实验⽬的1、顺序表(1)掌握线性表的基本运算。
(2)掌握顺序存储的概念,学会对顺序存储数据结构进⾏操作。
(3)加深对顺序存储数据结构的理解,逐步培养解决实际问题的编程能⼒。
l 实验内容1、顺序表1、编写线性表基本操作函数:(1)InitList(LIST *L,int ms)初始化线性表;(2)InsertList(LIST *L,int item,int rc)向线性表的指定位置插⼊元素;(3)DeleteList1(LIST *L,int item)删除指定元素值的线性表记录;(4)DeleteList2(LIST *L,int rc)删除指定位置的线性表记录;(5)FindList(LIST *L,int item)查找线性表的元素;(6)OutputList(LIST *L)输出线性表元素;2、调⽤上述函数实现下列操作:(1)初始化线性表;(2)调⽤插⼊函数建⽴⼀个线性表;(3)在线性表中寻找指定的元素;(4)在线性表中删除指定值的元素;(5)在线性表中删除指定位置的元素;(6)遍历并输出线性表;l 实验结果1、顺序表(1)流程图(2)程序运⾏主要结果截图(3)程序源代码#include<stdio.h>#include<stdlib.h>#include<malloc.h>struct LinearList/*定义线性表结构*/{int *list; /*存线性表元素*/int size; /*存线性表长度*/int Maxsize; /*存list数组元素的个数*/};typedef struct LinearList LIST;void InitList(LIST *L,int ms)/*初始化线性表*/{if((L->list=(int*)malloc(ms*sizeof(int)))==NULL){printf("内存申请错误");exit(1);}L->size=0;L->Maxsize=ms;}int InsertList(LIST *L,int item,int rc)/*item记录值;rc插⼊位置*/ {int i;if(L->size==L->Maxsize)/*线性表已满*/return -1;if(rc<0)rc=0;if(rc>L->size)rc=L->size;for(i=L->size-1;i>=rc;i--)/*将线性表元素后移*/L->list[i+=1]=L->list[i];L->list[rc]=item;L->size++;return0;}void OutputList(LIST *L)/*输出线性表元素*/{int i;printf("%d",L->list[i]);printf("\n");}int FindList(LIST *L,int item)/*查找线性元素,返回值>=0为元素的位置,返回-1为没找到*/ {int i;for(i=0;i<L->size;i++)if(item==L->list[i])return i;return -1;}int DeleteList1(LIST *L,int item)/*删除指定元素值得线性表记录,返回值为>=0为删除成功*/ {int i,n;for(i=0;i<L->size;i++)if(item==L->list[i])break;if(i<L->size){for(n=i;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return i;}return -1;}int DeleteList2(LIST *L,int rc)/*删除指定位置的线性表记录*/{int i,n;if(rc<0||rc>=L->size)return -1;for(n=rc;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return0;}int main(){LIST LL;int i,r;printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.size,LL.Maxsize);printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.list,LL.Maxsize);while(1){printf("请输⼊元素值,输⼊0结束插⼊操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d",&i);if(i==0)break;printf("请输⼊插⼊位置:");scanf("%d",&r);InsertList(&LL,i,r-1);printf("线性表为:");OutputList(&LL);}while(1){printf("请输⼊查找元素值,输⼊0结束查找操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d ",&i);if(i==0)break;r=FindList(&LL,i);if(r<0)printf("没有找到\n");elseprintf("有符合条件的元素,位置为:%d\n",r+1);}while(1){printf("请输⼊删除元素值,输⼊0结束查找操作:");fflush(stdin);/*清楚标准缓存区*/scanf("%d",&i);if(i==0)break;r=DeleteList1(&LL,i);if(i<0)printf("没有找到\n");else{printf("有符合条件的元素,位置为:%d\n线性表为:",r+1);OutputList(&LL);}while(1){printf("请输⼊删除元素位置,输⼊0结束查找操作:");fflush(stdin);/*清楚标准输⼊缓冲区*/scanf("%d",&r);if(r==0)break;i=DeleteList2(&LL,r-1);if(i<0)printf("位置越界\n");else{printf("线性表为:");OutputList(&LL);}}}链表基本操作l 实验⽬的2、链表(1)掌握链表的概念,学会对链表进⾏操作。
实验一-顺序表的基本操作
实验一-顺序表的基本操作实验一顺序表的基本操作一、实验目的1.掌握顺序表及其基本操作的实现。
2.掌握利用VC/TC实现数据结构的编程方法。
3.通过上机实践进一步加深对线性表的顺序存储方式理解。
4.通过上机实践加强利用数据结构解决实际应用问题的能力。
二、实验要求1.实验前做好充分准备,包括复习第一章、第二章所学内容,事先预习好本次实验内容。
2.实验时记录实验结果,按要求完成各题。
3.实验结束后,给出实验总结与分析并及时给出本次实验的实验报告。
三、实验内容与要求实验题目:顺序表的定义及其相关操作算法的实现要求:编程实现顺序表的类型定义及顺序表的初始化操作、插入操作、删除操作、取元素操作、输出操作等,并对其进行验证。
四、实验程序示例1、顺序表实验程序示例#include "stdio.h"#include "alloc.h"/*-------------(1)预定义常量及类型-----------------*/#define OK 1#define ERROR 0#define OVERFLOW -2#define TRUE 1#define FALSE 0typedef int Status;/*-------(2)顺序表类型及其基本操作函数的定义---------*/#define InitSize 100#define INCR 20typedef int ElemType; /*定义元素类型为int类型*/typedef struct{ ElemType *Elem;int Length;int ListSize;}SqList; /*SqList类型为顺序表类型*/Status InitList_sq(SqList *L) /*初始化操作函数定义*/{ L->Elem=(ElemType*)malloc(InitSize*sizeof(ElemType));if (!(L->Elem))return(OVERFLOW);L->Length=0; L->ListSize=InitSize;return OK;}Status ListInsert_sq(SqList *L, int i, ElemType e) /*插入操作函数定义*/{/* 写出你的代码*/}Status ListDelete_sq(SqList *L, int i) /*删除第i 个位置的元素*/ {/* 写出你的代码*/}Status LocateElem(SqList *L, ElemType e) /*查找值为e的元素的位置*/{/* 写出你的代码*/}/* 以下为选作的*//*void exchange ( SqList *L,int m ,int n) // 本算法实现顺序表中前m 个元素和后n 个元素的互换void purge(SqList *L ) // 删除顺序表L 中冗余元素v oid ReverseSeqList(SqList &L) //倒置v oid MergeList(SqList la,SqList lb,Sqlist &lc)//有数据类型为整型顺序表La和Lb,其元素均按从小到大升序排列,编写一个算法将它们合并成一个表Lc,且Lc的元素也是按升序排列。
数据结构 顺序表的基本算法
2011——2012学年第一学期合肥学院数理系实验报告课程名称:数据结构与算法实验项目:顺序表基本算法实验类别:综合性□设计性■验证性□专业班级:数学2班姓名:吴芸学号:0907022005 实验地点:7#503实验时间:2011-10-07指导教师:李旭成绩:一.实验目的:通过学习掌握顺序表的数据结构定义及其7种基本算法。
二.实验内容:1、置空表算法2、求表长算法3、按序号取元素算法4、按值查找算法5、判表满算法6、插入数据元素算法7、删除数据元素算法三. 实验方案(程序设计说明)1、置空表算法#include<stdio.h>#define maxlen 50typedef struct{int data[maxlen];int last;}Sequenlist;void SqLsetnull(Sequenlist *L){L->last=-1;}void main(){Sequenlist l;SqLsetnull(&l);}2、求表长算法#include<stdio.h>#define maxlen 100typedef struct{int data[maxlen];int last;}Sequenlist;int SqLlength(Sequenlist *L){return(L->last+1);}void main(){Sequenlist l;int i,x;for(i=0;i<10;i++)l.data[i]=i+2;st=9;x=(&l);printf("%d",x);}3、按序号取元素算法#include<stdio.h>#define maxlen 100typedef struct{int data[maxlen];int last;}Sequenlist;int SqLlength(Sequenlist *L){return(L->last+1);}int SqLget(Sequenlist *L,int i){int x;if(i<1||i>SqLlength(L))printf("超出范围");elsex=L->data[i-1];return(x);}void main(){Sequenlist l;int i,a;for(i=0;i<5;i++)scanf("%d",&l.data[i]);st=4;a=SqLget(&l,4);printf("取出的元素是%d",a); }4、按值查找算法#include<stdio.h>#define maxlen 100typedef struct{int data[maxlen];int last;}Sequenlist;int SqLlength(Sequenlist *L){return(L->last+1);}void SqLlocate(Sequenlist *L,int x) {int i,z=0;for(i=0;i<SqLlength(L);i++)if(L->data[i]==x){printf("%d",i+1);z=1;}if(z==0)printf("查找失败"); }void main(){Sequenlist l;int i;for(i=0;i<10;i++)scanf("%d",&l.data[i]);st=10;SqLlocate(&l,10);}5、判表满算法#include<stdio.h>#define maxlen 100typedef struct{int data[maxlen];int last;}Sequenlist;int SqLempty(Sequenlist *L){if(L->last+1>=maxlen)return(1);elsereturn(0);}void main(){Sequenlist l;int i,x;for(i=0;i<5;i++)scanf("%d",&l.data[i]);st=4;x=SqLempty(&l);printf("%d",x);}6、插入数据元素算法#include<stdio.h>#define maxlen 100typedef struct{int data[maxlen];int last;}sequenlist;int sqldelete(sequenlist *l,int i,int x){int j;if(l->last+1>=maxlen){printf("overflow");return 0;}else if((i<1)||(i>l->last+2)){printf("error");return(0);}else{for(j=l->last;j>=i-1;j--)l->data[j+1]=l->data[j];l->data[i-1]=x;l->last=l->last+1;for(j=0;j<l->last+1;j++)printf("%d ",l->data[j]);return(1);}}void main(){sequenlist l;int i;for(i=0;i<6;i++)scanf("%d",&l.data[i]);st=6;sqldelete(&l,4,67);}7、删除数据元素算法#include<stdio.h>#define maxlen 100typedef struct{int data[maxlen];int last;}sequenlist;int sqldelete(sequenlist *l,int i){int j;if(l->last<0){printf("顺序表空");return 0;}else if((i<1)||(i>l->last+1)){printf("i参数出错");return(0);}else{for(j=i;j<l->last+1;j++)l->data[j-1]=l->data[j];l->last--;for(j=0;j<l->last;j++)printf("%d ",l->data[j]);return(1);}}void main(){sequenlist l;int p;for(p=0;p<5;p++)scanf("%d",&l.data[p]);st=5;sqldelete(&l,3);}五.程序运行结果按序号取元素算法:按值查找算法:删除数据元素算法:六.实验总结在实验过程中,发现自己出现了一些数据结构定义、数据类型的错误,所以得不到正确的结果,通过不断的调试和修改将其改正过来了,通过对顺序表基本算法的练习而进一步了解了算法的应用。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验一顺序表的基本算法
一.实验目的:
通过上机编程,掌握线性表在顺序存储结构上的基本运算。
二.实验要求:
1. 给出程序设计的基本思想、原理和算法描述;
2. 画出程序流程图;根据数据结构有关知识编出算法程序;
3. 源程序给出注释;
4. 保存和打印出程序的运行结果,并结合程序进行分析。
三.实验内容:
1.编写顺序表的删除函数;
2.编写程序实现以下功能:
(1)创建一个至少包含5 个元素的顺序表,元素值从键盘输入;
(2) 调用删除函数,删除表中第三个位置上的元素;
(3) 输出最终顺序表中的元素。
3. 编写函数,要求实现以下功能:
(1)查找元素x 在顺序表中的位置:如果x 在表中,返回x 在顺序表中的位置;如果x 不在表中,返回0;
源程序
#include<stdio.h>
#include<stdlib.h>
#define maxlen 100//定义字符组
typedef int datatype; struct sqlisttp
{
datatype elem[maxlen];//建立顺序表
int last;
};
typedef struct sqlisttp SEQLIST;
void delete(SEQLIST v,datatype i);//定义delete 函数
void print(SEQLIST v);
void delete(SEQLIST v,datatype i)
{
int k;
if(i<1||i>st+1)
printf("The position is not suitable!\n");
else if(st>=maxlen-1)
printf("The sequlist in full!\n");
else
{
for(k=i+1;k<=st;k++)//将i+1 位置用i+2 替代,字符组长度减为n-1
v.elem[k-1]=v.elem[k];
st--;
}
print(v);
}
void print(SEQLIST v)//输出结果{
int i;
for(i=1;i<=st;i++)
{printf("%6d",v.elem[i]);
if(i%10==0) printf("\n");
}
printf("\n");
}
main( )
{
int i;
SEQLIST v;
st=0;
printf("Please input 5 elements:\n"); for(i=1;i<=5;i++)
{
scanf("%d",&v.elem[i]);
st++;
}
delete(v,3);//删除第3 个数// getch( );
}
实验小结:通过本次实验了解了顺序表的基本算法,上机操作了软件,通过自己输入算法获得结果,加深了对顺序表的理解,收获良多。