1.C语言顺序表实验报告

合集下载

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

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

顺序表的基本操作实验报告一、实验目的本次实验旨在深入理解和掌握顺序表的基本操作,包括顺序表的创建、插入、删除、查找和遍历等功能,并通过实际编程实现,加深对数据结构中顺序存储结构的理解和应用能力。

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

顺序表实验报告

顺序表实验报告

顺序表实验报告顺序表是一种线性数据结构,它以连续的存储空间来存储数据元素,通过元素在数组中的相对位置来表示数据元素之间的逻辑关系。

在这个实验中,我们使用顺序表的实现来进行实验。

首先我们先了解一下顺序表的结构。

顺序表由两部分组成:表头和表体。

表头包含顺序表的一些基本信息,如顺序表的长度和当前表体的容量;表体是一个一维数组,用来存储数据元素。

在这个实验中,我们主要实现顺序表的插入操作和删除操作。

插入操作是指将一个新的数据元素插入到顺序表的某个位置;删除操作是指在顺序表中删除某个位置的数据元素。

实验步骤如下: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)。

顺序表是一种简单高效的数据结构,适用于元素数量固定且频繁进行插入、删除和遍历操作的场景。

C语言程序设计 实验报告1--顺序结构

C语言程序设计 实验报告1--顺序结构

福建农林大学金山学院实验报告系(教研室):专业:年级:实验课程: C语言程序设计姓名:学号:实验室号:_ 计算机号:实验时间:指导教师签字:成绩:实验1:顺序结构程序设计一、实验目的和要求1.了解Visual C++ 6.0/DEV_C++的基本操作方法2.掌握C程序设计的基本步骤:编辑、编译、连接和运行3.掌握各种类型数据的输入输出方法4.能够编写一个简单的程序二、实验内容和原理1. 输入并运行一个简单、正确的程序。

# include <stdio.h>int main( ){printf ("This is a c program!\n");return 0;}2. 要使下面程序的输出语句在屏幕上显示:A,B,34,则从键盘输入的数据格式应为AB34__________ 。

#include<stdio.h>int main(){char a, b;int c;scanf("%c%c%d",&a,&b,&c);printf("%c,%c,%d\n",a,b,c);return0;问题1:要使上面程序的键盘输入数据格式为a=A,b=B,34,输出语句在屏幕上显示的结果也为A,B,34,则应修改程序中的哪条语句?怎样修改?scanf( “a=%c,b=%c,%d”,&a,&b,&c );问题 2:要使上面程序的键盘输入数据格式为A,B,34,而输出语句在屏幕上显示的结果为“A”,“B”,34,则应修改程序中的哪两条语句?怎样修改?scanf( “%c,%c,%d”,&a,&b,&c);printf(“\”%c\”,\”%c\”,%d\n”,a,b,c);3、编程求一个圆的周长和面积。

用scanf输入圆半径,输出保留两位小数。

4、输入一个华氏温度F,要求输出摄氏温度C。

顺序表的操作实验报告

顺序表的操作实验报告

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

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

二、实验目的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),因为需要将原有元素复制到新的更大的空间中。

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

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

【结构】c语言顺序结构实验报告

【结构】c语言顺序结构实验报告

【关键字】结构c语言顺序结构实验报告篇一:实验三顺序结构程序设计实验报告实验三顺序结构程序设计实验报告一、实验目的1. 掌握掌握赋值语句的使用方法。

2. 各种类型数据的输入输出的方法,能正确使用各种格式转换符。

3. 进一步掌握编写程序和调试程序的方法。

2、实验内容(源代码)1. sy3-(1) ①#includeint main() { int a,b;//基本整型float d,e; //单精度浮点型char c1,c2;//字符型double f,g;//双精度浮点型long m,n; //长整型unsigned int p,q;//"unsiguld"改成"unsigned" 无符号整型a=61,b=62; c1='a';c2='b';//'a''b'的"'"不能掉了d=3.56;e=-6.87; //d,e之间用";"隔开f=3157.890121;g=0.9; m=50000;n=-60000; p=32768;q=40000; printf("a=%d,b=%d\nc1=%c,c2=%c\nd=%6.2f,e=%6.2f\n",a,b,c1,c2,d,e);//"""与"a"之间的","不能掉了,"\"不能写成"/" printf("f=%15.6f,g=%15.12f\nm=%1d,n=%1d\np=%u,q=%u\n",f,g,m,n,p,q); //f后的q改为g}③#includeint main() {int a,b;//基本整型float d,e; //单精度浮点型char c1,c2;//字符型double f,g;//双精度浮点型long m,n; //长整型unsigned int p,q;//"unsiguld"改成"unsigned" 无符号整型a=61,b=62;c1=a;c2=b; //c1,c2之间用&quot;;"隔开f=3157.890121;g=0.9; d=f;e=g;p=a=m=50000;q=b=n=-60000;printf("a=%d,b=%d\nc1=%c,c2=%c\nd=%6.2f,e=%6.2f\n",a,b,c1,c2,d,e);//"""与"a"之间的","不能掉了,"\"不能写成"/"printf("f=%15.6f,g=%15.12f\nm=%1d,n=%1d\np=%u,q=%u\n",f,g,m,n,p,q); //f后的q改为g④#includeint main() {int a,b;//基本整型float d,e; //单精度浮点型char c1,c2;//字符型double f,g;//双精度浮点型long m,n; //长整型unsigned int p,q;//"unsiguld"改成"unsigned" 无符号整型a=61,b=62;c1=a;c2=b; //c1,c2之间用";"隔开f=3157.890121;g=0.9; d=f;e=g;p=a=m=50000;q=b=n=-60000;printf("a=%d,b=%d\nc1=%d,c2=%d\nd=%d,e=%d\n",sizeof(a),sizeof(b),sizeof(c1),sizeof(c2),sizeof (d),sizeof(e));printf("f=%d,g=%d\nm=%d,n=%d\np=%d,q=%d\n",sizeof(f),sizeof(g),sizeof(m),sizeof(n),sizeof(p), sizeof(q));}2. sy3-(2)#include int main() {float h,r,c,s1,s2,v1,v2; //定义float pi=3.1415926; //赋值printf("圆半径r=,圆柱高h=:");//提示scanf("%f,%f",&r,&h); //输入c=2*pi*r; //计算s1=pi*r*r;//"*"不可省略s2=4*s1;v1=4.0/3.0*s1*r; v2=s1*h;printf("圆周长:c=%6.2f\n",c); //输出printf("圆面积:s1=%6.2f\n",s1);printf("圆球表面积:s2=%6.2f\n",s2); printf("圆球体积:v1=%6.2f\n",v1); printf("圆柱体积:v2=%6.2f\n",v2); return 0;}3. sy3-(3)#include#include //不要忘了数学函数int main() {float p,r5,r3,r2,r1,r0,p1,p2,p3,p4,p5; //定义p=1000;//赋值printf("r5=,r3=,r2=,r1=,r0=:");//提示scanf("%f,%f,%f,%f,%f",&r5,&r3,&r2,&r1,&r0); //输入p1=p*r5*5; //计算}p2=p*(1+2*r2)*(1+3*r3)-p; p3=p*(1+3*r3)*(1+2*r2)-p; p4=p*pow(1+r1,5)-p; p5=p*pow(1+r0/4,20)-p;printf("方案1的利息:p1=%f\n",p1); //输出printf("方案2的利息:p2=%f\n",p2); printf("方案3的利息:p3=%f\n",p3); printf("方案4的利息:p4=%f\n",p4); printf("方案5的利息:p5=%f\n",p5); return 0;4. sy3-(4)① #include int main() {char c1='C',c2='h',c3='i',c4='n',c5='a';//定义与赋值c1=c1+4;//计算c2=c2+4; c3=c3+4; c4=c4+4; c5=c5+4;printf("用printf语句输出结果为:");//提示printf("%c%c%c%c%c\n",c1,c2,c3,c4,c5);//输出c1,c2之间的","不可省略printf("用putchar语句输出结果为:");//提示putchar(c1);//输出putchar(c2); putchar(c3); putchar(c4); putchar(c5);printf("\n");//换行不要省略return 0;② #include int main(){ }char c1='T',c2='o',c3='d',c4='a',c5='y';//定义与赋值c1=c1-22;//计算c2=c2-22; c3=c3-22; c4=c4-22; c5=c5-22;printf("用printf语句输出结果为:");//提示printf("%c%c%c%c%c\n",c1,c2,c3,c4,c5);//输出c1,c2之间的","不可省略printf("用putchar语句输出结果为:");//提示putchar(c1);//输出putchar(c2); putchar(c3); putchar(c4); putchar(c5);printf("\n");//换行不要省略return 0;③ #include int main(){char c1='T',c2='o',c3='d',c4='a',c5='y';//定义与赋值c1=c1-4;//计算c2=c2-4; c3=c3-4; c4=c4-4; c5=c5-4;printf("用printf语句输出结果为:");//提示printf("%c%c%c%c%c\n",c1,c2,c3,c4,c5);//输出c1,c2之间的","不可省略printf("用putchar语句输出结果为:");//提示putchar(c1);//输出putchar(c2); putchar(c3); putchar(c4); putchar(c5);printf("\n");//换行不要省略return 0;}篇二:C语言实验二程序、总结顺序结构与输入、输出方法实验二顺序结构与输入/输出方法1 学会使用C的有关算术运算符,以及包含这些运算符的表达式,特别是自增减运算符的使用。

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

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

顺序表的建立与基本操作实验报告
实验目的:
1、理解顺序表的概念和工作机制。

2、掌握顺序表的建立方法和基本操作。

实验仪器:
1、计算机
2、编程软件
实验原理:
顺序表是一种线性结构,它可以用一段地址连续的存储单元依次存储线性表中的数据元素。

其中,数据元素在存储区中的位置是按其逻辑次序依次存放的。

实验步骤:
1、定义顺序表结构体。

顺序表的结构体包含两个元素:顺序表存储的数据和顺序表存储的长度。

2、初始化顺序表。

初始化顺序表其实就是将顺序表长度设为0。

3、增加数据元素。

当往顺序表中增加元素时,需要先判断顺序表中是否还有剩余的可存储空间,如果没有,需要扩展顺序表空间。

4、删除数据元素。

删除顺序表中的元素时,需要先判断该元素是否在顺序表中存在,然后将该元素后面的元素依次往前移动一位。

5、查找数据元素。

查找顺序表中的元素时,需要先判断该元素是否在顺序表中存在,然后返回该元素在顺序表中的下标。

实验结果:
根据以上步骤和原理,我们创建了一个简单的顺序表程序。

通过该程序的运行,我们可以看到以下结果:
1、创建了一个长度为0的顺序表。

2、在顺序表中增加了8个整数数据。

3、删除了顺序表中下标为2的元素。

4、查找了顺序表中值为7的元素并返回其下标。

结论:
通过这次实验,我们掌握了顺序表的建立方法和基本操作。

顺序表在实际编程中十分常见,因此这次实验为我们今后的编程实践提供了有用的知识和工具。

顺序表实验报告

顺序表实验报告

顺序表实验报告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语言和数据结构的应用能力。

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

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

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

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

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

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

二、实验内容。

1. 初始化顺序表。

2. 插入元素。

3. 删除元素。

4. 查找元素。

5. 修改元素。

6. 输出顺序表。

三、实验步骤。

1. 初始化顺序表。

在本实验中,我们使用C语言来实现顺序表的基本操作。

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

然后,我们通过动态内存分配来创建一个顺序表,并初始化表长为0。

2. 插入元素。

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

在实验中,我们需要编写插入元素的函数,通过移动元素位置来实现插入操作。

具体步骤包括,先判断插入位置是否合法,然后将插入位置后的元素依次向后移动一个位置,最后将新元素插入到指定位置。

3. 删除元素。

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

实验中,我们需要编写删除元素的函数,同样也是通过移动元素位置来实现删除操作。

具体步骤包括,先判断删除位置是否合法,然后将删除位置后的元素依次向前移动一个位置,最后将表长减1。

4. 查找元素。

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

实验中,我们需要编写查找元素的函数,通过遍历顺序表中的元素来实现查找操作。

具体步骤包括,遍历顺序表中的元素,逐个比较元素的数值,找到目标元素后返回其位置。

5. 修改元素。

修改元素是指将顺序表中指定位置的元素进行修改。

实验中,我们需要编写修改元素的函数,通过直接修改指定位置的元素值来实现修改操作。

具体步骤包括,先判断修改位置是否合法,然后直接修改指定位置的元素值。

6. 输出顺序表。

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

实验中,我们需要编写输出顺序表的函数,通过遍历顺序表中的元素来实现输出操作。

具体步骤包括,遍历顺序表中的元素,逐个输出元素的数值。

四、实验结果。

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

数据结构实验报告(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语言程序设计实践综合题目:顺序表基本算法班级:姓名:同组人员:提交日期:一、程序功能: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;}实验结果:经过上述实验操作,成功实现了顺序表的初始化、插入、删除、查找、修改、清空等操作,并能够正确输出结果。

顺序表的实验报告

顺序表的实验报告

顺序表的实验报告顺序表的实验报告一、引言顺序表是一种常见的数据结构,它能够以连续的存储空间来存储数据,并且能够快速地进行插入、删除和查找操作。

在本次实验中,我们将通过实际操作和观察,深入了解顺序表的特点和使用方法。

二、实验目的1. 掌握顺序表的定义和基本操作;2. 熟悉顺序表的插入、删除和查找操作;3. 比较不同操作在顺序表中的时间复杂度。

三、实验内容本次实验主要包括以下几个方面的内容:1. 顺序表的初始化:通过调用初始化函数,创建一个空的顺序表;2. 顺序表的插入操作:向顺序表中插入若干个元素,并观察插入后的顺序表状态;3. 顺序表的删除操作:从顺序表中删除指定位置的元素,并观察删除后的顺序表状态;4. 顺序表的查找操作:查找指定元素在顺序表中的位置,并观察查找结果。

四、实验步骤1. 初始化顺序表:调用初始化函数,创建一个空的顺序表;2. 插入操作:依次向顺序表中插入元素,观察插入后的顺序表状态;3. 删除操作:从顺序表中删除指定位置的元素,观察删除后的顺序表状态;4. 查找操作:查找指定元素在顺序表中的位置,观察查找结果。

五、实验结果与分析通过实验操作和观察,我们得到了以下实验结果:1. 初始化顺序表后,顺序表为空,长度为0;2. 在插入操作中,我们成功向顺序表中插入了若干个元素,并且顺序表的长度随之增加;3. 在删除操作中,我们成功删除了指定位置的元素,并且顺序表的长度随之减少;4. 在查找操作中,我们成功找到了指定元素在顺序表中的位置,并且返回了正确的结果。

根据实验结果,我们可以得出以下结论:1. 顺序表的插入和删除操作都能够在常数时间内完成,时间复杂度为O(1);2. 顺序表的查找操作的时间复杂度为O(n),其中n为顺序表的长度。

六、实验总结通过本次实验,我们深入了解了顺序表的定义、基本操作以及时间复杂度。

顺序表作为一种常见的数据结构,在实际应用中具有广泛的用途。

掌握了顺序表的使用方法,我们能够更加高效地处理各种数据操作。

c语言顺序结构程序实验报告

c语言顺序结构程序实验报告

c语言顺序结构程序实验报告C语言顺序结构程序实验报告引言:C语言作为一种高级编程语言,具有广泛的应用领域。

在本次实验中,我们将学习和实践C语言中的顺序结构程序设计。

通过编写一系列的实验程序,我们将深入了解顺序结构的概念和原理,并掌握如何使用C语言编写简单的顺序结构程序。

实验目的:1. 了解顺序结构程序的概念和特点;2. 掌握C语言中的基本数据类型和变量的声明;3. 学习使用C语言中的输入输出函数;4. 熟悉C语言中的基本运算符和表达式;5. 掌握C语言中的条件语句和循环语句的使用。

实验步骤:1. 实验程序一:计算圆的面积和周长首先,我们需要声明一个常量PI,并定义一个变量radius用于存储圆的半径。

然后,通过输入函数获取用户输入的半径值,并使用相应的公式计算圆的面积和周长。

最后,通过输出函数将计算结果显示在屏幕上。

2. 实验程序二:华氏温度转换为摄氏温度在这个实验中,我们需要定义一个变量fahrenheit用于存储华氏温度的值。

然后,通过输入函数获取用户输入的华氏温度,并使用相应的公式将其转换为摄氏温度。

最后,通过输出函数将转换后的摄氏温度显示在屏幕上。

3. 实验程序三:判断一个数是否为偶数在这个实验中,我们需要定义一个变量num用于存储用户输入的数值。

然后,通过输入函数获取用户输入的数值,并使用条件语句判断该数是否为偶数。

最后,通过输出函数将判断结果显示在屏幕上。

4. 实验程序四:计算1到n的累加和在这个实验中,我们需要定义一个变量n用于存储用户输入的数值。

然后,通过输入函数获取用户输入的数值,并使用循环语句计算1到n的累加和。

最后,通过输出函数将计算结果显示在屏幕上。

实验结果与分析:通过以上实验程序的编写和运行,我们成功实现了顺序结构程序的设计。

在实验程序一中,我们计算了圆的面积和周长,通过输入函数获取用户输入的半径值,并使用相应的公式计算出了圆的面积和周长。

在实验程序二中,我们将华氏温度转换为摄氏温度,通过输入函数获取用户输入的华氏温度,并使用相应的公式将其转换为摄氏温度。

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. 掌握顺序表的插入操作;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```通过测试,我们可以验证查找操作的正确性和时间复杂度。

C语言程序设计 实验报告1--顺序结构

C语言程序设计 实验报告1--顺序结构

C语言程序设计实验报告1--顺序结构实验目的1. 熟练掌握C语言的基础语法。

2. 掌握常见的控制语句及操作符的使用方法。

3. 加深对顺序结构的理解与掌握,提升使用主函数的能力。

实验原理C语言程序的结构可以分为顺序结构、选择结构、循环结构等几个部分,顺序结构是整个程序的基础。

顺序结构指程序按照一定的顺序依次执行,即按照程序中的语句顺序逐条执行。

主函数是整个C语言程序的入口,也就是程序从这里开始执行。

主函数由两部分组成:主体部分和返回值。

其中主体部分是程序真正的内容,而返回值是程序执行后返回给操作系统的值。

C语言中的控制语句包括条件语句和循环语句。

条件语句主要有if语句和switch语句,循环语句有while、do while和for语句。

操作符用于对数据进行加减乘除等运算,常见的操作符有加号、减号、乘号、除号等。

实验内容1. 编写一个C程序,计算两个整数的和、差、积、商,要求在屏幕上输出计算过程和结果。

```C#include <stdio.h> //包含标准输入输出库2. 编写一个C程序,输入一个圆形的半径,计算该圆形的面积和周长。

3. 编写一个C程序,输入两个不同的整数,比较它们的大小并输出结果。

实验总结本次实验主要学习了C语言的基础语法和顺序结构的操作方法。

顺序结构指的是程序按照一定的顺序依次执行,本次实验中我们通过各种实例锻炼了掌握顺序结构的能力。

同时,我们还学习了控制语句和操作符的使用,这些是编写复杂程序的必备知识点。

在编写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 <stdio.h>
#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.如何用程序实现将两个不同的顺序表复制到一个顺序表中?。

相关文档
最新文档