实验一 数据结构顺序表的插入和删
顺序表的基本操作--插入,删除,合并
{
ElemType*newbase,*p,*q;
if(i<1||i>L->length+1)returnERROR;
if(L->length>=L->listsize)
{
newbase=(ElemType*)realloc(L->elem,(L->listsize+LISTINCREMENT)*sizeof(ElemType));
printf("Listsize: %d\n\n",La.listsize);
}
else
printf("error!");
/*------------------INIT-----------------*/
if(InitList_sq(&Lb))
{
printf("Init is ok!\n");
printf("Length: %d\n",Lb.length);
实验
准备
你为本次实验做了哪些准备:
在课后认真复习,基于上课的基础上,对于线性表的存储,插入,删除,合并等有了一定的了解,对于书上给出的程序反复捉摸,达到了较熟练的程度。
实验
进度
本次共有1个练习,完成个。
实验
总结
日
本次实验的收获、体会、经验、问题和教训:
顺序表初始化、插入、删除算法。
实现两个有序表合并算法.
for(i=1;i<=n;i++)
{
scanf("%d",&e) ;
数据结构实验一顺序表
数据结构实验一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.实验目的1、输入一批整型数据,建立顺序表;2、实现顺序表的插入(输入插入位置i,插入元素)3、实现顺序表的删除(输入删除元素位置i)4、实现顺序表中数据的显示;5、实现顺序表中数据的查找和定位;6、编写主函数,调试上述算法。
2.实验源代码#include<stdio.h>#define max 100void sequenlist(int s[],int n) //建立一个顺序表{for(int i=0;i<n;i++){printf("顺序表第%d个元素是:\n",i+1);scanf("%d",&s[i]);}printf("所以该顺序表输出为:\n");for(int j=0;j<n;j++){printf("%d\t",s[j]);}putchar('\n');}void insert(int s[],int &n,int i,int x) //顺序表的插入{if(n==max||i<1||i>n+1)printf("插入失败!!!\n");elsefor(int k=n-1;k>=i-1;k--){s[k+1]=s[k];}s[i-1]=x;n++;}void dele(int s[],int &n,int i) //删除元素位置i {if(i<1||i>n+1)printf("无法删除!!!\n");elsefor(int j=i-1;j<n;j++){s[j]=s[j+1];}n--;}void disp(int s[],int n) //输出顺序表数据{printf("该顺序表输出为:\n");for(int j=0;j<n;j++){printf("%d\t",s[j]);}putchar('\n');}void locate(int s[],int &n,int x) //查找和定位{int k;for(int j=0;j<n;j++){if(s[j]==x)k=j+1;}printf("您要查找的数据位于第%d位!\n",k);}int main(){int s[max];int n;int i,x;int num;printf("请输入顺序表的数据元素个数:\n");scanf("%d",&n);sequenlist(s,n); //顺序表的建立printf("******************************************************\n" );printf("*************1.插入***********************************\n");printf("*************2.删除***********************************\n");printf("*************3.输出***********************************\n");printf("*************4.查找***********************************\n");printf("******************************************************\n" );while(1){printf("请选择:\n");scanf("%d",&num);switch(num){case 1:printf("请选择要插入的位置:\n");scanf("%d",&i);printf("请选择要插入的数据:\n");scanf("%d",&x);insert(s,n,i,x);break;case 2:printf("请选择您要删除的元素位置:\n");scanf("%d",&i);dele(s,n,i);break;case 3:disp(s,n);break;case 4:printf("请选择您要查询的元素:\n");scanf("%d",&x);locate(s,n,x);break;default:goto l;break;}}l:return 0;}3.实验结果见下图!。
顺序表的查找插入与删除实验报告
顺序表的查找插入与删除实验报告顺序表的查找、插入与删除实验报告《数据结构》实验报告一学院:班级:姓名:程序名学号:日期:一、上机实验的问题和要求:顺序表的搜寻、填入与删掉。
设计算法,同时实现线性结构上的顺序表的产生以及元素的搜寻、填入与删掉。
具体内容同时实现建议:1.从键盘输入10个整数,产生顺序表,并输入结点值。
2.从键盘输入1个整数,在顺序表搜寻该结点的边线。
若找出,输入结点的边线;若打听不到,则显示“找不到”。
3.从键盘输入2个整数,一个则表示欲填入的边线i,另一个则表示欲填入的数值x,将x挂入在对应位置上,输出顺序表所有结点值,观察输出结果。
4.从键盘输入1个整数,表示欲删除结点的位置,输出顺序表所有结点值,观察输出结果。
二、源程序及注解:#include#include/*顺序表的定义:*/#include#definelistsize100/*表空间大小可根据实际需要而定,这里假设为100*/typedefintdatatype;/*datatype可以是任何相应的数据类型如int,float或char*/typedefstruct{datatypedata[listsize];/*向量data用作放置表中结点*/intlength;/*当前的表中长度*/}seqlist;voidmain(){seqlistl;inti,x;intn=10;/*欲建立的顺序表长度*/l.length=0;voidcreatelist(seqlist*l,intn);voidprintlist(seqlistl,intn);intlo catelist(seqlistl,datatypex);voidinsertlist(seqlist*l,datatypex,inti);voiddele telist(seqlist*l,inti);1createlist(&l,n);/*建立顺序表*/printlist(l,n);/*打印顺序表*/printf(\输入要查找的值:\scanf(\i=locatelist(l,x);/*顺序表查找*/printf(\输入要插入的位置:\scanf(\printf(\输入要插入的元素:\scanf(\insertlist(&l,x,i);/*顺序表插入*/printlist(l,n);/*打印顺序表*/printf(\输入要删除的位置:\scanf(\deletelist(&l,i);/*顺序表删除*/printlist(l,n);/*打印顺序表*/}/*顺序表的创建:*/voidcreatelist(seqlist*l,intn){inti;for(i=0;ilength=n;}/*顺序表的列印:*/voidprintlist(seqlistl,intn){inti;for(i=0;i/*顺序表的查找:*/intlocatelist(seqlistl,datatypex){inti=0;while(iif(i2/*顺序表的插入:*/voidinsertlist(seqlist*l,datatypex,inti){intj;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++;}/*顺序表的删除:*/voiddeletelist(seqlist*l,inti){intj;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--;}3三、运行输出结果:四、调试和运行程序过程中产生的问题及采取的措施:4。
数据结构实验,线性表的插入和删除,单链表操作,Huffman编码树
{ int i,j,k,x1,x2,m1,m2;
for(i=1;i<(2*n);i++)
{ t[i].pa=t[i].lc=t[i].rc=0;
if(i<=n)
t[i].data=w[i];
else
t[i].data=0;
}
for(i=1;i<n;i++)
{ m1=m2=MAX;
x1=x2=0;
for(j=1;j<(n+i);j++)
ListCount=0;
int nOperateState;
while(TRUE)
{
printf( "选择你要操作的方法,1为插入,2为删除,3为查询!4为退出\r\n ");
scanf("%d",&nOperateState);
switch(nOperateState)
{
case 1:
InsertInfo();
{
printf("请不要重复插入相同学号的信息\r\n");
LocalFree(Info);
return;
}
ptemp=ptemp->pNext;
}
}
if (ListHead)
{
if (ListCount==1)
{
ListTail=Info;
ListTail->pNext=NULL;
ListHead->pNext=ListTail;
temp->stu_num,temp->stu_age,temp->stu_english_grade);
数据结构实验顺序表的基本操作
数据结构实验-顺序表的基本操作顺序表是一种线性数据结构,它的元素在内存中是连续存储的。
顺序表具有随机访问的特点,可以通过下标直接访问元素,因此在访问元素时具有较高的效率。
顺序表的基本操作包括插入、删除、查找等,下面将对这些基本操作进行详细介绍。
1. 初始化:初始化顺序表需要为其分配一定的内存空间,以存储元素。
可以使用静态分配或动态分配两种方式来初始化顺序表。
静态分配是在编译时为顺序表分配固定大小的内存空间,而动态分配是在运行时根据需要动态地为顺序表分配内存空间。
2. 插入操作:插入操作是将一个元素插入到顺序表的指定位置上。
在插入元素之前,需要判断顺序表是否已满,如果已满则需要进行扩容操作。
插入元素时,需要将插入位置以及其后的元素向后移动一位,为插入元素腾出位置。
插入操作的时间复杂度为O(n),其中n为顺序表的长度。
3. 删除操作:删除操作是将顺序表中的一个元素删除。
在删除元素之前,需要判断顺序表是否为空,如果为空则无法进行删除操作。
删除元素时,需要将删除位置后面的元素向前移动一位,覆盖删除位置上的元素。
删除操作的时间复杂度为O(n),其中n为顺序表的长度。
4. 查找操作:查找操作是根据给定的关键字,在顺序表中查找满足条件的元素。
可以使用顺序查找或二分查找两种方式进行查找。
顺序查找是从顺序表的第一个元素开始,逐个比较关键字,直到找到满足条件的元素或遍历完整个顺序表。
二分查找是在有序顺序表中进行查找,每次将待查找区间缩小一半,直到找到满足条件的元素或待查找区间为空。
查找操作的时间复杂度为O(n),其中n为顺序表的长度。
5. 修改操作:修改操作是将顺序表中的一个元素修改为新的值。
修改操作需要先进行查找操作,找到待修改的元素,然后将其值修改为新的值。
修改操作的时间复杂度为O(n),其中n为顺序表的长度。
6. 遍历操作:遍历操作是依次访问顺序表中的每个元素。
可以使用for循环或while循环进行遍历,从第一个元素开始,依次访问每个元素,直到遍历完整个顺序表。
数据结构顺序表的基本操作
数据结构顺序表的基本操作
数据结构顺序表是一种线性表的实现方式,它通过一段连续的内存空间存储线性表的元素,支持快速的随机访问。
顺序表的基本操作包括插入、删除、查找、遍历等。
下面分别介绍这些操作:
1. 插入操作:顺序表的插入操作需要考虑插入位置、插入元素和数组容量等因素。
如果插入位置在数组范围内,则需要将插入位置及之后的元素向后移动一位,以给插入元素腾出空间。
如果数组容量已满,则需要动态扩容,重新分配一段更大的内存空间。
2. 删除操作:顺序表的删除操作需要考虑删除位置和数组容量等因素。
如果删除位置在数组范围内,则需要将删除位置及之后的元素向前移动一位,填补删除位置的空缺。
如果数组元素数量较少,可以考虑动态缩容,释放一部分内存空间。
3. 查找操作:顺序表的查找操作可以通过遍历整个数组进行线性查找,也可以通过二分查找等算法提高查找效率。
需要注意的是,顺序表的元素必须是有序的才能使用二分查找。
4. 遍历操作:顺序表的遍历操作可以通过循环遍历整个数组进行,也可以通过迭代器等方式简化遍历操作。
以上是顺序表的基本操作,需要根据具体的应用场景和需求进行选择和实现。
在实现过程中,需要注意数组下标越界、插入删除元素时的内存管理等问题。
- 1 -。
顺序表的操作实验报告
顺序表的操作实验报告一、实验目的。
1. 了解顺序表的基本概念和操作方法;2. 掌握顺序表的插入、删除、查找等操作;3. 熟悉顺序表的存储结构和实现方式。
二、实验内容。
1. 实现顺序表的基本操作,包括插入、删除、查找等;2. 对比顺序表和链表的优缺点;3. 分析顺序表的存储结构和实现方式。
三、实验原理。
顺序表是一种线性表的存储结构,它的特点是元素之间的逻辑顺序和物理顺序一致,即在内存中连续存储。
顺序表的基本操作包括插入、删除、查找等。
1. 插入操作,在顺序表的某个位置插入一个元素,需要将插入位置后的所有元素向后移动一个位置,然后将新元素插入到指定位置。
2. 删除操作,删除顺序表中的某个元素,需要将删除位置后的所有元素向前移动一个位置,然后将最后一个元素删除。
3. 查找操作,在顺序表中查找某个元素,需要遍历整个顺序表,逐个比较元素的值,直到找到目标元素或者遍历完整个表。
四、实验步骤。
1. 实现顺序表的基本操作,包括插入、删除、查找等;2. 编写测试用例,验证顺序表的功能和正确性;3. 对比顺序表和链表的优缺点,分析其适用场景;4. 分析顺序表的存储结构和实现方式,总结其特点和应用场景。
五、实验结果与分析。
1. 实现了顺序表的基本操作,包括插入、删除、查找等,功能正常;2. 经过测试用例验证,顺序表的功能和正确性得到了验证;3. 对比顺序表和链表的优缺点,发现顺序表的插入、删除操作效率较低,但查找操作效率较高,适合静态查找;4. 分析顺序表的存储结构和实现方式,发现其适用于元素数量较少且频繁查找的场景。
六、实验总结。
通过本次实验,我们深入了解了顺序表的基本概念和操作方法,掌握了顺序表的插入、删除、查找等操作。
同时,我们对比了顺序表和链表的优缺点,分析了顺序表的存储结构和实现方式,加深了对顺序表的理解和应用。
在今后的学习和工作中,我们将根据实验结果的分析,合理选择顺序表或链表作为数据结构,以满足不同场景下的需求。
顺序表的建立、输入、输出、查找、插入、删除(数据结构)
顺序表的建⽴、输⼊、输出、查找、插⼊、删除(数据结构)1.顺序表的基本操作实践。
(1)建⽴4个元素的顺序表list[]={2,3,4,5},实现顺序表建⽴的基本操作。
(2)在list[]={2,3,4,5}的元素4和5之间插⼊⼀个元素9,实现顺序表插⼊的基本操作。
(3)在list[]={2,3,4,9,5}中删除指定位置(i=3)上的元素4,实现顺序表的删除的基本操作。
#include <stdio.h>#include <stdlib.h>#include <iostream>#define MAXSIZE 10using namespace std;typedef int ElemType;typedef struct {ElemType a[MAXSIZE];int length;} S;void CreatList(S &L) {scanf("%d", &L.length);for(int i = 1; i <= L.length; i ++) scanf("%d",&L.a[i]);} //创建列表void PutList(S L) {for(int i = 1; i <= L.length; i ++) {printf("%d ",L.a[i]);}printf("\n");} //输出列表void InserElem(S &L, int i, ElemType x) { j iif(i < 1 || i > L.length) return; 2 3 4 5 9for(int j = L.length+1; j > i; j --) { j-1jL.a[j] = L.a[j-1]; 2 3 4 9 5}L.a[i] = x;L.length++;} //插⼊void DeleElem(S &L, int i) {for(int j = i; j < L.length; j ++) {L.a[j] = L.a[j+1]; j j+1} 2 3 4 9 5L.length--;}//删除int main() {S L;CreatList(L);InserElem(L,4,9);PutList(L);DeleElem(L,3);PutList(L);return0;}结果E:\c++>b42345234952395。
实验一顺序表的操作、插入与删除
实验一顺序表的操作、插入与删除实验一顺序表的操作、插入与删除【实验目的】(1)熟悉数据移动是顺序表的操作特点。
(2)掌握顺序表中元素的移动、插入和删除操作的特点。
【实验内容】题1 设有一个用向量表示的线性表a[n],a[0]中不存放线性表的元素。
要求写出将其中元素逆置的函数,并只允许用a[0]作附加的工作单元。
题2 写出从线性表中删除元素值为x的结点的函数。
若该表中无此结点,则输出“无此结点”信息。
【实验要求】从键盘任意输入9个整数,依次存放在数组a[10]的元素a[1]~a[9]中,逆置后输出。
在题1的基础上,从键盘输入一个整数x,从a[1]开始访问数组a,完成题2。
【实验提示】题1 有以下两种方法:(1)将a[1]至a[n-1]前移1位,再将a[n-1]←a[0];接着a[1]至a[n-2]前移一位,再将a[n-2]←a[0];……。
(2)可用移动和插入,通过a[0]使元素a[1]和a[n-1]交换;再使a[2]和a[n-2]交换;如此继续至中点为止。
注意如何判断中点。
思考这两种方法的时间复杂度分别是多少。
题2 首先也要找到被删除元素的位置,然后将该位置以后的数据元素全部前移一个单元。
注意:当数组a中有重复的元素值且x与此值相等时,函数应能删除全部重复元素。
当有多个连续的相同值需要删除时,应都能删除。
程序如下:#include#include/* run this program using the console pauser or add your own getch,system("pause") or input loop */int main(int argc, char *argv[]) {int a[100]={0},i,x,j,k;int n;//输入数组printf("请输入数组大小n:");scanf("%d",&n);printf("请输入%d个数:\n",n-1);for (i=1;i<n;i++)< p="">scanf("%d",&a[i]);printf("\n");for(i=1;i<=n/2;i++){a[0]=a[i];a[i]=a[n-i];a[n-i]=a[0];}//将a[i]与a[n-i]交换printf("逆序输出:\n");for(i=1;i<n;i++)< p="">{printf("%d ",a[i]);}//逆序输出n-1个整数printf("\n输入一个数字并删除它:\n");scanf("%d",&x);k=n;for(i=1;i<k;i++)< p="">while(a[i]==x){for(j=i;j<n;j++)< p="">a[j]=a[j+1];//将删除位置后的数据元素全部前移一个单元k=k-1;//顺序表的元素个数减一}//有多个连续相同值也进行删除if(k==n)printf("无此结点");else{for(i=1;i<k;i++)< p="">{printf("%d ",a[i]);}}return 0;}</k;i++)<></n;j++)<></k;i++)<></n;i++)<></n;i++)<>。
数据结构实验一顺序表实验报告
数据结构实验一顺序表实验报告数据结构实验一顺序表实验报告一、实验目的顺序表是一种基本的数据结构,本次实验的目的是通过实现顺序表的基本操作,加深对顺序表的理解,并掌握顺序表的插入、删除、查找等操作的实现方法。
二、实验内容1. 实现顺序表的创建和初始化操作。
2. 实现顺序表的插入操作。
3. 实现顺序表的删除操作。
4. 实现顺序表的查找操作。
5. 实现顺序表的输出操作。
三、实验步骤1. 创建顺序表的数据结构,包括数据存储数组和记录当前元素个数的变量。
2. 初始化顺序表,将当前元素个数置为0。
3. 实现顺序表的插入操作:- 判断顺序表是否已满,若已满则输出错误信息。
- 将插入位置之后的元素依次后移一位。
- 将要插入的元素放入插入位置。
- 当前元素个数加一。
4. 实现顺序表的删除操作:- 判断顺序表是否为空,若为空则输出错误信息。
- 判断要删除的位置是否合法,若不合法则输出错误信息。
- 将删除位置之后的元素依次前移一位。
- 当前元素个数减一。
5. 实现顺序表的查找操作:- 遍历顺序表,逐个比较元素值与目标值是否相等。
- 若找到目标值,则返回该元素的位置。
- 若遍历完整个顺序表仍未找到目标值,则返回错误信息。
6. 实现顺序表的输出操作:- 遍历顺序表,逐个输出元素值。
四、实验结果经过实验,顺序表的各项操作均能正确实现。
在插入操作中,可以正确将元素插入到指定位置,并将插入位置之后的元素依次后移。
在删除操作中,可以正确删除指定位置的元素,并将删除位置之后的元素依次前移。
在查找操作中,可以正确返回目标值的位置。
在输出操作中,可以正确输出顺序表中的所有元素。
五、实验总结通过本次实验,我深入了解了顺序表的原理和基本操作,并通过实际编程实现了顺序表的各项功能。
在实验过程中,我遇到了一些问题,如如何判断顺序表是否已满或为空,如何处理插入和删除位置的合法性等。
通过查阅资料和与同学讨论,我解决了这些问题,并对顺序表的操作有了更深入的理解。
数据结构实验.顺序表的插入
[数据结构实验题目一] 顺序表的插入辽大宋文龙一、实验题目:1、已知顺序表L,在第i个元素前插入元素e。
A、首先要定义顺序表的数据结构B、定义一个函数能够初始化一个顺序表C、编写一个函数,例如:int ListInsert_Sq(SqList *L,int i,int e){//已知顺序表L,在第i个元素前插入元素e,已知空间足够大。
……}D、读懂F中函数(ListPrint),它能输出一个顺序表中的所有元素的值。
E、编写主函数(main)并多次调用ListInsert_Sq函数创建一个顺序表,并输出其结果,例如:(输入的是1,2,3,4,5),输出结果为:1 2 3 4 5二,实验完整代码:#include "stdio.h"#include <malloc.h>//malloch函数头文件#include <conio.h>//getch函数头文件#define N 10 //顺序表中最多N个数#define OK 1#define ERROR -1typedef struct{int *elem;int length;int listsize;}SqList;int Init(SqList *L){// 初始化链表,因为L是指针,所以请注意->的使用,而不是L.L->elem=(int*)malloc(N*sizeof(int));if(!L->elem) return ERROR;L->length=0;L->listsize=N;return OK;}int ListInsert_Sq(SqList *L,int i,int e){//插入函数,在实验时,可暂不考虑空间不足的情况……int *p,*q,j;p=q=L->elem+L->length;if(i>L->length){*p=e;L->length++;L->listsize--;}//插入位置在链表最后元素之后时,为了保证无空位置,直接插在链表最后else{ for(j=L->length;j>=i;j--,q--){ *q=*(q-1);*(q-1)=e;}L->length++;L->listsize--;}return OK;}void ListPrint(SqList M){//能输出顺序表所有元素的值int *p;for(p=M.elem;p<=(M.elem+M.length-1);p++)printf("%d ",*p);printf("\n");}main(){int i,n=5,e;SqList M;Init(&M);printf("输入 %d 个数, Please:\n",n);for(i=1;i<=n;i++){/*创建初始的顺序表,包含n个数,通过调用n次ListInsert_Sq函数实施插入*/printf("第%d个数:",i);scanf("%d",&e); //输入一个数ListInsert_Sq(&M,i,e); //在L中第i个前插入e}ListPrint(M);//输出顺序表中各元素的值ListInsert_Sq(&M,3,999); //在第三个元素前插入999printf("插入后:\n");ListPrint(M);//输出插入后顺序表的各元素的值getch();//如果环境是Win-Tc,getch()起到暂停作用以看程序输出结果}三,实验结果。
数据结构实验报告顺序表
数据结构实验报告顺序表数据结构实验报告:顺序表摘要:顺序表是一种基本的数据结构,它通过一组连续的存储单元来存储线性表中的数据元素。
在本次实验中,我们将通过实验来探索顺序表的基本操作和特性,包括插入、删除、查找等操作,以及顺序表的优缺点和应用场景。
一、实验目的1. 理解顺序表的概念和特点;2. 掌握顺序表的基本操作;3. 了解顺序表的优缺点及应用场景。
二、实验内容1. 实现顺序表的初始化操作;2. 实现顺序表的插入操作;3. 实现顺序表的删除操作;4. 实现顺序表的查找操作;5. 对比顺序表和链表的优缺点;6. 分析顺序表的应用场景。
三、实验步骤与结果1. 顺序表的初始化操作在实验中,我们首先定义了顺序表的结构体,并实现了初始化操作,即分配一定大小的存储空间,并将表的长度设为0,表示表中暂时没有元素。
2. 顺序表的插入操作接下来,我们实现了顺序表的插入操作。
通过将插入位置后的元素依次向后移动一位,然后将新元素插入到指定位置,来实现插入操作。
我们测试了在表中插入新元素的情况,并验证了插入操作的正确性。
3. 顺序表的删除操作然后,我们实现了顺序表的删除操作。
通过将删除位置后的元素依次向前移动一位,来实现删除操作。
我们测试了在表中删除元素的情况,并验证了删除操作的正确性。
4. 顺序表的查找操作最后,我们实现了顺序表的查找操作。
通过遍历表中的元素,来查找指定元素的位置。
我们测试了在表中查找元素的情况,并验证了查找操作的正确性。
四、实验总结通过本次实验,我们对顺序表的基本操作有了更深入的了解。
顺序表的插入、删除、查找等操作都是基于数组的操作,因此在插入和删除元素时,需要移动大量的元素,效率较低。
但是顺序表的优点是可以随机访问,查找效率较高。
在实际应用中,顺序表适合于元素数量不变或变化不大的情况,且需要频繁查找元素的场景。
综上所述,顺序表是一种基本的数据结构,我们通过本次实验对其有了更深入的了解,掌握了顺序表的基本操作,并了解了其优缺点及应用场景。
实验一、顺序表的插入和删除操作
int len;
} SQlist;
void insert( SQlist *L, int i , ElemType x ){
int j;
for(j=L->len; j>=i; j--)
L->elem[j+1]=L->elem[j];
L->elem[i]=x;
山东英才学院
课年月日
学院(系)班姓名学号
实验题目:实验一、线形表的的插入、删除操作成绩:
一、实验目的和要求
1.掌握线性表的概念。
2.掌握线性表的插入、删除和查找算法。
二、实验原理
线性表(Linear List)是具有相同数据类型的数据元素的一个有限序列。
1.插入
线性表的插入操作是指在线性表的第i-1个数据元素和第i个数据元素之间插入一个新的数据元素b,就是要使长度为n的线性表(a1 ,…,ai-1 ,ai ,…an)变成长度为n+1的线性表(a1 ,…,ai-1 ,b ,ai ,…an)
while(1)
{
printf("\t\t\t 1继续录入,2退出并排序\n");
scanf("%d",&j);
if(j==2) break;
else {
printf(“please input the value k and x: ”);
scanf(“%d”,&k);
scanf(“%d”,&x);
3、查找
查找操作是指在具有n个结点的线性表中查找结点x在表中的位置,表的长度不发生变化。
三、主要仪器设备或材料
1、计算机一台
实验一顺序表的插入和删除实验目的...
int ctrl_loop;
putchar(' '); for (ctrl_loop = 0; ctrl_loop < length; ++ctrl_loop) {
std::cout << ctrl_loop + 1; } putchar('\n'); }
实验一顺序表的插入和删除
实验目的
1、掌握使用 Turbo C 上机调试线性表的基本方法; 2、掌握线性表的基本操作:插入、删除在顺序存储结构上的运算。
实验要求
1、认真阅读和掌握本实验的给定的程序; 2、按照你的操作需要,编制程序、上机调试运行程序; 3、保存程序的运行结果,并结合程序进行分析。
实验内容
std::cout << " Copyright (C) 2014 Spinel Studio" << std::endl; std::cout << " By Andrew Junzki" << std::endl; putchar('\n'); }
实验二链表的插入和删除
实验目的
1、掌握使用 Turbo C 上机调试线性表的基本方法; 2、掌握链表的基本操作:插入、删除和游历的操作。
实验要求
1、认真阅读和掌握本实验的给定的程序; 2、按照你的操作需要,编制程序、上机调试运行程序; 3、保存程序的运行结果,并结合程序进行分析。
实验内容
利用顺序表完成线性表信息的管理。要求首先建立并初始化线性表,并实现 增加、删除和游历等功能。
(1) 对给定字母 A C D E 建立顺序表 (2) 在给定位置插入字母 B,形成顺序表 A B C D E (3) 删除字母 D,形成表 A B C E
顺序表的插入和删除
《数据结构》实验报告实验名称:顺序表的插入和删除班级学号:学生姓名:指导老师:实验日期: 2012-10-26实验二顺序表的插入和删除实验学时:2学时一. 实验目的1.掌握顺序表的存储结构;2.掌握在顺序表上进行的插入、删除等操作。
二. 实验内容对已定义好的顺序表编写插入、删除等函数。
三. 实验重点插入、删除函数的编写。
四. 实验要求1.用C语言完成顺序表插入、删除函数的编写;2.源程序必须编译调试成功,结果正确。
五. 实验器材一个装有C语言编译环境的计算机。
六. 实验过程分实验预习、上机操作和实验报告三部分。
七. 原始程序#include <stdio.h>#include <malloc.h>#define MAXSIZE 100 //顺序表的最大长度typedef struct{int data[MAXSIZE];int curLength; //当前长度}SqList;void Init_Sq(SqList *L); //顺序表的初始化void Show_Sq(SqList *L); //顺序表的显示int Insert_Sq(SqList *L,int x,int i); //顺序表的插入int Delete_Sq(SqList *L,int i); //顺序表的删除void main(){SqList *L;L=(SqList*) malloc(sizeof(SqList));//初始化操作Init_Sq(L);printf("原始顺序表:\n");Show_Sq(L);//插入操作Insert_Sq(L,23,4);printf("插入之后顺序表:\n");Show_Sq(L);//删除操作Delete_Sq(L,1);printf("删除之后顺序表:\n");Show_Sq(L);}//顺序表的初始化void Init_Sq(SqList *L){printf("请输入初始化数据(以“-1”结束):");int b=0;int i=0;L->curLength=0;scanf("%d",&b);while(b!=-1){L->data[i]=b;i++;L->curLength++;scanf("%d",&b);}}//顺序表的显示void Show_Sq(SqList *L){int i;if(L->curLength==0){printf("顺序表中没有元素!\n");return;}else{for(i=0;i<L->curLength;i++)printf("%d\n",L->data[i]);}}//顺序表的插入int Insert_Sq(SqList *L,int x,int i){//实现插入操作return(1);}//顺序表的删除int Delete_Sq(SqList *L,int i){//实现删除操作return(1);}一、实验内容对已定义好的顺序表编写插入、删除等函数。
实验一顺序表的插入和删除
山东英才学院实验报告课年月日学院(系)班姓名学号实验题目:成绩:一、实验目的和要求本实验是数据结构后续实验的基础,做好本实验有助于学生理解单顺序线性表的概念,使学生掌握顺序线性表结构体的定义,熟悉顺序线性表的基本操作。
为后续实验打好基础。
定义顺序线性表结构体,定义顺序线性表初始化、销毁、插入、删除操作函数二、实验方法与步骤#include "stdio.h"#include "malloc.h"#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;#define LIST_INIT_SIZE 100 //线性表存储空间初始分配量#define LISTINCREMENT 10 //线性表存储空间分配增量typedef int ElemType;typedef struct{ElemType *elem; //线性表的基址int length; //线性表长度int listsize; //当前分配的存储容量} SqList;//线性表初始化:分配内存,长度置为0,初始容量LIST_INIT_SIZEStatus InitList(SqList &L){ L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));if(L.elem==NULL) return OVERFLOW;L.length=0;L.listsize=LIST_INIT_SIZE;return OK;}//释放内存,销毁线性表Status DestroyList(SqList &L){ if(L.elem==NULL) return OVERFLOW;free(L.elem);return OK;}Status ListEmty(SqList &L){ if(L.length==0) return 1;else return 0;}int ListLength(SqList &L){ return L.length;}//定位函数int LocateElem(SqList &L,ElemType e,Status compare(ElemType x, ElemType y)){ int i=1,*p=L.elem;while(i<=L.length ){if( (compare)(*p,e)==TRUE )return i;else{i++;p++;}}if(i>=L.length) return ERROR;}//向线性表中插入新数据Status ListInsert(SqList &L,int i,ElemType e){ if(i<1 || i>L.length+1 ) return ERROR;if(L.length >= L.listsize ){ ElemType *newbase=(ElemType *)realloc(L.elem,(L.listsize + LISTINCREMENT)*sizeof(ElemType));if(newbase==NULL) return OVERFLOW;L.elem=newbase;L.listsize=L.listsize+LISTINCREMENT;}ElemType *q=&(L.elem[i-1]);for(ElemType *p=&(L.elem[L.length-1]); p>=q; p--)*(p+1)=*p;*q=e;L.length=L.length+1;return OK;}//向线性表中插入新数据Status ListDelete(SqList &L,int i,ElemType &e){ if(i<1 || i>L.length+1 ) return ERROR;ElemType *p=&(L.elem[i-1]);e=*p;ElemType *q=L.elem+L.length-1;for(++p; p<=q;p++)*(p-1)=*p;L.length=L.length-1;return OK;}//线性表遍历函数void ListTraverse( SqList &L){ printf("线性表长度:%d,线性表容量:%d\n",L.length ,L.listsize );printf("线性表遍历序列:");if(L.length ==0) printf("线性表中无数据");for(int i=0; i<L.length ;i++)printf(" %d",L.elem[i]);printf("\n");}void main(){ SqList La;int pos,choose;ElemType e;InitList(La);while(1){ printf("请选择操作:选择1 进行插入操作,选择2 进行删除操作,选择3 显示表中内容,选择0 结束程序");scanf("%d",&choose);if(choose==1){ while(1){ printf("请输入插入位置(输入位置为0结束插入操作):");scanf("%d",&pos);if(pos==0) break;printf("请输入插入数据:");scanf("%d",&e);ListInsert(La,pos,e);}}else if(choose==2){ while(1){ printf("请输入删除位置(输入位置为0结束删除操作):");scanf("%d",&pos);if(pos==0) break;ListInsert(La,pos,e);}}else if(choose==3) ListTraverse(La);else if(choose==0) break;}DestroyList(La);}实验结果截图心得体会:本实验是数据结构后续实验的基础,做好本实验有助于学生理解单顺序线性表的概念,使学生掌握顺序线性表结构体的定义,熟悉顺序线性表的基本操作。
实验一数据结构顺序表的插入和删除
实验一顺序表的操作1.实验题目:顺序表的操作2.实验目的和要求:1)了解顺序表的基本概念、顺序表结构的定义及在顺序表上的基本操作(插入、删除、查找以及线性表合并)。
2) 通过在Turbo C(WinTc,或visual stdio6)实现以上操作的C语言代码。
3)提前了解实验相关的知识(尤其是C语言)。
3.实验内容:(二选一)1) 顺序表的插入算法,删除算法,顺序表的合并算法2) 与线性表应用相关的实例(自己选择具体实例)4.部分参考实验代码:⑴顺序表结构的定义:#include <stdio.h>#define MAXLEN 255typedef int ElemType;typedef struct{ ElemType elem[MAXLEN];int length;}sqList;⑵顺序表前插(在第i号元素前插入一个新的元素)int ListInsert(sqList *la,int i,int x){ int j;if(i<0||i>la-> length +1){ printf(“\n the value of i is wrong!”);return 0;}if(la-> length +1>=MAXLEN){ printf(“\n overflow!”);return 0;}. for(j=la-> length;j>=i;j--)la->list[j+1]=la->list[j];la->list[i]=x;la-> length ++;return 1;}⑶顺序表删除int ListDelete(sqList *la,int i){ if(i<0||i>la-> length){ printf(“\n the position is wrong!\n”);return 0;}for(i;i<la-> length;i++)la->list[i-1]=la->list[i];la-> length --;return 1;}5.附录:实验预备知识:⑴复习C语言中数组的用法。
顺序表的实现,包含插入 删除 查找等操作,完整源代码,有注释,包你喜欢
For personal use only in study and research; not for commercial use实验一顺序表的实现实验目的:熟练掌握顺序表的基本操作(插入、删除、查找等)实验内容:顺序表中的基本操作的实现(初始化、插入、删除、求表长、按值查找、按位置查找)实验要求:以顺序表的动态分配存储结构来实现;所有基本操作均应该以函数的形式表示;要有运行结果并考虑到顺序表中所有情况。
一、实验算法描述:1、顺序表的声明和创建typedef struct{int* data;//int*型元素int length;//顺序表的实际长度int listsize;//顺序表的最大长度}sqlist;void creatsqlist(sqlist &list){list.data=(int*)malloc(sizeof(int)*maxsize);//开辟一个名为l的顺序表if(!list.data)//判断顺序表是否存在exit(1);list.length=0;list.listsize=maxsize;}2、初始化函数initsqlist(list)void initsqlist(sqlist &list)//初始化操作{int* p;int n;cout<<"请输入顺序表元素数(1-50):"<<endl;//让用户输入顺序表元素个数cin>>n;cout<<"您申请的顺序表的长度是---"<<n<<endl;p=list.data;//p指向头指针cout<<"请依次输入无重复数字的有序顺序表(相邻数据用空格隔开,回车键完成输入):"<<endl;for(int i=0;i<n;i++)//逐个赋值{cin>>*p;p++;list.length++;}cout<<"您输入的递增顺序表为:"<<endl;//打印出初始化的顺序表for(i=0;i<n;i++)cout<<list.data[i]<<"\t";cout<<endl;}3、输出函数put(list)void put(sqlist &list) //输出函数{ int i;for(i=0;i<list.length;i++)cout<<list.data[i]<<"\t";cout<<endl;}4、定位函数locateElem(list)void locateElem(sqlist &list){int i,j=0,b;cout<<"请输如要查找的字符:\n";cin>>b;for(i=0;i<list.length;i++)if(list.data[i]==b){j=i+1;break;}if(j)cout<<"该数字的位置是:"<<j<<endl;elsecout<<"很抱歉,表中没有这个数字,请重试!"<<endl; }5、插入函数insert(list)void insert(sqlist &list)//插入函数{int i;cout<<"您想在第几位插入数字:\n";cin>>i;int x;cout<<"请输入要插入的数字:\n";cin>>x;int j;if(i<0||i>list.length){cout<<"位置错误"<<endl;put(list);}else{ for(j=list.length;j>=i;j--)list.data[j]=list.data[j-1];list.data[j]=x;list.length++;}cout<<"插入操作完成后的顺序表:"<<endl;put(list);}6、删除函数delete1(list)和delete2(list)void delete1(sqlist &list)//删除第i个位置的数字的函数{int i,b;cout<<"请输入你想要删除数据的位置:"<<endl;cin>>i;if(i<0||i>list.length){cout<<"输入错误!"<<endl;return;}else{b=list.data[i-1];for(i=i-1;i<list.length-1;i++)list.data[i]=list.data[i+1];--list.length;cout<<"需要删除的元素是:"<<b<<endl;cout<<"删除操作完成后的顺序表是:"<<endl;put(list);}}void delete2(sqlist &list)//删除指定数字的函数{int b;cout<<"输入您想删除的数字:"<<endl;cin>>b;int i,j=0;for(i=0;i<list.length;i++){if(list.data[i]==b){j=i+1;break;}}if(j!=0){for(;i<list.length-2 ;i++)list.data[i]=list.data[i+1];--list.length;cout<<"该位置是第"<<i<<"位"<<endl;cout<<"删除操作完成后的顺序表是:"<<endl;put(list);}elsecout<<"很遗憾,表中没有找到此数字,删除不成功,请重试!"<<endl;}二、实验程序描述:主函数如下:int main(){int flag;sqlist l;creatsqlist(l);initsqlist(l);cout<<endl<<"********************************************************* *****************"<<endl;cout<<"请输入要进行的操作序号:\n";cout<<"1.插入字符"<<endl<<"2.查找数字"<<endl<<"3.删除第i位数字"<<endl<<"4.删除指定数字"<<endl<<"0.退出"<<endl<<endl;cin>>flag;do{switch(flag){case 1:insert(l);break;case 2:locateElem(l);break;case 3:delete1(l);break;case 4:delete2(l);break;default:cout<<"请重新输入||代码错误"<<endl;}cout<<"*********************************************************** ***************"<<endl;cout<<"请输入要进行的操作序号:\n";cout<<"1.插入字符"<<endl<<"2.查找数字"<<endl<<"3.删除第i位数字"<<endl<<"4.删除指定数字"<<endl<<"0.退出"<<endl<<endl;cin>>flag;}while(flag!=0);return 0;}三、实验结果(输入和输出):1、输入界面:2、插入操作:3、查找操作:4、删除操作:仅供个人用于学习、研究;不得用于商业用途。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验一顺序表的操作
1.实验题目:顺序表的操作
2.实验目的和要求:
1)了解顺序表的基本概念、顺序表结构的定义及在顺序表上的基本操作(插入、删除、查找以及线性表合并)。
2)通过在Turbo C(WinTc,或visual stdio6)实现以上操作的C语言代码。
3)提前了解实验相关的知识(尤其是C语言)。
3.实验内容:(二选一)
1)顺序表的插入算法,删除算法,顺序表的合并算法
2)与线性表应用相关的实例(自己选择详尽实例)
4.部分参考实验代码:
⑴顺序表结构的定义:
#include <stdio.h>
#define MAXLEN 255
typedef int ElemType;
typedef struct
{ ElemType elem[MAXLEN];
int length;
}sqList;
⑵顺序表前插(在第i号元素前插入一个新的元素)
int ListInsert(sqList *la,int i,int x)
{ int j;
if(i<0||i>la-> length +1)
{printf(“\n the value of i is wrong!”); return 0;
}
if(la-> length +1>=MAXLEN)
{ printf(“\n overflow!”);
return 0;
}
. for(j=la-> length;j>=i;j--)
la->list[j+1]=la->list[j];
la->list[i]=x;
la-> length++;
return 1;
}
⑶顺序表删除
int ListDelete(sqList *la,int i)
{ if(i<0||i>la-> length)
{ printf(“\n the position is wrong!\n”); return 0;
}
for(i;i<la-> length;i++)
la->list[i-1]=la->list[i];
la-> length--;
return 1;
}
5.附录:实验预备知识:
⑴复习C语言中数组的用法。
⑵了解线性表和顺序表的概念,顺序表的定义方法;
线性表是n个数据元素的无限序列,至于每个数据元素的详尽含义,在例外的情况下各不相同。
顺序表是线性表的顺序存储表示,是用一组地址持续的存储单元依次存储线性表的数据元素。
在C语言中,顺序表是用数组来实现的。
⑶掌握线性表在顺序存储结构上实现基本操作:查找、插入、删除和合并的算法。
在实现这些算法的时候,要注意判断输入数据的合法性,除此之外还要要注意以下内容:
在实现查找的时候,首先要判断该顺序表是否为空,其次要判断查找后的结果(查到时输出查到的数据,未查到时给出未查到提示)。
在实现插入的时候,首先要判断该顺序表是否为满,如为满则报错(此时要注意:顺序表是用数组来实现的,它不能随机分配空间);如不为满,则需判断要插入的位置是否合法(例如:如果一个线性表的元素只有10个,而要在第0个元素前插入或在第11个元素后插入就为不合法)。
其次要注意是前插还是后
插,两者是有区别的;最后还要注意插入时各个数据元素移动的次序是从后面依次开始移动。
在实现删除的时候,首先要判断该顺序表是否为空,如为空则报错,如不为空,则需判断要删除的位置是否合法(例如:如果一个线性表的元素只有10个,而要删除第0个或第十一个元素就为不合法)。
其次还要注意删除时各个数据元素移动的次序是从前面依次开始移动。