数据结构-顺序表的查找实验报告

合集下载

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

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

数据结构实验一顺序表实验报告
数据结构是计算机科学中的一门基础课程,在学习数据结构的过程中,顺序表是我们必须深入了解和掌握的重要数据结构之一。

在实验一中,我们对顺序表进行了一系列的操作,实现了增删改查等基本操作。

我们先来介绍一下顺序表的基本概念。

顺序表是将线性表中的数据存储在一段连续的存储空间中的数据结构,其查找效率高,但插入和删除操作效率较低。

顺序表需要预先分配一定的存储空间,当存储空间不足时需要进行动态扩容,即重新申请更大的存储空间并将原有数据复制到新的存储空间中。

在实验中,我们首先学习了顺序表的实现方式,包括顺序表的结构体定义、创建顺序表、插入元素、删除元素、修改元素以及查询元素等基本操作。

我们通过 C 语言来实现了这些操作,并将其封装成一个顺序表的 API,使其更加易于使用和维护。

在实验过程中,我们还发现顺序表中数据的存储顺序非常重要,因为顺序表中元素的存储顺序与元素的下标是一一对应的,如果存储的顺序错误,可能会导致元素的下标与我们想象中的不一致,从而造成一些意想不到的结果。

总的来说,实验一帮助我们更深入地了解了顺序表的实现方式和基本操作,同时也挖掘出了一些潜在问题,这对于我们今后的学习和实践都起到了很大的帮助。

数据结构与算法实验报告5-查找与排序

数据结构与算法实验报告5-查找与排序

北京物资学院信息学院实验报告
课程名_数据结构与算法
实验名称查找与排序
实验日期年月日实验报告日期年月日姓名______ ___ 班级_____ ________ 学号___
一、实验目的
1.掌握线性表查找的方法;
2.了解树表查找思想;
3.掌握散列表查找的方法.
4.掌握插入排序、交换排序和选择排序的思想和方法;
二、实验内容
查找部分
1.实现顺序查找的两个算法(P307), 可以完成对顺序表的查找操作, 并根据查到和未查到两种情况输出结果;
2.实现对有序表的二分查找;
3.实现散列查找算法(链接法),应能够解决冲突;
排序部分
4.分别实现直接插入排序、直接选择排序、冒泡排序和快速排序算法
三、实验地点与环境
3.1 实验地点
3.2实验环境
(操作系统、C语言环境)
四、实验步骤
(描述实验步骤及中间的结果或现象。

在实验中做了什么事情, 怎么做的, 发生的现象和中间结果, 给出关键函数和主函数中的关键段落)
五、实验结果
六、总结
(说明实验过程中遇到的问题及解决办法;个人的收获;未解决的问题等)。

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

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

实验报告课程数据结构及算法实验项目 1.顺序表的建立和基本运算成绩专业班级*** 指导教师***姓名*** 学号*** 实验日期***实验一顺序表的建立和基本运算一、实验目的1、掌握顺序表存储结构的定义及C/C++语言实现2、掌握顺序表的各种基本操作及C/C++语言实现3、设计并实现有序表的遍历、插入、删除等常规算法二、实验环境PC微机,Windows,DOS,Turbo C或者Visual C++三、实验内容1、顺序表的建立和基本运算(1)问题描述顺序表时常进行的运算包括:创建顺序表、销毁顺序表、求顺序表的长度、在顺序表中查找某个数据元素、在某个位置插入一个新数据元素、在顺序表中删除某个数据元素等操作。

试编程实现顺序表的这些基本运算。

(2)基本要求实现顺序表的每一个运算要求用一个函数实现。

(3)算法描述参见教材算法2.3、算法2.4、算法2.5等顺序表的常规算法。

(4)算法实现#include<malloc.h> // malloc()等#include<stdio.h> // NULL, printf()等#include<process.h> // exit()// 函数结果状态代码#define OVERFLOW -2#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1typedef int Status; // Status是函数的类型,其值是函数结果状态代码,如OK等typedef int Boolean; // Boolean是布尔类型,其值是TRUE或者FALSE//-------- 线性表的动态分配顺序存储结构-----------#define LIST_INIT_SIZE 10 // 线性表存储空间的初始分配量#define LIST_INCREMENT 2 // 线性表存储空间的分配增量typedef int ElemType;struct SqList{ElemType *elem; // 存储空间基址int length; // 当前长度int listsize; // 当前分配的存储容量(以sizeof(int)为单位)};void InitList(SqList &L) // 算法2.3{ // 操作结果:构造一个空的顺序线性表LL.elem=new ElemType[LIST_INIT_SIZE];if(!L.elem)exit(OVERFLOW); // 存储分配失败L.length=0; // 空表长度为0L.listsize=LIST_INIT_SIZE; // 初始存储容量}void DestroyList(SqList &L){ // 初始条件:顺序线性表L已存在。

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

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

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

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

数据结构查找实验报告

数据结构查找实验报告

数据结构查找实验报告一、实验目的本次实验的主要目的是深入理解和掌握常见的数据结构查找算法,包括顺序查找、二分查找、哈希查找等,并通过实际编程实现和性能比较,分析它们在不同数据规模和分布情况下的效率和适用场景。

二、实验环境本次实验使用的编程语言为 Python 38,开发环境为 PyCharm。

实验中所使用的数据集生成工具为 numpy 库。

三、实验原理1、顺序查找顺序查找是一种最简单的查找算法,它从数据结构的开头依次逐个比较元素,直到找到目标元素或遍历完整个数据结构。

其平均时间复杂度为 O(n)。

2、二分查找二分查找要求数据结构是有序的。

通过不断将查找区间缩小为原来的一半,直到找到目标元素或者确定目标元素不存在。

其时间复杂度为 O(log n)。

3、哈希查找哈希查找通过将元素映射到一个特定的哈希表中,利用哈希函数计算元素的存储位置,从而实现快速查找。

理想情况下,其平均时间复杂度为 O(1),但在存在哈希冲突时,性能可能会下降。

四、实验步骤1、数据集生成使用 numpy 库生成不同规模和分布的数据集,包括有序数据集、无序数据集和具有一定重复元素的数据集。

2、顺序查找实现编写顺序查找算法的函数,接受数据集和目标元素作为参数,返回查找结果(是否找到及查找次数)。

3、二分查找实现实现二分查找算法的函数,同样接受数据集和目标元素作为参数,并返回查找结果。

4、哈希查找实现构建哈希表并实现哈希查找函数,处理哈希冲突的情况。

5、性能比较对不同规模和类型的数据集,分别使用三种查找算法进行查找操作,并记录每种算法的查找时间和查找次数。

五、实验结果与分析1、顺序查找在无序数据集中,顺序查找的性能表现较为稳定,查找时间随着数据规模的增大线性增长。

但在有序数据集中,其性能没有优势。

2、二分查找二分查找在有序数据集中表现出色,查找时间随着数据规模的增大增长缓慢,体现了对数级别的时间复杂度优势。

然而,在无序数据集中无法使用。

数据结构实验报告七_顺序查找

数据结构实验报告七_顺序查找

实验七顺序查找一、实验目的1.掌握顺序查找操作的算法实现。

二、实验平台操作系统:Windows7或Windows XP开发环境:JA V A三、实验内容及要求1.建立顺序查找表,并在此查找表上实现顺序查找操作。

四、实验的软硬件环境要求硬件环境要求:PC机(单机)使用的软件名称、版本号以及模块:Netbeans 6.5以上或Eclipse、MyEclipse等编程环境下。

五、知识准备前期要求掌握查找的含义和顺序查找操作的方法。

六、验证性实验1.实验要求编程实现如下功能:(1)根据输入的查找表的表长n和n个关键字值,建立顺序查找表,并在此查找表中用顺序查找方法查找给定关键值的记录,最后输出查找结果。

2. 实验相关原理:查找表分别静态查找表和动态查找表两种,其中只能做引用操作的查找表称为静态查找表。

静态查找表采用顺序存储结构,待查找的记录类可描述如下:public class RecordNode {private Comparable key; //关键字private Object element; //数据元素……}待排序的顺序表类描述如下:public class SeqList {private RecordNode[] r; //顺序表记录结点数组private int curlen; //顺序表长度,即记录个数// 顺序表的构造方法,构造一个存储空间容量为maxSize的顺序表public SeqList(int maxSize) {this.r = new RecordNode[maxSize]; // 为顺序表分配maxSize个存储单元this.curlen = 0; // 置顺序表的当前长度为0}……}【核心算法提示】查找操作是根据给定的某个值,在查找表中确定一个其关键字等于给定值的数据元素或记录的过程。

若查找表中存在这样一个记录,则称“查找成功”。

查找结果给出整个记录的信息,或指示该记录在查找表中的位置;若在查找表中不存在这样的记录,则称“查找不成功”。

顺序查找法实验报告

顺序查找法实验报告

一、实验目的1. 理解顺序查找法的原理和过程。

2. 掌握顺序查找法的实现方法。

3. 通过实验验证顺序查找法的效率和适用场景。

二、实验环境1. 操作系统:Windows 102. 编程语言:Python3.83. 实验数据:一组随机生成的整数序列三、实验原理顺序查找法是一种简单的查找算法,其基本思想是从线性表的第一个元素开始,逐个比较,直到找到待查找的元素或者比较到序列的末尾。

如果找到待查找的元素,则返回该元素的位置;如果比较到序列的末尾仍未找到,则返回-1表示查找失败。

顺序查找法的时间复杂度为O(n),空间复杂度为O(1),适用于数据量较小或者无序的线性表。

四、实验步骤1. 导入Python的random模块,用于生成随机整数序列。

2. 定义一个顺序查找函数,接收线性表和待查找元素作为参数。

3. 在主函数中,生成一个随机整数序列,并设置待查找元素。

4. 调用顺序查找函数,并输出查找结果。

五、实验代码```pythonimport randomdef sequential_search(arr, target):for i in range(len(arr)):if arr[i] == target:return ireturn -1def main():# 生成随机整数序列arr = [random.randint(1, 100) for _ in range(20)] print("随机整数序列:", arr)# 设置待查找元素target = random.randint(1, 100)print("待查找元素:", target)# 调用顺序查找函数result = sequential_search(arr, target)# 输出查找结果if result != -1:print("查找成功,元素位置:", result)else:print("查找失败")if __name__ == "__main__":main()```六、实验结果与分析1. 运行实验程序,生成随机整数序列和待查找元素。

数据结构查找算法实验报告

数据结构查找算法实验报告

数据结构查找算法实验报告一、实验目的本次实验的主要目的是深入理解和掌握常见的数据结构查找算法,包括顺序查找、二分查找、哈希查找等,并通过实际编程实现和性能分析,比较它们在不同数据规模和分布情况下的效率和优劣。

二、实验环境操作系统:Windows 10编程语言:Python 3x开发工具:PyCharm三、实验原理1、顺序查找顺序查找是一种最简单的查找算法,从数据结构的起始位置开始,依次比较每个元素,直到找到目标元素或遍历完整个数据结构。

其时间复杂度在最坏情况下为 O(n),平均情况下也接近 O(n)。

2、二分查找二分查找要求数据结构是有序的。

通过不断将查找区间缩小为原来的一半,直到找到目标元素或者确定目标元素不存在。

其时间复杂度为 O(log n)。

3、哈希查找哈希查找通过哈希函数将关键字映射到一个特定的位置,如果发生冲突则通过相应的解决冲突策略进行处理。

在理想情况下,其时间复杂度可以接近 O(1)。

四、实验内容及步骤1、顺序查找算法实现```pythondef sequential_search(arr, target):for i in range(len(arr)):if arri == target:return ireturn -1```2、二分查找算法实现```pythondef binary_search(arr, target):low = 0high = len(arr) 1while low <= high:mid =(low + high) // 2if arrmid == target:return midelif arrmid < target:low = mid + 1else:high = mid 1return -1```3、哈希查找算法实现(采用简单的线性探测解决冲突)```pythonclass HashTable:def __init__(self):selfsize = 10selftable = None selfsizedef hash_function(self, key):return key % selfsizedef insert(self, key):index = selfhash_function(key)while selftableindex is not None:index =(index + 1) % selfsize selftableindex = keydef search(self, key):index = selfhash_function(key)original_index = indexwhile selftableindex is not None:if selftableindex == key:return indexindex =(index + 1) % selfsizeif index == original_index:return -1return -1```4、生成不同规模和分布的数据进行测试```pythonimport random生成有序数据def generate_sorted_data(size):return i for i in range(size)生成随机分布数据def generate_random_data(size):return randomrandint(0, size 10) for _ in range(size)```5、性能测试与分析```pythonimport time测试不同算法在不同数据上的查找时间def test_search_algorithms(data, target):start_time = timetime()sequential_search(data, target)sequential_time = timetime() start_timestart_time = timetime()binary_search(sorted(data), target)binary_time = timetime() start_timeht = HashTable()for num in data:htinsert(num)start_time = timetime()htsearch(target)hash_time = timetime() start_timereturn sequential_time, binary_time, hash_time 进行多组实验并取平均值def perform_experiments():sizes = 100, 500, 1000, 5000, 10000 sequential_avg_times =binary_avg_times =hash_avg_times =for size in sizes:sequential_times =binary_times =hash_times =for _ in range(10):进行 10 次实验取平均值sorted_data = generate_sorted_data(size)random_data = generate_random_data(size)target = randomchoice(sorted_data)sequential_time, binary_time, hash_time =test_search_algorithms(random_data, target)sequential_timesappend(sequential_time)binary_timesappend(binary_time)hash_timesappend(hash_time)sequential_avg_timesappend(sum(sequential_times) /len(sequential_times))binary_avg_timesappend(sum(binary_times) / len(binary_times))hash_avg_timesappend(sum(hash_times) / len(hash_times))return sizes, sequential_avg_times, binary_avg_times, hash_avg_times sizes, sequential_avg_times, binary_avg_times, hash_avg_times =perform_experiments()```五、实验结果与分析通过对不同规模数据的实验,得到了以下平均查找时间的结果:|数据规模|顺序查找平均时间|二分查找平均时间|哈希查找平均时间|||||||100|0000123 秒|0000008 秒|0000005 秒||500|0000567 秒|0000021 秒|0000007 秒||1000|0001234 秒|0000035 秒|0000008 秒||5000|0005789 秒|0000123 秒|0000012 秒||10000|0012345 秒|0000234 秒|0000015 秒|从结果可以看出,在数据规模较小时,顺序查找和哈希查找的性能差距不大,二分查找由于需要先对数据进行排序,所以优势不明显。

顺序表的查找插入与删除实验报告

顺序表的查找插入与删除实验报告

顺序表的查找插入与删除实验报告顺序表的查找、插入与删除实验报告《数据结构》实验报告一学院:班级:姓名:程序名学号:日期:一、上机实验的问题和要求:顺序表的搜寻、填入与删掉。

设计算法,同时实现线性结构上的顺序表的产生以及元素的搜寻、填入与删掉。

具体内容同时实现建议: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。

数据结构顺序表实验报告

数据结构顺序表实验报告

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

操作环境: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;}运行截图创建查找插入删除。

数据结构实验报告顺序表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.上机题目:顺序表实验2.需求分析实现顺序表的建立、输出、查找、插入、删除、合并几项功能。

明确说明程序的开发环境和功能要求。

针对主要功能,给出如下说明:(1)输入参数的格式和合法取值范围输入参数范围输入格式菜单选择数字 0—6, getche()接受键盘上对应的按钮数据输入 0—9999 scanf(“%s”,data)程序是否执行 y n getche()接受键盘上对应按键(2)输出的格式输出参数输出格式文字输出 printf(“******”);数据输出 printf(“%d”,data[i])(3)测试数据能够完成顺序表的建立、输出、查找、插入、删除、合并几项功能。

********************************* 1.建立一个顺序表 ** 2.输出一个顺序表 ** 3.在顺序表中查找 ** 4.向顺序表中插入一个元素 ** 5.删除顺序表中的一个元素 ** 6.将两个顺序表合并 ** 0.退出 *********************************(4)开发环境Vc6.03.详细设计(1)确定存储结构,并给出所用数据类型的数据结构定义采用顺序表存储的线性表。

利用内存中的一片起始位置确定的连续存储区域来存放表中的所以元素。

可以根据需要对表中的任何数据元素进行访问,元素的插入,删除可以在表中任何位置进行。

typedef struct {ElemType data[MAXSIZE];int length;}SqList;(2)给出所用数据类型中每个操作的伪码算法A.初始化建立的顺序表Void InitList(SqList &L)置 L.length 为 0B.建立新的顺序表Void CreatSqlist(SqList &L,int n)开辟一个数据结构空间,容量是MAXSIZEif str 是四位正整数记录else重新输入正确值C.输出顺序表int Output(SqList L)if L.length 等于 0return 0elsereturn 1D. 在顺序表中按位置取值int GetElem(SqList L,int i)if 取值不在线性表范围内return -9999;elsereturn L.data[i];E.在顺序表中按位置取值int LocateElem(SqList L,ElemType x)While x=L.data[k]if(k<L.length)return k;elsereturn -1;F.在i处插入元素int Insert(SqList &L,ElemType x,int i)if 不在k的范围内插入return 0;else在 i处插入元素return 1;G.在i处删除元素int Delete(SqList &L,int i)if i不在L.length范围内return 0;else删除i处的元素return 1;H. 合并la lb两个顺序表Void MergeList(SqList la,SqList lb,SqList &lc) la,lb升序排序la先存在lclb再存在lc4.调试分析(1)调试过程中主要遇到哪些问题?是如何解决的?A.在程序结束时如果按书上的代码printf("继续执行吗Y(1)/N(0): ");scanf("%d",&k);if(!k)return;只要不输入0都会继续执行代码,所以我想让此时的程序只识别 y 和 n 两个按键通过查找 y的键盘值是 0x0079N的键盘值是 0x006e通过 key=getche(),判断key的值来决定标志位的值来。

顺序表的实验报告

顺序表的实验报告

顺序表的实验报告顺序表的实验报告一、引言顺序表是一种常见的数据结构,它可以用来存储一组具有相同数据类型的元素,并且这些元素在内存中是连续存储的。

在本次实验中,我们将通过编写一个简单的顺序表程序来深入了解顺序表的原理和使用方法。

二、实验目的1. 掌握顺序表的基本概念和特点;2. 熟悉顺序表的操作,包括插入、删除、查找等;3. 理解顺序表的存储结构和算法。

三、实验过程1. 定义顺序表结构首先,我们需要定义一个顺序表的结构。

顺序表由两部分组成:一个数组用于存储元素,一个变量用于记录当前元素个数。

我们可以使用C语言的结构体来定义顺序表结构:```c#define MAX_SIZE 100 // 定义顺序表的最大容量typedef struct {int data[MAX_SIZE]; // 用数组存储元素int length; // 记录当前元素个数} SeqList;```2. 初始化顺序表在使用顺序表前,我们需要对其进行初始化,即将长度置为0。

可以编写一个初始化函数来完成这个操作:```cvoid init(SeqList *list) {list->length = 0;}```3. 插入元素顺序表的插入操作是将一个元素插入到指定位置上,并将后面的元素依次后移。

我们可以编写一个插入函数来实现这个操作:```cvoid insert(SeqList *list, int position, int value) {if (position < 0 || position > list->length) {printf("插入位置无效!\n");return;}if (list->length >= MAX_SIZE) {printf("顺序表已满,无法插入!\n");return;}for (int i = list->length; i > position; i--) {list->data[i] = list->data[i - 1];}list->data[position] = value;list->length++;}```4. 删除元素顺序表的删除操作是将指定位置上的元素删除,并将后面的元素依次前移。

数据结构实验报告顺序表

数据结构实验报告顺序表

数据结构实验报告顺序表数据结构实验报告:顺序表一、引言数据结构是计算机科学的重要基础,它研究数据的组织方式和操作方法。

顺序表是一种常见的数据结构,它以数组的形式存储数据元素,具有随机访问和插入删除方便的特点。

本实验旨在深入理解顺序表的实现原理和操作方法,并通过实验验证其性能。

二、实验目的1. 掌握顺序表的基本概念和实现原理;2. 熟悉顺序表的插入、删除、查找等操作;3. 分析顺序表的时间复杂度,并进行性能测试。

三、实验过程1. 顺序表的定义和初始化顺序表是一种线性表,它以一组连续的存储单元来存储数据元素。

在实验中,我们使用数组来实现顺序表。

首先,定义一个结构体来表示顺序表,包括数据元素和当前长度等信息。

然后,通过动态分配内存来初始化顺序表。

2. 插入元素顺序表的插入操作是将一个新元素插入到指定位置,同时移动后面的元素。

在实验中,我们可以通过循环将后面的元素依次向后移动,然后将新元素放入指定位置。

3. 删除元素顺序表的删除操作是将指定位置的元素删除,并将后面的元素依次向前移动。

在实验中,我们可以通过循环将后面的元素依次向前移动,然后将最后一个元素置为空。

4. 查找元素顺序表的查找操作是根据指定的值查找元素所在的位置。

在实验中,我们可以通过循环遍历顺序表,逐个比较元素的值,找到匹配的位置。

五、实验结果与分析在实验中,我们通过插入、删除、查找等操作对顺序表进行了测试,并记录了操作所需的时间。

通过分析实验结果,我们可以得出以下结论:1. 顺序表的插入操作的时间复杂度为O(n),其中n为元素的个数。

因为插入操作需要移动后面的元素,所以时间复杂度与元素个数成正比。

2. 顺序表的删除操作的时间复杂度也为O(n),与插入操作相同,需要移动后面的元素。

3. 顺序表的查找操作的时间复杂度为O(n),需要逐个比较元素的值。

六、结论通过本次实验,我们深入理解了顺序表的实现原理和操作方法。

顺序表以数组的形式存储数据,具有随机访问和插入删除方便的特点。

数据结构顺序表操作实验报告

数据结构顺序表操作实验报告

实验1 顺序表的操作一、实验要求1.输入一组整型元素序列,建立顺序表。

2.实现该顺序表的遍历。

3.在该顺序表中进行顺序查找某一元素,查找成功返回1,否则返回0。

4.判断该顺序表中元素是否对称,对称返回1,否则返回0。

5.实现把该表中所有奇数排在偶数之前,即表的前面为奇数,后面为偶数。

6.* 输入整型元素序列利用有序表插入算法建立一个有序表。

7.* 利用算法6建立两个非递减有序表并把它们合并成一个非递减有序表。

8.编写一个主函数,调试上述算法。

二、源代码#include"stdio.h"#include"stdlib.h"#define ElemType int//int类型宏定义#define MAXSIZE 100//顺序结构typedef struct{ElemType elem[MAXSIZE]; //元素数组int length; //当前表长}SqList;//建立顺序表void BuildList(SqList &L){int n;printf("请输入建立顺序表的大小。

n=");scanf("%d",&n);L.length=n;printf("\n开始建立顺序表...\n");for(int i=0;i<L.length;i++)//循环建立顺序表{printf("\n请输入第%d个元素:",i+1);scanf("%d",&L.elem[i]);}printf("\n建立顺序表完毕!...\n");}//遍历顺序表void ShowList(SqList &L){int i;printf("\n开始遍历顺序表...\n");for(i=0;i<L.length;i++)printf("%d ",L.elem[i]);printf("\n遍历结束...\n");}//在顺序表中寻找X元素int FindList(SqList &L,int x){int a=0;for(int i=0;i<L.length;i++){if(L.elem[i]==x)a=1;}if(a==1)printf("1\n");elseprintf("0\n");return 0;}//判断是否对称int Duichen(SqList &L){int j,b=1,n;n=L.length;if(n%2==0){for(j=0;j<n/2;j++){if(L.elem[j]!=L.elem[L.length-j-1])b=0;}}elsefor(j=0;j<(n-1)/2;j++){if(L.elem[j]!=L.elem[L.length-j-1])b=0;}if(b==1)printf("1\n");elseprintf("0\n");return 0;}//前面为奇数,后面为偶数void PaixuList(SqList &L){int i,j,a;for(i=1;i<L.length;i++){if(L.elem[i]%2==1){a=L.elem[i];for(j=i;j>0;j--){L.elem[j]=L.elem[j-1];}L.elem[0]=a;i++;}}for(i=0;i<L.length;i++)printf("%d ",L.elem[i]);printf("\n");}int main(){SqList List;int n;while(1){printf("\n 实验一:顺序表\n");printf("\n******************************************************************");printf("\n 1.创建顺序表");printf("\n 2.遍历顺序表");printf("\n 3.在该顺序表中进行顺序查找某一元素,查找成功返回1,否则返回0");printf("\n 4.判断该顺序表中元素是否对称,对称返回1,否则返回0");printf("\n 5.该表中所有奇数排在偶数之前,即表的前面为奇数,后面为偶数");printf("\n 0.退出");printf("\n******************************************************************\n");printf("\n请输入选择序号:");scanf("%d",&n);switch(n){case 0:return 0;case 1:BuildList(List);break;case 2:ShowList(List);break;case 3:int X;printf("请输入要查找值:X=");scanf("%d",&X);FindList(List,X);break;case 4:Duichen(List);break;case 5:PaixuList(List);break;default:printf(" 请输入数字0-5 \n");}}return 0;}三、运行结果1)程序主界面2)选择1建立顺序表3)选择2遍历顺序表4)选择3查询元素X5)选择4判断是否对称6)选择5奇数在前,偶数在后7)选择0退出。

数据结构顺序表实验报告

数据结构顺序表实验报告

数据结构顺序表实验报告数据结构顺序表实验报告1.实验目的:本实验旨在通过实现顺序表的基本操作,加深对数据结构顺序表的理解,并掌握相关算法的实现方法。

2.实验环境:●操作系统:Windows 10●编程语言:C/C++●开发工具:Visual Studio Code3.实验内容:3.1 初始化顺序表●定义顺序表结构体●实现创建顺序表的函数●实现销毁顺序表的函数3.2 插入元素●实现在指定位置插入元素的函数●实现在表尾插入元素的函数3.3 删除元素●实现删除指定位置元素的函数●实现删除指定值元素的函数3.4 查找元素●实现按值查找元素的函数●实现按位置查找元素的函数3.5 修改元素●实现修改指定位置元素的函数3.6 打印顺序表●实现打印顺序表中所有元素的函数4.实验步骤:4.1 初始化顺序表●定义顺序表结构体,并分配内存空间●初始化顺序表中的数据和长度4.2 插入元素●调用插入元素函数,在指定位置或表尾插入元素4.3 删除元素●调用删除元素函数,删除指定位置或指定值的元素4.4 查找元素●调用查找元素函数,按值或位置查找元素4.5 修改元素●调用修改元素函数,修改指定位置的元素4.6 打印顺序表●调用打印顺序表函数,输出顺序表中的所有元素5.实验结果:经过测试,顺序表的基本操作均能正确执行。

插入元素、删除元素、查找元素、修改元素和打印顺序表等功能都能正常运行。

6.实验总结:本实验通过实现顺序表的基本操作,巩固了对数据结构顺序表的理论知识,并加深了对算法的理解和应用能力。

顺序表是一种简单、易于实现的数据结构,适用于元素数量变化较少的情况下。

7.附件:无8.法律名词及注释:●顺序表:一种基本的线性数据结构,数据元素按照其逻辑位置依次存储在一片连续的存储空间中。

●初始化:为数据结构分配内存空间并进行初始化,使其具备基本的数据存储能力。

●插入元素:将一个新元素插入到已有元素的合适位置,使得数据结构保持有序或符合特定要求。

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

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

数据结构实验一顺序表实验报告数据结构实验一顺序表实验报告一、实验目的顺序表是一种基本的数据结构,本次实验的目的是通过实现顺序表的基本操作,加深对顺序表的理解,并掌握顺序表的插入、删除、查找等操作的实现方法。

二、实验内容1. 实现顺序表的创建和初始化操作。

2. 实现顺序表的插入操作。

3. 实现顺序表的删除操作。

4. 实现顺序表的查找操作。

5. 实现顺序表的输出操作。

三、实验步骤1. 创建顺序表的数据结构,包括数据存储数组和记录当前元素个数的变量。

2. 初始化顺序表,将当前元素个数置为0。

3. 实现顺序表的插入操作:- 判断顺序表是否已满,若已满则输出错误信息。

- 将插入位置之后的元素依次后移一位。

- 将要插入的元素放入插入位置。

- 当前元素个数加一。

4. 实现顺序表的删除操作:- 判断顺序表是否为空,若为空则输出错误信息。

- 判断要删除的位置是否合法,若不合法则输出错误信息。

- 将删除位置之后的元素依次前移一位。

- 当前元素个数减一。

5. 实现顺序表的查找操作:- 遍历顺序表,逐个比较元素值与目标值是否相等。

- 若找到目标值,则返回该元素的位置。

- 若遍历完整个顺序表仍未找到目标值,则返回错误信息。

6. 实现顺序表的输出操作:- 遍历顺序表,逐个输出元素值。

四、实验结果经过实验,顺序表的各项操作均能正确实现。

在插入操作中,可以正确将元素插入到指定位置,并将插入位置之后的元素依次后移。

在删除操作中,可以正确删除指定位置的元素,并将删除位置之后的元素依次前移。

在查找操作中,可以正确返回目标值的位置。

在输出操作中,可以正确输出顺序表中的所有元素。

五、实验总结通过本次实验,我深入了解了顺序表的原理和基本操作,并通过实际编程实现了顺序表的各项功能。

在实验过程中,我遇到了一些问题,如如何判断顺序表是否已满或为空,如何处理插入和删除位置的合法性等。

通过查阅资料和与同学讨论,我解决了这些问题,并对顺序表的操作有了更深入的理解。

数据结构实验报告顺序表

数据结构实验报告顺序表

数据结构实验报告顺序表数据结构实验报告:顺序表摘要:顺序表是一种基本的数据结构,它通过一组连续的存储单元来存储线性表中的数据元素。

在本次实验中,我们将通过实验来探索顺序表的基本操作和特性,包括插入、删除、查找等操作,以及顺序表的优缺点和应用场景。

一、实验目的1. 理解顺序表的概念和特点;2. 掌握顺序表的基本操作;3. 了解顺序表的优缺点及应用场景。

二、实验内容1. 实现顺序表的初始化操作;2. 实现顺序表的插入操作;3. 实现顺序表的删除操作;4. 实现顺序表的查找操作;5. 对比顺序表和链表的优缺点;6. 分析顺序表的应用场景。

三、实验步骤与结果1. 顺序表的初始化操作在实验中,我们首先定义了顺序表的结构体,并实现了初始化操作,即分配一定大小的存储空间,并将表的长度设为0,表示表中暂时没有元素。

2. 顺序表的插入操作接下来,我们实现了顺序表的插入操作。

通过将插入位置后的元素依次向后移动一位,然后将新元素插入到指定位置,来实现插入操作。

我们测试了在表中插入新元素的情况,并验证了插入操作的正确性。

3. 顺序表的删除操作然后,我们实现了顺序表的删除操作。

通过将删除位置后的元素依次向前移动一位,来实现删除操作。

我们测试了在表中删除元素的情况,并验证了删除操作的正确性。

4. 顺序表的查找操作最后,我们实现了顺序表的查找操作。

通过遍历表中的元素,来查找指定元素的位置。

我们测试了在表中查找元素的情况,并验证了查找操作的正确性。

四、实验总结通过本次实验,我们对顺序表的基本操作有了更深入的了解。

顺序表的插入、删除、查找等操作都是基于数组的操作,因此在插入和删除元素时,需要移动大量的元素,效率较低。

但是顺序表的优点是可以随机访问,查找效率较高。

在实际应用中,顺序表适合于元素数量不变或变化不大的情况,且需要频繁查找元素的场景。

综上所述,顺序表是一种基本的数据结构,我们通过本次实验对其有了更深入的了解,掌握了顺序表的基本操作,并了解了其优缺点及应用场景。

(完整word版)数据结构 查找 实验报告(word文档良心出品)

(完整word版)数据结构  查找  实验报告(word文档良心出品)

数据结构实验报告课程数据结构 _ 实验名称查找院系专业班级实验地点姓名学号实验时间指导老师实验成绩批改日期一.实验目的1.熟悉静态查找的相关算法二.实验内容及要求1.实现顺序表的查找算法2.实现有序表的折半查找算法三.实验过程及结果实验过程:源程序:1、顺序查找:#include <stdio.h>#define MAX_SIZE 100typedef struct{int key;}element;element list[MAX_SIZE];int seqsearch(element list[],int searchnum,int num);int main(){int i,num,searchnum,k;printf("请输入元素的个数:");scanf("%d",&num);printf("请输入元素:\n");for(i=0;i<num;i++){scanf("%d",&list[i].key);}while(1){printf("请输入要查询的数据元素:");scanf("%d",&searchnum);k=seqsearch(list,searchnum,num);if(k!=-1){printf("所查询元素的下标为:");printf("%d\n",k);}elseprintf("查询元素不存在。

\n");}return 0;}int seqsearch(element list[],int searchnum,int num) {int j;list[num].key=searchnum;for(j=0;list[j].key!=searchnum;j++);return j<num?j:-1;}2、折半查找:#include <stdio.h>#define MAX_SIZE 100#define COMPARE(a,b) (a)>(b)?1:(a)==(b)?0:-1typedef struct{int key;}element;element list[MAX_SIZE];int binsearch(element list[],int searchnum,int num); int main(){int i,num,searchnum,k;printf("请输入元素的个数:");scanf("%d",&num);printf("请输入元素:\n");for(i=0;i<num;i++){scanf("%d",&list[i].key);}while(1){printf("请输入要查询的数据元素:");scanf("%d",&searchnum);k=binsearch(list,searchnum,num);if(k!=-1){printf("所查询元素的下标为:");printf("%d\n",k);}elseprintf("查询元素不存在。

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

计算机科学与技术系
实验报告
专业名称计算机科学与技术
课程名称《数据结构》
项目名称顺序表查找
班级
学号
姓名
同组人员无
实验日期
一、实验目的与要求:
(简述本次实验要求达到的目的,涉及到的相关知识点,实验的具体要求。

)(一)实验目的:
应用顺序表来实现对数据的查找
(二)实验要求:
用顺序表实现对数据进行查找
(三)实验环境:
VC++6.0.
二、实验内容
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define ERROR 0
#define OK 1
#define INIT_SIZE 5 /*初始分配的顺序表长度*/
#define INCREM 5 /*溢出时,顺序表长度的增量*/ typedef int ElemType; /*定义表元素的类型*/
typedef struct Sqlist{
ElemType *slist; /*存储空间的基地址*/
int length; /*顺序表的当前长度*/
int listsize; /*当前分配的存储空间*/
}Sqlist;
int InitList_sq(Sqlist *L);
int CreateList_sq(Sqlist *L,int n);
int ListInsert_sq(Sqlist *L,int i,ElemType e);
int PrintList_sq(Sqlist *L);
int ListDelete_sq(Sqlist *L,int i);
int ListLocate(Sqlist *L,ElemType e);
//初始化顺序表
int InitList_sq(Sqlist *L){
L->slist=(ElemType*)malloc(INIT_SIZE*sizeof(ElemType));
if(!L->slist) return ERROR;
L->length=0;
L->listsize=INIT_SIZE;
return OK;
}/*InitList*/
//创建顺序表
int CreateList_sq(Sqlist *L,int n){
ElemType e;
int i;
for(i=0;i<n;i++){
printf("input data %d",i+1);
printf(": ");
scanf("%d",&e);
if(!ListInsert_sq(L,i+1,e))
return ERROR;
}
return OK;
}/*CreateList*/
/*输出顺序表中的元素*/
int PrintList_sq(Sqlist *L){
int i;
for(i=1;i<=L->length;i++)
printf("%-5d",L->slist[i-1]);
printf("\n");
return OK;
}/*PrintList*/
//在顺序表中插入
int ListInsert_sq(Sqlist *L,int i,ElemType e){ int k;
if(i<1||i>L->length+1)
return ERROR;
if(L->length>=L->listsize){
L->slist=(ElemType*)realloc(L->slist,
(INIT_SIZE+INCREM)*sizeof(ElemType));
if(!L->slist)
return ERROR;
L->listsize+=INCREM;
}
for(k=L->length-1;k>=i-1;k--){
L->slist[k+1]=k;
}
L->slist[i-1]=e;
L->length++;
return OK;
}/*ListInsert*/
/*在顺序表中删除第i个元素*/
int ListDelete_sq(Sqlist *L,int i)
{
int j;
if(L->length<0){
printf("顺序表为空!\n");
return ERROR;
}
else if(i < 0 || (i > L->length))
{
printf("i 的参数出错!\n");
return ERROR;
}
else
{
for(j = i; j <= L->length; j ++) L->slist[j-1] = L->slist[j];
L->length--;
return OK;
}
}
/*在顺序表中查找指定值元素,返回其序号*/
int ListLocate(Sqlist *L,ElemType e)
{
int i, z = 0;
for(i = 0; i < L->length; i ++)
{
if(L->slist[i] == e)
{
printf("查找的元素%d 在第%d 位置\n", e, i+1);
z = 1;
//return OK;
}
}
printf("没有查找到相应的数\n");
return ERROR;
}
//主函数
int main(){
Sqlist sl;
int n, i;
ElemType e;
printf("请创建表,输入顺序表的元素个数:"); /*输入顺序表的元素个数*/
scanf("%d",&n);
if(n>0){
printf("\n1-Create Sqlist:\n");
InitList_sq(&sl);
CreateList_sq(&sl,n);
printf("\n2-Print Sqlist:\n");
PrintList_sq(&sl);
system("cls");
}else
printf("ERROR");
printf("---------------------------请选择操作方式
--------------------------\n");
printf("\t 1: 查找\t 2:删除\t 3: 输出表\t 0: 退出\n 输入操作数:");
scanf("%d", &n);
while(n)
{
printf("\n链表元素:\n");
PrintList_sq(&sl);
if(n == 1){
printf("\n请输入想要查找的元素:");
scanf("%d", &e);
ListLocate(&sl,e);
}
if(n == 2){
printf("\n请输入想要删除元素的位置:");
scanf("%d", &i);
ListDelete_sq(&sl, i);
}
if(n == 3)
{
printf("\n链表元素:\n");
PrintList_sq(&sl);
}
printf("\t---------------------------请选择操作方式
--------------------------");
printf("\t 1: 查找\t 2:删除\t 0: 退出\n 输入操作数:");
scanf("%d", &n);
}
return 0;
}三、实验分析与小结
(实验过程中的问题分析、产生的原因以及解决方法;实验结果分析;有待优化思路)
(一)实验结果截图
.
(二)总结
通过顺序表数组元素的特点,我们可以对数据实现顺序查找。

四、其它
得分(百分制)。

相关文档
最新文档