太原理工大学软件工程《数据结构实验报告4-查找》
数据结构 查找 实验报告
数据结构查找实验报告数据结构查找实验报告1·实验目的本实验旨在研究不同的查找算法在不同数据结构下的性能表现，通过实验结果对比分析，选取最优算法来完成查找操作。
2·实验方法2·1 数据结构选择在本实验中，我们选择了常用的数据结构进行查找性能比较，包括线性表、二叉树、哈希表等。
2·2 查找算法选择我们选择了以下常用的查找算法进行实验：●顺序查找●二分查找●插值查找●二叉查找树●平衡二叉查找树（AVL树）●哈希查找3·实验过程3·1 实验环境设置首先，我们需要搭建合适的实验环境，包括编程语言选择、编译器、开发环境等。
在本次实验中，我们选择了C++编程语言，并使用了Visual Studio 2019作为开发环境。
3·2 实验步骤为了比较各个查找算法的性能，我们按照以下步骤进行实验： 1·创建用于查找的数据结构，并初始化数据集合。
2·调用每个查找算法进行查找，并记录查找耗时。
3·分析实验结果，比较各个查找算法的性能。
4·实验结果与分析根据实验步骤中记录的各个查找算法的耗时，我们得到了以下结果：●对于小规模数据集，顺序查找表现较好。
●对于有序数据集，二分查找和插值查找表现最佳。
●对于动态数据集，哈希表的查找效率最高。
5·结论根据实验结果与分析，我们得出以下结论：●不同的数据结构适用于不同的查找需求。
●在静态有序数据集中，二分查找和插值查找是较好的选择。
●在动态数据集中，哈希表具有较高的查找效率。
附件：附件1：实验数据集附件2：查找算法代码法律名词及注释：1·数据结构：数据之间的组织方式和关系，使得我们可以高效地进行数据的存储和操作。
2·查找算法：在给定某个目标值的情况下，在给定数据集内寻找目标值的算法。
3·顺序查找：逐个比较目标值和数据集内的元素，直到找到目标值或者遍历完整个数据集。
《数据结构》实验报告查找
实验四——查找一、实验目的1.掌握顺序表的查找方法，尤其是折半查找方法；2.掌握二叉排序树的查找算法。
二、实验内容1.建立一个顺序表，用顺序查找的方法对其实施查找；2.建立一个有序表，用折半查找的方法对其实施查找；3.建立一个二叉排序树，根据给定值对其实施查找；4.对同一组数据，试用三种方法查找某一相同数据，并尝试进行性能分析。
三、实验预习内容实验一包括的函数有：typedef struct ，创建函数void create(seqlist & L)，输出函数void print(seqlist L)，顺序查找int find(seqlist L,int number)，折半查找int halffind(seqlist L,int number) 主函数main().实验二包括的函数有：结构体typedef struct，插入函数void insert(bnode * & T,bnode * S)，void insert1(bnode * & T)，创建函数void create(bnode * & T)，查找函数bnode * search(bnode * T,int number)，主函数main().四、上机实验实验一：1.实验源程序。
#include<iostream.h>#define N 80typedef struct{int number; //关键字char name[5];char sex[2];int age;}record;typedef struct{record stu[N];int num;//记录人数}seqlist;//建顺序表void create(seqlist & L){int i;L.num=0;cout<<"请依次输入(输入学号为0认定为终止输入):"<<endl;cout<<"学号"<<"\t姓名"<<"\t性别"<<"\t年龄"<<endl;cin>>L.stu[1].number;for(i=1;L.stu[i].number!=0;){cin>>L.stu[i].name>>L.stu[i].sex>>L.stu[i].age;L.num++;cout<<endl;cin>>L.stu[++i].number;}}//输出学生信息void print(seqlist L){int i;cout<<"学生基本信息为:"<<endl;for(i=1;i<=L.num;i++)cout<<"\t"<<L.stu[i].number<<"\t"<<L.stu[i].name<<"\t"<<L.stu[i].sex<<"\t"<<L.stu[i].age<< endl;}//顺序查找int find(seqlist L,int number){int i;for(i=L.num;i>=0;i--)if(L.stu[i].number==number)return i;}//折半查找int halffind(seqlist L,int number){int high=L.num,low=1,mid;for(;low<=high;){mid=(high+low)/2;if(number==L.stu[mid].number)return mid;elseif(number<L.stu[mid].number)high=mid-1;elselow=mid+1;}return 0;}void main(){int i,number;seqlist L;create(L);print(L);cout<<"折半查找:"<<endl;cout<<"输入学生学号:";cin>>number;if((i=halffind(L,number))!=0)cout<<"\t"<<L.stu[i].number<<"\t"<<L.stu[i].name<<"\t"<<L.stu[i].sex<<"\t"<<L.stu[i].age<< endl;elsecout<<"失败!"<<endl;cout<<"顺序查找:"<<endl;cout<<"输入学生学号:";cin>>number;if((i=find(L,number))!=0)cout<<"\t"<<L.stu[i].number<<"\t"<<L.stu[i].name<<"\t"<<L.stu[i].sex<<"\t"<<L.stu[i].age<< endl;elsecout<<"失败!"<<endl;}实验二：#include<iostream.h>typedef struct{int number; //关键字char name[5];char sex[2];int age;}record;typedef struct node{record inf;struct node *lchild,*rchild;}bnode;void insert(bnode * & T,bnode * S){if(!T)T=S;elseif(S->inf.number<T->inf.number)insert(T->lchild,S);elseinsert(T->rchild,S);}void insert1(bnode * & T){int flag=1; int number; bnode * u; char ctinue;for(;flag==1;){cout<<"依次输入(学号为0默认为结束输入):"<<endl;cout<<"学号"<<"\t姓名"<<"\t性别"<<"\t年龄"<<endl;cin>>number;while(number){u=new bnode;u->inf.number=number;cin>>u->>>u->inf.sex>>u->inf.age;u->lchild=u->rchild=NULL;insert(T,u);cin>>number;}cout<<"继续插入(Y/N):";cin>>ctinue;if(ctinue=='y'||ctinue=='y')flag=1;elseflag=0;}}void create(bnode * & T){bnode * u;int number;T=NULL;cout<<"依次输入(学号为0默认为结束输入):"<<endl;cout<<"学号"<<"\t姓名"<<"\t性别"<<"\t年龄"<<endl;cin>>number;while(number){u=new bnode;u->inf.number=number;cin>>u->>>u->inf.sex>>u->inf.age;u->lchild=u->rchild=NULL;insert(T,u);cin>>number;}}bnode * search(bnode * T,int number){if(T==NULL||T->inf.number==number)return T;elseif(T->inf.number>number)return search(T->lchild,number);elsereturn search(T->rchild,number);}void main(){int number,flag=1,choice; char ctinue;bnode * T,*p;for(;flag==1;){cout<<"\t1.建立二叉排序树"<<"\n\t2.插入学生信息"<<"\n\t3.查找学生信息"<<endl;cout<<"选择:";cin>>choice;switch(choice){case 1:{create(T);cout<<"成功建立!"<<endl;};break;case 2:{insert1(T);cout<<"插入成功!"<<endl;};break;case 3:{cout<<"输入待查学生的学号:";cin>>number;p=search(T,number);if(p)cout<<p->inf.number<<"\t"<<p-><<"\t"<<p->inf.sex<<"\t"<<p->inf.age<<endl;elsecout<<"查找失败!"<<endl;};break;}cout<<"Continue(Y/N):";cin>>ctinue;if(ctinue=='y'||ctinue=='y')flag=1;elseflag=0;}}2.实验结果（截图）。
太原理工大学软件工程软件需求实验报告
本科实验报告课程名称：软件需求工程实验项目：软件需求课程实验实验地点：行勉楼A304 专业班级：学号：学生姓名：指导教师：2016年5月18日实验一需求分析实验一、实验目的1、要求学生根据实际项目的要求，应用传统的结构化方法或者面向对象方法进行需求分析；2、通过实验了解和掌握UML和Rataional等工具的使用方法。
二、实验设备：PC机、Windows操作系统、UML和Rational等工具软件。
三、实验内容：1、熟悉和掌握UML和Rational Rose工具的使用。
在rose中创建新的模型，分别画出如下的图：用例图、类图、包图、活动图、顺序图、状态图等。
2、根据如下项目，对系统进行需求分析。
具体要求，绘制系统的用例对用例进行规格说明，绘制类图、活动图、顺序图和状态图等。
四、实验步骤1、安装Rational Rose。
2、根据问题目标、业务背景、问题陈述（描述）等（此信息可以根据项目名称从网上搜索），确定系统的参与者Actor（用户），从用户角度确定系统相关功能用例Usecase，做出用例图。
3、针对每个功能用例使用《用例描述模板》，进行描述。
4、分别使用活动图、顺序图描述用例执行过程。
五、实验结果1、安装Rational Rose。
成功安装了UML软件。
2、根据问题目标、业务背景、问题陈述（描述）等（此信息可以根据项目名称从网上搜索），确定系统的参与者Actor（用户），从用户角度确定系统相关功能用例Usecase，做出用例图。
（一）选题1：学生选课系统项目背景：本系统实现学生选课的基本功能，包括学生退选课，查看自己的选课信息；教师查看选课学生的信息，提交成绩；管理员添加学生、管理学生、管理成绩、添加教师、管理教师和管理课程等。
实现学生选课的动态管理，使得对信息的管理更加及时、高效，提高了效率。
用例图：用户：学生：管理者：类图：时序图：管理者：学生：协作图：老师：学生：（二）选题2：图书管理系统项目背景：本系统实现图书管理的基本功能，包括学生借书退书，查看自己的借书信息；管理员添加学生、管理学生和管理书籍等。
太原理工数据结构实验报告四
实验报告四课程名称：数据结构实验名称：数据结构实验地点：计算机110机房专业班级：计科Z1501 学号：2015001909 学生姓名：刘元瑞指导教师：孟亮2016年12 月26日1.序实现下面运算：在二叉排序树中查找关键字为key的记录。
#include <stdio.h>#include <malloc.h>#include <Windows.h>//构造二叉排序树的结点typedef struct sort{int a; //关键字struct sort *L_node;//其左孩子struct sort *R_node;//其右孩子}Sort, *Sort_;Sort_ Structure();//接收用户输入的数据构造二叉排序树Sort_ Find(Sort_ BS_tree, int a);//查找部分void main(){int t;Sort_ Record;Sort_ BS_tree = Structure();//调用函数构造二叉排序树printf("请输入要查找的关键字!\n");scanf("%d", &t);if((Record = Find(BS_tree, t)))printf("所要找的记录为%d", Record->a);system("pause");}//接收用户输入的数据构造二叉排序树Sort_ Structure(){Sort_ BS_tree= (Sort_)malloc(sizeof(Sort));Sort_ p, s, q;int t;BS_tree->L_node = BS_tree->R_node = NULL;printf("请按照任意顺序输入二叉树的结点，输入0时结束！\n");scanf("%d",&t);if(t!=0){BS_tree->a = t;}scanf("%d", &t);while(t!=0){p = BS_tree;q = (Sort_)malloc(sizeof(Sort));q->a = t;q->L_node = q->R_node = NULL;//查找要插入部分if(t>p->a) s = p->R_node;else if(t<p->a) s = p->L_node;else s = NULL;while(s != NULL){p = s;if(t>p->a) s = p->R_node;else if(t<p->a) s = p->L_node;else s = NULL;}if(p->a != t){if(t > p->a) p->R_node = q;else p->L_node = q;}scanf("%d", &t);}return BS_tree;}//查找部分Sort_ Find(Sort_ BS_tree, int a){Sort_ s;Sort_ p = BS_tree;if(a>p->a) s = p->R_node;else if(a<p->a) s = p->L_node;else return p;while(s != NULL){p = s;if(a>p->a) s = p->R_node;else if(a<p->a) s = p->L_node;else return p;}printf("查找不成功!\n");return NULL;}2．试将折半查找的算法改写成递归算法。
查找实验报告
for(j = 0;j <lenth-i-1;j ++)
{
if(a[j]>a[j+1])
{
temp = *(a +j);
*(a+j) = *(a+j+1);
*(a+j+1) = temp;
}
}
}
return a;
}
int halnt low= 0;
#include <stdlib.h>
#define STACK_INIT_SIZE 100
#define ERROR 0
#define TURE 1
int* order(int* a,int lenth)
{
int i ,j;int temp;
for(i = 0;i < lenth -1;i ++)
{
printf("查找成功！找到的位置为：\t");
printf("%d\n",halffind(a, 9, e));
}
else
printf("没有你要查找的数据！");
return 0;
}
七、实验结果
查找成功
查找失败
八、实验心得：
通过本次查找实验，让我懂得了如何应用冒泡排序，如何对有序数组进行折半查找，加深了对折半查找的理解，初步掌握了其基本概念和操作。
数据结构实验报告（实验四）
实验人：颜建学
班级：4101090703
实验时间：
实验学时：4
实验地点：260
1、实验题目：查找
二、实验目的：
掌握二分查找算法
太原理工数据结构实验报告完整版
实验名称：线性表一．目的与要求本次实习的主要目的是为了使学生熟练掌握线性表的基本操作在顺序存储结构和链式存储结构上的实现，提高分析和解决问题的能力。
要求仔细阅读并理解下列例题，上机通过，并观察其结果，然后独立完成后面的实习题。
二．例题[问题描述]用链表形式存储一个字符串，插入、删除某个字符，最后按正序、逆序两种方式输出字符串。
[输入]初始字符串，插入位置，插入字符，删除字符。
[输出]已建立链表（字符串），插入字符后链表，删除字符后链表，逆转后链表。
[存储结构]采用链式存储结构[算法的基本思想]建立链表：当读入字符不是结束符时，给结点分配存储空间，写数据域，将新结点插到表尾；插入字符：根据读入的字符在链表中找插入位置，将新结点插入到该位置之前；删除字符：根据读入的删除字符在链表中找到被删结点后，将其从链表中删除；链表逆转：从链表的第一个结点开始对所有结点处理，将每个结点的前驱变为它的后继；打印链表：从链表的第一个结点开始，依次打印各个结点的数据域。
[参考源程序]#define NULL 0typedef struct node{char a;struct node *link;}node,*nodelink;void readlink(nodelink head){nodelink p,q;char c;p=head;printf("Input a linktable(a string):");scanf("%c",&c);if (c=='\n') printf("This string is empty。
");while(c!='\n'){q=(nodelink)malloc(sizeof(node));q->a=c;p->link=q;p=q;scanf("%c",&c);}p->link=NULL;}void writelink(nodelink head){nodelink q;if (head->link==NULL) printf(" This link is empty。
太原理工软件工程实习报告
太原理工软件工程实习报告一、实习背景与目的随着信息技术的快速发展，软件工程成为现代科技领域中的重要研究方向。
为了提高自身的实践能力和专业素养，我选择了太原理工大学的软件工程实习项目。
本次实习旨在通过实际操作，深入了解软件开发流程，掌握软件工程的核心技术，并培养团队合作和解决问题的能力。
二、实习内容与过程在实习期间，我参与了太原理工大学软件实验室的一个实际项目开发。
以下是实习的主要内容与过程：1. 项目启动：在实习的开始阶段，导师为我们介绍了项目的背景和需求。
我们通过讨论和分析，明确了项目的目标、功能要求和性能要求。
2. 需求分析：我们小组成员共同参与需求分析工作，通过与导师和客户的沟通，明确了用户需求和系统功能。
我们使用UML图和用例图工具，对系统的功能进行详细的描述和文档化。
3. 设计阶段：在需求分析的基础上，我们开始进行系统设计。
我负责设计和实现系统的数据库部分，包括数据库表的创建、关系的建立和SQL语句的编写。
4. 编码阶段：根据设计文档，我开始编写代码。
我使用了Java语言和MySQL数据库，实现了系统的核心功能。
在编码过程中，我注重代码的可读性和可维护性，遵循了软件工程的最佳实践。
5. 测试阶段：在编码完成后，我们进行了系统的测试。
我负责编写测试用例，并与其他成员一起进行测试。
我们发现了一些问题，并通过调试和优化，解决了这些问题。
6. 项目总结与汇报：在项目完成后，我们进行了项目总结和汇报。
我向导师和同学们展示了自己的工作成果，并分享了在实习过程中的收获和体会。
三、实习收获与反思通过本次实习，我对软件工程的核心技术和开发流程有了更深入的了解。
我掌握了UML图和用例图的使用，熟悉了Java语言和MySQL数据库的操作。
同时，我也学会了团队合作和解决问题的能力。
在实习过程中，我也意识到了自己在一些方面的不足之处。
例如，我在需求分析阶段的沟通能力和表达能力有待提高。
此外，我在代码编写和调试过程中，还需要更加注重细节和规范，以提高代码的质量和稳定性。
数据结构 查找 实验报告
数据结构查找实验报告数据结构查找实验报告1. 简介查找是计算机科学中一种常见的操作，它用于在一组数据中快速定位特定的元素。
数据结构是计算机存储、组织数据的方式，可以有效地支持查找操作。
本实验报告将介绍查找算法的原理和实现，以及实验结果的分析和总结。
2. 查找算法2.1 顺序查找顺序查找是一种简单直观的查找算法，它从数据集的第一个元素开始逐个比较，直至找到目标元素或遍历完所有元素。
顺序查找的时间复杂度为O(n)，其中n是数据集的大小。
2.2 二分查找二分查找是一种高效的查找算法，它要求数据集必须是有序的。
它通过将数据集分成两部分，并与目标元素进行比较，以确定目标元素所在的区间，然后在该区间内继续二分查找，直至找到目标元素或确定目标元素不存在。
二分查找的时间复杂度为O(log n)，其中n是数据集的大小。
2.3 插值查找插值查找是对二分查找的一种改进，它根据目标元素的估计位置来确定比较的起始位置。
它适用于数据集分布均匀的情况，可以进一步减少查找的次数。
插值查找的时间复杂度为O(log(log n))。
3. 实验结果本次实验我们使用了三种查找算法（顺序查找、二分查找和插值查找）在不同大小的数据集上进行了性能测试。
实验结果如下表所示：---- 数据集大小 ---- 顺序查找时间（ms） ---- 二分查找时间（ms） ---- 插值查找时间（ms） ---------------------------------------------------------------------------------------------- 1000 ---- 10 ---- 2 ---- 1 -------- 10000 ---- 100 ---- 4 ---- 2 -------- 100000 ---- 1000 ---- 6 ---- 3 -------- 1000000 ---- 10000 ---- 8 ---- 4 ----从实验结果可以看出，随着数据集的增大，顺序查找的时间成正比增加，而二分查找和插值查找的时间相对较稳定。
数据结构查找算法实验报告
数据结构查找算法实验报告数据结构查找算法实验报告---------------------------------1.引言在计算机科学中，查找算法是一种用于在数据集合中寻找特定元素的算法。
查找算法在各种应用中广泛使用，例如数据库检索，关键字搜索等。
本次实验旨在研究和探索不同的数据结构查找算法，如线性查找、二分查找、哈希查找等，并比较它们的性能和适用场景。
2.线性查找2.1 算法原理线性查找又称为顺序查找，它从数据集合的起始位置开始，逐个比较元素直到找到目标元素或遍历完整个集合。
线性查找是最简单的查找算法，但效率较低，时间复杂度为O(n）2.2 算法步骤●从数组的第一个元素开始遍历，依次比较元素与目标元素是否相等。
●如果相等，返回目标元素的索引值。
●如果遍历完整个数组仍未找到目标元素，返回未找到的标志。
2.3 算法实现```function linearSearch(arr, target) {for (let i = 0。
i < arr.length。
i++) {if (arri === target) {return i。
}}return -1。
}```3.二分查找3.1 算法原理二分查找是一种高效的查找算法，要求数据集合必须有序。
它通过重复将数据集合一分为二，直到找到目标元素或确定目标元素不存在。
二分查找的时间复杂度为O(log n）3.2 算法步骤●将数据集合的起始位置和结束位置分别设为low和high。
●计算中间位置mid，并将mid元素与目标元素进行比较。
●如果mid元素等于目标元素，则返回mid。
●如果mid元素大于目标元素，则将high设为mid-1。
●如果mid元素小于目标元素，则将low设为mid+1。
●重复以上步骤，直到low大于high或找到目标元素。
3.3 算法实现```function binarySearch(arr, target) {let low = 0。
数据结构查找实验报告
数据结构查找实验报告一、实验目的本次实验的主要目的是深入理解和掌握常见的数据结构查找算法，包括顺序查找、二分查找、哈希查找等，并通过实际编程实现和性能比较，分析它们在不同数据规模和分布情况下的效率和适用场景。
二、实验环境本次实验使用的编程语言为 Python 38，开发环境为 PyCharm。
实验中所使用的数据集生成工具为 numpy 库。
三、实验原理1、顺序查找顺序查找是一种最简单的查找算法，它从数据结构的开头依次逐个比较元素，直到找到目标元素或遍历完整个数据结构。
其平均时间复杂度为 O(n)。
2、二分查找二分查找要求数据结构是有序的。
通过不断将查找区间缩小为原来的一半，直到找到目标元素或者确定目标元素不存在。
其时间复杂度为 O(log n)。
3、哈希查找哈希查找通过将元素映射到一个特定的哈希表中，利用哈希函数计算元素的存储位置，从而实现快速查找。
理想情况下，其平均时间复杂度为 O(1)，但在存在哈希冲突时，性能可能会下降。
四、实验步骤1、数据集生成使用 numpy 库生成不同规模和分布的数据集，包括有序数据集、无序数据集和具有一定重复元素的数据集。
2、顺序查找实现编写顺序查找算法的函数，接受数据集和目标元素作为参数，返回查找结果（是否找到及查找次数）。
3、二分查找实现实现二分查找算法的函数，同样接受数据集和目标元素作为参数，并返回查找结果。
4、哈希查找实现构建哈希表并实现哈希查找函数，处理哈希冲突的情况。
5、性能比较对不同规模和类型的数据集，分别使用三种查找算法进行查找操作，并记录每种算法的查找时间和查找次数。
五、实验结果与分析1、顺序查找在无序数据集中，顺序查找的性能表现较为稳定，查找时间随着数据规模的增大线性增长。
但在有序数据集中，其性能没有优势。
2、二分查找二分查找在有序数据集中表现出色，查找时间随着数据规模的增大增长缓慢，体现了对数级别的时间复杂度优势。
然而，在无序数据集中无法使用。
数据结构实验4查找、排序
淮海工学院计算机工程学院实验报告书课程名：《数据结构》题目：实验4 查找、排序的应用班级：学号：姓名：实验4 查找、排序的应用实验目的和要求1.熟悉查找表的存储结构。
2.熟练掌握循序查找和二分查找方法。
3.熟悉几种典型的排序方法，并对各种算法的特点、使用范围和效率有进一步的了解。
4.实现两种以上的简单排序和快速排序、比较它们的时间效率。
5.要求独立完成实验内容（提交程序清单、相关实验数据及运行结果）；6.要求认真书写实验报告,并按时提交。
实验环境Turbo C 或VC++实验学时4学时，必做实验实验内容和步骤l、产生n个整数并存于数组r[1..n]中。
对主要查找算法（顺序查找、折半查找）和排序算法（直接插入排序、冒泡排序、快速排序、简单选择排序）进行实验比较，计算出平均比较次数、平均移动次数。
2、对实验结果数据进行对比分析。
1. #include <iostream>using namespace std;int count;int SepSearch(int r[], int key,int len) //顺序查找{int i;count=0;i=len;while(key!=r[i]){i--;count++;}return(i);}int BinSrch(int r[],int key,int len) //折半查找{int low,high,mid;low=1;high=len;count=0;while(low<=high){ count++;mid=(low+high)/2;if(key==r[mid]) return(mid);else if(key<r[mid]) high=mid-1;else low=mid+1;}return(0);}void BiInsertsort(int r[], int n) //插入排序（折半）{count=0;for(int i=2;i<=n;i++){if (r[i]<r[i-1]){r[0] = r[i];int low=1,high=i-1;while (low<=high){count++;int mid=(low+high)/2;if (r[0]<r[mid])high=mid-1;else low = mid+1;}int j;for (j=i-1;j>high;j--){r[j+1] = r[j];count++;}r[j+1] = r[0];}}for(int k=1;k<=n;k++)printf("%d ",r[k]);printf("\n");}void BubbleSort(int r[], int n) //冒泡排序{count=0;int i;int temp,exchange,bound;exchange=n;while (exchange) //仅当上一趟排序有记录交换才进行本趟排序{bound=exchange;exchange=0;for (int j=1; j<bound; j++)if (r[j]>r[j+1]){temp=r[j];r[j]=r[j+1];r[j+1]=temp;exchange=j;count++;}}for( i=1;i<=n;i++)printf("%d ",r[i]);printf("\n");}int Partition(int r[], int first, int end) //快速排序一次划分{int i=first;int j=end;r[0]=r[first];count=1;while (i<j){while (i<j && r[0]<= r[j]) j--; //右侧扫描r[i]=r[j];while (i<j && r[i]<= r[0]) i++; //左侧扫描r[j]=r[i];}r[i]=r[0];return i; //i为轴值记录的最终位置}void QuickSort(int r[], int first, int end) //快速排序{count++;if (first<end){int pivot=Partition(r, first, end);QuickSort(r, first, pivot-1); //递归地对左侧子序列进行快速排序QuickSort(r, pivot+1, end); //递归地对右侧子序列进行快速排序}}void SelectSort(int r[ ], int n) //简单选择排序{count=0;int i,j,index,temp;for (i=1; i<n; i++){index=i;for (j=i+1; j<=n; j++){count++;if (r[j]<r[index]) index=j;}if (index!=i){temp=r[i];r[i]=r[index];r[index]=temp;}}for(i=1;i<=n;i++)printf("%d ",r[i]);printf("\n");}void main(){const int numv=12;inta[3][numv]={{0,6,13,19,23,37,39,41,45,48,58,86},{0,86,58,48,45,41,39,37,23,19,13,6},{0,23,13,48,86,19, 6,41,58,37,45,39}};int z1[numv],z2[numv];int m,n,i,j;int s1;printf("请选择测试数据类:1 正序2 逆序3 随机[ 若跳出,请按4 ]\n");scanf("%d",&m);while(m>0&&m<4){printf("请选择操作算法：1 直接插入排序2 冒泡排序3 快速排序 4 简单选择排序5顺序查找6 折半查找\n");scanf("%d",&n);switch(n){case 1:printf("直接插入排序前:\n");for(j=1;j<numv;j++)printf("%d ",a[m-1][j]);printf("\n");printf("直接插入排序结果为:\n");BiInsertsort(a[m-1],numv-1);printf("移动了""%d""次\n",count);break;case 2:printf("冒泡排序前:\n");for( j=1;j<numv;j++)printf("%d ",a[m-1][j]);printf("\n");printf("冒泡排序结果为:\n");BubbleSort(a[m-1], numv-1);printf("移动了""%d""次\n",count);break;case 3:printf("快速排序前:\n");for( j=1;j<numv;j++)printf("%d ",a[m-1][j]);printf("\n");printf("快速排序结果为:\n");QuickSort(a[m-1],0,numv-1);for(i=1;i<numv;i++)printf("%d ",a[m-1][i]);printf("\n");printf("移动了""%d""次\n",count);break;case 4:printf("简单选择排序前:\n");for( j=1;j<numv;j++)printf("%d ",a[m-1][j]);printf("\n");printf("简单选择排序结果为:\n");SelectSort(a[m-1],numv-1);printf("移动了""%d""次\n",count);break;case 5:printf("请输入查找的数:\n");scanf("%d\n",&s1);i=SepSearch(a[m-1], s1,numv-1);printf("用顺序查找法查找数""%d""在第""%d""位,""比较了""%d""次\n",s1,i+1,count); break;case 6:printf("请输入查找的数:\n");scanf("%d\n",&s1);j=BinSrch(a[m-1], s1,numv-1);printf("用折半查找法查找数""%d""在第""%d""位,""比较了""%d""次\n",s1,i+1,count);break;default:printf("输入错误!\n");}m=0;printf("请选择测试数据类型:1 正序2逆序3随机[ 若跳出,请按4 ]:\n");scanf("%d",&m);}if(m==4) printf("(*^__^*) 再见!\n");else printf("输入错误!\n");}实验结果：（1）直接插入排序：（2）冒泡排序：（3）快速排序：(3)快速排序（4）简单选择排序（5）顺序查找（6）折半查找2.1 顺《数据结构》实验报告- 10 -2结果分析（1）几种排序法的比较如下表：(2)顺序查找平均查找长度:ASL=1/2(n+1)(3)折半法平均查找长度：ASL= (n+1)/2*log2(n+1)-1折半法查找方法优点是比较次数少，查找速度快，平均性能好，但要求查找的表为有序，且插入删除困难。
数据结构查找实验报告
数据结构查找实验报告数据结构查找实验报告一、引言数据结构是计算机科学中的重要概念之一，它涉及到组织和管理数据的方式和方法。
在实际应用中，我们经常需要对大量的数据进行查找操作，因此查找算法的效率和准确性显得尤为重要。
本实验旨在通过对比不同的查找算法，探索其性能和适用场景。
二、实验目的本实验的目的是比较常见的查找算法，包括线性查找、二分查找和哈希查找，分析它们的时间复杂度和空间复杂度，并通过实验数据验证其效率。
三、实验方法1. 实验环境本实验使用C++语言进行编程，选择了Visual Studio作为开发环境，以保证实验结果的准确性和可靠性。
2. 实验步骤（1）线性查找线性查找是最简单直接的查找算法，它的原理是从头到尾逐个比较待查找元素和数组中的元素，直到找到目标元素或遍历完整个数组。
在实验中，我们随机生成一个包含一定数量元素的有序数组，并使用线性查找算法查找目标元素。
（2）二分查找二分查找是一种高效的查找算法，它基于有序数组的特点，通过不断缩小查找范围来快速定位目标元素。
在实验中，我们同样生成一个有序数组，并使用二分查找算法进行查找操作。
（3）哈希查找哈希查找是一种基于哈希表的查找算法，它通过将关键字映射到哈希表中的位置来实现快速查找。
在实验中，我们使用哈希查找算法对一个包含大量元素的数组进行查找。
四、实验结果与分析1. 时间复杂度通过实验数据统计，我们可以得到不同查找算法的平均时间复杂度。
线性查找的时间复杂度为O(n)，其中n为数组的大小；二分查找的时间复杂度为O(logn)，哈希查找的时间复杂度为O(1)。
可以看出，随着数据规模增大，二分查找和哈希查找的效率明显高于线性查找。
2. 空间复杂度线性查找的空间复杂度为O(1)，即不需要额外的存储空间；二分查找的空间复杂度为O(1)，哈希查找的空间复杂度为O(n)，其中n为哈希表的大小。
因此，从空间复杂度的角度来看，线性查找和二分查找相对较优。
3. 实验结果通过多次实验，我们得到了不同查找算法的平均查找时间。
数据结构实验报告_太原理工大学软件学院
}
int InserOrderList(SqList *L,int e){
int i;
if((L->length)>=(L->listsize)){
int *newbase;
newbase=(int *)realloc(L->elem,(L->listsize+LISTINCREMENT)*sizeof(int));
《数据结构》实验报告
专业：软件工程
班级：13XX班
姓名：X X X
2014年12月
太原理工大学学生实验报告
学院名称
软件学院
专业班级
软件13XX班
学号
201300XXXX
实验成绩
学生姓名
XXX
同组人姓名
实验日期
11.12
课程名称
数据结构
实验题目
实验一线性表
实验记录：
1．设顺序表A中的数据元素递增有序，试写一程序，将x插入到顺序表的适当位置上，使该表仍然有序。
if(!newbase) exit(OVERFLOW);
L->elem=newbase;
L->listsize+=LISTINCREMENT;
}
q=&(L->elem[i-1]);
for(p=&(L->elem[L->length-1]);p>=q;--p)
*(p+1)=*p;
*q=e;
++L->length;
L->length++;
return OK;
}
void main(){
数据结构查找算法实验报告-无删减范文
数据结构查找算法实验报告数据结构查找算法实验报告1. 引言数据结构查找算法是计算机科学中的重要部分，它涉及在给定的数据集中搜索特定元素的算法。
在本实验中，我们将研究和比较两种常见的查找算法：顺序查找和二分查找。
通过实验，我们将评估它们在不同数据规模下的性能表现，并分析其时间复杂度和空间复杂度。
2. 实验目的- 研究和理解顺序查找算法和二分查找算法的原理；- 实现顺序查找算法和二分查找算法并进行性能比较；- 分析不同数据规模下两种算法的时间复杂度和空间复杂度。
3. 实验方法和实验步骤3.1 实验环境本实验使用以下实验环境进行开发和测试：- 操作系统：Windows 10- 编程语言：Python 3.9.13.2 顺序查找算法顺序查找算法是一种简单直接的查找方法，它逐个比较数据集中的元素，直到找到目标元素或遍历完整个数据集。
以下是顺序查找算法的实现步骤：1. 从数据集的第一个元素开始，逐个比较元素与目标元素是否相等；2. 如果相等，则返回目标元素的位置索引；3. 如果遍历完整个数据集仍未找到目标元素，则返回-1表示未找到。
以下是顺序查找算法的代码实现：```pythondef sequential_search(data, target):for i in range(len(data)):if data[i] == target:return ireturn -1```3.3 二分查找算法二分查找算法是一种高效的查找方法，它要求数据集已经有序。
以下是二分查找算法的实现步骤：1. 初始化左右两个指针，分别指向数据集的第一个元素和最后一个元素；2. 计算中间元素的位置索引，并与目标元素进行比较；3. 如果中间元素等于目标元素，则返回中间元素的位置索引；4. 如果中间元素大于目标元素，则将右指针移动到中间元素的前一个位置；5. 如果中间元素小于目标元素，则将左指针移动到中间元素的后一个位置；6. 重复上述步骤，直到找到目标元素或左指针大于右指针为止；7. 如果未找到目标元素，则返回-1。
太原理工大学软件工程实验报告
2 数据描述
2.1 输入输出：
输入项至少包括：教务处布置的教学计划和工作量计算子系统、学院教师自报的授课计 划和学院制定的有关授课限制条件，输出项至少包括：教务处最终下达全院教师的教学任务 书和学院各个班级下各学期的课程表（可以不含上课地点）。
依次去掉各项输入，第一轮去掉一个，第二轮去掉两个，以此类推。 第三个大模块： 3.1 是否满足条件 测试用例：Z≤2 300≤A≤600 C=0
Z＞2 300≤A≤600 C=0 Z≤2 A＜300 或 A＞600 C=0 Z≤2 300≤A≤600 C≠0 Z＞2 A＜300 或 A＞600 C=0 Z≤2 A＜300 或 A＞600 C≠0 Z＞2 300≤A≤600 C≠0 Z＞2 A＜300 或 A＞600 C≠0 3.2 更新信息 测试用例：教工号+课程名称+课程代码+课时+班级类别+班号 依次去掉各项输入，第一轮去掉一个，第二轮去掉两个，以此类推。 第四个大模块： 4.1 检查 测试用例：教工号+密码 教工号（是否存在） 密码（是否正确） 4.2 查询 测试用例：教工号+课程名称+课程代码+课时+班级类别+班号+限制条件+计划学时+
加工名：审核 编号：5.1 输入：教务号 输出：有效值 加工逻辑：检查输入的教务号是否有密码对应
加工名：审计 编号：5.2 输入：有效值，课程信息 输出：通过名单 加工逻辑：判断课程是否可以通过，给出通过名单
加工名：更新信息 编号：5.3 输入：通过名单 输出：课程信息、教学任务书 加工逻辑：修改课程信息是否通过并给出教学任务书
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
本科实验报告
课程名称：数据结构B
实验项目：查找
实验地点：行勉楼C214
专业班级：软件XXX班学号：2014XXXX 学生姓名：xxxxx
指导教师：牛之贤张润梁
2016年 1 月 1 日
void insertBST(BiTree *bt, BiTree s) {
if (*bt == NULL) *bt = s;
else if (s->data.key<(*bt)->data.key) insertBST(&((*bt)->lchild), s);
else if (s->data.key>(*bt)->data.key) insertBST(&((*bt)->rchild), s); }
main() {
char ch;
KeyType key;
BiTree bt, s;
int i = 0;
printf("请输入元素：\n");
scanf("%d", &key);
bt = NULL;
while (key != -1) {
s = (BiTree)malloc(sizeof(BiTNode));
(s->data).key = key; s->lchild = s->rchild = NULL;
insertBST(&bt, s);
scanf("%d", &key);
}
do {
printf("输入你想要查找的元素：");
scanf("%d", &key);
s = searchBST(bt, key);
if (s != NULL) printf("成功! 这个等价元素是 %d.\n", s->data.key);
else printf("没有找到!\n");
printf("是否继续查找?(y/n)：");
scanf("%c", &ch);
ch = getchar();
} while (ch == 'y' || ch == 'Y');
getchar();
}
4.2#include<stdio.h>
int b_search(int *p, int l, int r, int key);
int main() {
int a[10] = { 1,2,3,4,5,6,7,8,9,10 };
int i, p, k;
for (i = 0; i < 10; i++) {
printf("a[%d]=%d\n", i, a[i]);
}
for (i = 0; i<2; i++) {
printf("请输入想要查找的数字:");
scanf("%d", &k);
p = b_search(a, 0, 6, k);
if (p >= 0)
printf("找到: a[%d]=%d\n", p, k);
else
printf("没有找到此元素: %d\n", k);
}
getchar();
getchar();
return 0;
}
int b_search(int *p, int l, int r, int key) { int f, m;
m = (l + r) / 2;
if (l>r)
f = -1;
else if (p[m] == key)
f = m;
else if (p[m]>key)
f = b_search(p, l, r - 1, key);
else
f = b_search(p, l + 1, r, key);
return f;
}
五、实验数据记录和处理
六、实验结果与分析。