实验15 折半查找

数据结构实验报告5(电大)

实验报告五查找（学科：数据结构）姓名单位班级学号实验日期成绩评定教师签名批改日期实验名称：实验五查找5.1 折半查找【问题描述】某班学生成绩信息表中，每个学生的记录已按平均成绩由高到低排好序，后来发现某个学生的成绩没有登记到信息表中，使用折半查找法把该同学的记录插入到信息表中，使信息表中的记录仍按平均成绩有序。

【基本信息】（1）建立现有学生信息表，平均成绩已有序。

（2）输入插入学生的记录信息。

（3）用折半查找找到插入位置，并插入记录。

【测试数据】自行设计。

【实验提示】（1）用结构数组存储成绩信息表。

（2）对记录中的平均成绩进行折半查找。

【实验报告内容】设计程序代码如下:#include<stdio.h>#include<string.h>#define N 5struct student{char name[10];float avg;}void insort(struct student s[],int n){int low,hight,mid,k;char y[10];float x;low=1;hight=n;strcpy(y,s[0].name );x=s[0].avg ;while(low<=hight){mid=(low+hight)/2;if(x>s[mid].avg )hight=mid-1;elselow=mid+1;}for(k=0;k<low-1;k++){strcpy(s[k].name,s[k+1].name) ;s[k].avg =s[k+1].avg ;}printf("%d",low);strcpy(s[low-1].name ,y) ;s[low-1].avg =x;}void main(){Struct student a[N]={{"caozh",96},{"cheng",95},{"zhao",93},{"wang",92},{"chen",91}};struct student stu[N];int i;for(i=0;i<N;i++)stu[i+1]=a[i];printf("初始%d 位同学的信息表\n",MAX);printf("排名姓名平均分数\n");for(i=1;i<=N;i++)printf("%d: %6s %3.2f\n",i,stu[i].name,stu[i].avg);printf("\n");printf("\n");printf("请输入学生的姓名：");scanf("%s",stu[0].name );printf("\n");printf("请输入平均成绩：");scanf("%f",&stu[0].avg );printf("\n");insort(stu,N);printf("折半排序后同学的信息表\n",MAX);printf("排名姓名平均分数\n");for(i=0;i<=N;i++){printf("%d: %6s %3.2f\n",i+1,stu[i].name,stu[i].avg);}printf("\n");}程序运行结果如下:5.2 二叉排序树的建立【问题描述】参阅相关资料，阅读建立二叉排序树的程序。

数据结构——查找,顺序查找,折半查找

实验五查找的应用一、实验目的：1、掌握各种查找方法及适用场合，并能在解决实际问题时灵活应用。

2、增强上机编程调试能力。

二、问题描述1.分别利用顺序查找和折半查找方法完成查找。

有序表（3,4,5,7,24,30,42,54,63,72,87,95）输入示例：请输入查找元素：52输出示例：顺序查找：第一次比较元素95第二次比较元素87 ……..查找成功，i=**/查找失败折半查找：第一次比较元素30第二次比较元素63 …..2.利用序列（12,7,17,11,16,2,13,9,21,4）建立二叉排序树，并完成指定元素的查询。

输入输出示例同题1的要求。

三、数据结构设计（选用的数据逻辑结构和存储结构实现形式说明）（1）逻辑结构设计顺序查找和折半查找采用线性表的结构，二叉排序树的查找则是建立一棵二叉树，采用的非线性逻辑结构。

（2）存储结构设计采用顺序存储的结构，开辟一块空间用于存放元素。

（3）存储结构形式说明分别建立查找关键字，顺序表数据和二叉树数据的结构体进行存储数据四、算法设计（1）算法列表（说明各个函数的名称，作用，完成什么操作）序号名称函数表示符操作说明1 顺序查找 Search_Seq 在顺序表中顺序查找关键字的数据元素2 折半查找 Search_Bin 在顺序表中折半查找关键字的数据元素3 初始化 Init 对顺序表进行初始化，并输入元素4 树初始化 CreateBST 创建一棵二叉排序树5 插入 InsertBST 将输入元素插入到二叉排序树中6 查找 SearchBST在根指针所指二叉排序树中递归查找关键字数据元素（2）各函数间调用关系（画出函数之间调用关系）typedef struct { ElemType *R; int length;}SSTable;typedef struct BSTNode{Elem data; //结点数据域 BSTNode *lchild,*rchild; //左右孩子指针}BSTNode,*BSTree; typedef struct Elem{ int key; }Elem;typedef struct {int key;//关键字域}ElemType;（3）算法描述int Search_Seq(SSTable ST, int key){//在顺序表ST中顺序查找其关键字等于key的数据元素。

折半查找法查找关键字,C++课程设计

河北联合大学2011-2012第2学期《软件设计基础-C++》课程设计报告设计名称：折半查找法查找关键字姓名：学号：专业班级：学院：设计时间：设计地点：指导教师评语：成绩：指导教师签字：年月日目录1.课程设计目的 (3)2.课程设计任务与要求 (4)3.课程设计说明书 (5)4.课程设计成果 (9)5.程序调试过程 (13)6.设计问题的不足和改进方案 (16)7.课程设计心得 (17)8.参考文献 (18)1．课程设计目的《软件设计基础-C++》课程设计是这门课程的实践性教学环节之一，本次设计结合实际应用的要求，使课程设计既覆盖C++的知识点，又接近工程实际需要。

目的是通过课程设计的综合训练，培养学生实际分析问题、解决问题的能力，以及编程和动手能力，最终目标是通过课程设计这种形式，帮助学生系统掌握C++这门课程的主要内容，养成良好的编程习惯，更好的完成教学任务。

通过产品管理系统的设计，培养学生综合利用C++语言进行程序设计的能力，加强函数的运用及学生对软件工程方法的初步认识，提高软件系统分析能力和程序文档建立、归纳总结的能力，培养学生利用系统提供的标准函数及典型算法进行设计。

2．课程设计任务与要求：要求：本次课程设计利用《软件设计基础-C++》课程中所学到的编程知识和编程技巧，完成具有一定难度和工作量的程序设计题目，帮助学生掌握编程、调试的基本技能，独立完成所布置的任务。

要求：1、对系统进行功能需求分析2、设计合理的数据结构和系统框架3、编程简练，程序功能齐全，能正确运行4、说明书、流程图要清楚5、课题完成后必须按要求提交课程设计报告任务：设计一个简单的产品管理系统：某工厂有5种产品，每种产品包括：产品代码，产品名称，产品数量，销售量，要求编写函数实现下列功能：（1）从键盘输入这些产品的信息；（2）按照产品的库存量进行升序排序，使用选择法排序，在主函数中输出；（3）使用折半查找法进行循环查询，当用户给出某种产品的代码时，在主函数中显示该产品的信息，如果没找到则给出未找到的信息，退出程序的运行；（4）输出产品信息。

折半查找

深圳大学实验报告课程名称：数据结构实验与课程设计实验项目名称：顺序查找、折半查找实验学院：计算机与软件学院专业：指导教师：杨芳报告人：张健哲学号：2013150372 班级：8 实验时间：2014/11/27实验报告提交时间：2014/11/27教务处制一、实验目的1、掌握顺序查找、折半查找算法的基本思想2、掌握顺序查找、折半查找算法的实现方法3、掌握顺序查找、折半查找的时间性能二、实验要求1、熟悉C++语言编程2、了解顺序查找、折半查找的原理三、实验内容本次实验有两项必做内容和一项选作内容：（一）顺序查找实验1、问题描述给出一个队列和要查找的数值，找出数值在队列中的位置，队列位置从1开始，要求使用带哨兵的顺序查找算法2、顺序查找算法⑴、在表的第0位置，赋给定值Key⑵、从表中最后一个记录开始⑶、逐个进行记录的关键字和给定值Key的比较⑷、若某个记录比较相等，则查找成功⑸、若直到第1个记录都比较不等，则查找不成功3、输入第一行输入n，表示队列有n个数据第二行输入n个数据，都是正整数，用空格隔开第三行输入t，表示有t个要查找的数值第四行起，输入t个数值，输入t行4、输入样本833 66 22 88 11 27 44 5532211995、输出每行输出一个要查找的数值在队列的位置，如果查找不成功，输出字符串error6、输出样本35error（二）折半查找实验1、问题描述在一个有序序列中，折半查找一个关键字；返回查找是否成功，如果成功，输入关键字所在的位置和查找次数。

2、查找算法⑴、n个对象从小到大存放在有序顺序表BinList中，Key为给定值⑵、设low、high指向待查元素所在区间的下界、上界，即low=1, high=BinListLen⑶、设mid指向待查区间的中点，即⑷、让Key与mid指向的记录关键字比较若Key=BinList[mid]，查找成功，结束若Key<BinList[mid]，则high=mid-1 [上半区间]若Key>BinList[mid]，则low=mid+1 [下半区间]⑸、重复⑶、⑷操作，直至low>high时，查找失败。

折半查找算法及分析（手工过程）

折半查找算法及分析（⼿⼯过程）折半查找的⼿⼯过程：1.我需要查找的数是10；给定：1 5 8 10 13 14 17 22 25 27 29 31 35 37 40 42 45 47 50 51 58下标：0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 h m t h m t h m t h t m h m这个⼿⼯过程到head = tail 时找到了。

我需要查找的数是29；给定：1 5 8 10 13 14 17 22 25 27 29 31 35 37 40 42 45 47 50 51 58下标：0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 h m t这个⼿⼯过程数在head < tail时程序停⽌，找到的是下标的那个数。

代码如下：#include<stdio.h>#include<stdlib.h>int binarySearch(int *arr,int count ,int data){int middle;int head = 0;int tail;tail = count;while(arr[middle] != data){middle = (head + tail)/ 2;if(arr[middle] < data){head = middle + 1;}else if(arr[middle] > data){tail = middle - 1;}}return middle;return -1;}int main(){int n = 0;int m ;int a[10]={1,4,8,9,16,17,19,20,25,27};printf("请输⼊需要查找的数: ");scanf("%d",&n);m = binarySearch(a,10,n);printf("%d ",m);return 0;}这是⼀个简单的折半处理，⽤的是⼀个简单的数组需要强调的是：如果要运⽤折半算法，数必须是有序的（升序或者降序）很多⼈都认为while（head > tail）这样也是正确的，但是对于middle = data时条件⼀直成⽴就会出现问题的！。

折半查找(二分搜索)的应用和技巧全面总结

---------------------------------------------------------------最新资料推荐------------------------------------------------------ 折半查找(二分搜索)的应用和技巧全面总结折半查找（二分搜索）的应用和技巧全面总结折半查找应该算是算法中比较简单常见，但却很实用的方法之一了，又叫做二分搜索，其应用比较广泛，可以用于排序数组中元素的查找，复杂度仅为 log （N），也可以用于有序数组中插入元素等等，一般而言针对排序数组的一些算法都会活多或少的用到折半查找活折半查找的思想，折半查找的实现主要分为两种方式，一种是遍历非递归形式，一种是采用递归的形式。

1、非递归形式，这种实现主要是通过每次调整中点的位置来实现。

1. int binsearch1(int arr[], int k, int l, int h){2. if(lh){ 3. return -1; 4. } 5. int mid; 6. while(l = h){ 7. mid = (l + h) / 2; 8. if(k == arr[mid]){ 9. return mid; 10. }else if(k arr[mid]){ 11. l = mid + 1; 12. }else{ 13. h = mid - 1; 14. } 15. } 16. return -1; 17. } 这种方式比较灵活，而已有利于解决很多变形的问题，后面会介绍。

2、递归的形式，这种形式比较简单，调整起点，中点，终点的位置，递归函数就可以实现 1. int binsearch2(int arr[], int k, int l, int h){ 2. if(l h){ 3. return -1; 4. } 5. int mid = (l + h) / 2; 6. if(k == arr[mid]){ 7. return mid; 8. }else if(k arr[mid]){ 9. binsearch2(arr, k, mid +1, h); 10. }else1/ 6if(k arr[mid]){ 11. binsearch2(arr, k, l, mid - 1); 12. } 13. return -1; 14. } 二、现在考虑复杂一点的二分搜索的问题，当我们遇到这样的数组 a={1, 2, 3, 3, 5, 7, 8}，存在重复的元素，需要从中找出 3 第一次出现的位置，这里 3 第一次出现的位置是 2，《编程珠玑》里给出了很好的分析，二分搜索主要的精髓在于不变式的设计（就是上面的 while 循环条件式）。

太原理工数据结构实验答案

实验一线性表一．目的与要求本次实习的主要目的是为了使学生熟练掌握线性表的基本操作在顺序存储结构和链式存储结构上的实现，提高分析和解决问题的能力。

要求仔细阅读并理解下列例题，上机通过，并观察其结果，然后独立完成后面的实习题。

二．例题问题描述:用链表形式存储一个字符串，插入、删除某个字符，最后按正序、逆序两种方式输出字符串。

输入:初始字符串，插入位置，插入字符，删除字符。

输出:已建立链表（字符串），插入字符后链表，删除字符后链表，逆转后链表。

存储结构:采用链式存储结构算法的基本思想:建立链表当读入字符不是结束符时，给结点分配存储空间，写数据域，将新结点插到表尾；插入字符：根据读入的字符在链表中找插入位置，将新结点插入到该位置之前；删除字符：根据读入的删除字符在链表中找到被删结点后，将其从链表中删除；链表逆转：从链表的第一个结点开始对所有结点处理，将每个结点的前驱变为它的后继；打印链表：从链表的第一个结点开始，依次打印各[运行情况]Input a linktable(a string):abcde↙Build link is :abcdePlease input a char you want to insert after:b↙Please input a char you want to insert:c↙After p insert y,link is:abccdePlease input a char you want to delete:e↙after delete p,link is:abccdOpsite result is :dccba如图显示：实习题：问题描述：设顺序表A中的数据元素递增有序，试写一程序，将x插入到顺序表的适当位置上，使该表仍然有序。

输入：插入前的顺序表，插入的数，插入后的顺序表输出：插入前的顺序表，插入的数，插入后的顺序表存储结构：顺序表存储数据算法基本思想:其实这个题在学C语言时就已经写过了，这里采用顺序表来存储数据。

数据结构实验报告-BST存储结构与折半查找

实验报告课程名称：数据结构与算法课程类型：必修实验项目：树型查找结构与排序方法实验题目：BST存储结构与折半查找一、实验目的1. 理解二叉查找树的存储结构。

2. 掌握BST的插入、删除、查找、排序等多种算法。

3. 掌握折半查找算法。

4. 学会计算BST的查找成功及失败的平均查找长度。

5. 学会计算折半查找的查找成功及失败的平均查找长度。

二、实验要求及实验环境实验要求：1. 设计BST 的左右链存储结构，并实现BST插入（建立）、删除、查找和排序算法。

2. 实现折半查找算法。

3. 实验比较：设计并产生实验测试数据，考察比较两种查找方法的时间性能，并与理论结果进行比较。

以下具体做法可作为参考：4. 第1组测试数据： n=1024个已排序的整数序列（如0至2048之间的奇数）；第2组测试数据：第1组测试数据的随机序列。

5. 按上述两组序列的顺序作为输入顺序，分别建立BST。

6. 编写程序计算所建的两棵BST的查找成功和查找失败的平均查找长度（主要是改造Search算法，对“比较”进行计数），并与理论结果比较。

7. 以上述BST的中序遍历序列作为折半查找的输入，编写程序分别计算折半查找的查找成功和查找失败的平均查找长度，并与理论结果比较。

8. 以上实验能否说明：就平均性能而言，BST的查找与折半查找差不多，为什么？实验环境：codeblocks/Dev-C++三、设计思想（本程序中的用到的所有数据抽象数据性ADT的定义，主程序的流程图及各程序模块之间的调用关系）1. 所用的抽象数据性ADT的定义1）逻辑结构：BST树：二叉查找树是一个满足以下条件的树：任意一个结点的关键字，都大于(小于)其左(右)子树中任意结点的关键字，因此各结点的关键字互不相同按中序遍历二叉查找树所得的中序序列是一个递增的有序序列，因此，二叉查找树可以把无序序列变为有序序列。

同一个数据集合，可按关键字表示成不同的二叉查找树，即同一数据集合的二叉查找树不唯一；但中序序列相同。

分治算法折半查找实验总结

分治算法折半查找实验总结导言：分治算法是一种常用的问题解决方法，其核心思想是将问题划分为更小的子问题进行解决，最后将子问题的解合并得到原问题的解。

折半查找是一种高效的查找算法，适用于有序数组。

本文将结合实验结果对分治算法折半查找进行总结和分析。

一、算法原理折半查找（Binary Search）是一种基于分治思想的查找算法。

假设有一个有序数组arr，要查找的元素为target。

首先，取数组的中间元素mid。

若target等于mid，则查找成功；若target小于mid，则在数组的左半部分继续查找；若target大于mid，则在数组的右半部分继续查找。

通过不断地折半查找，最终可以确定是否存在目标元素，并找到其位置。

二、实验过程为了验证折半查找算法的效果，我们在实验中使用了一个有序数组arr，并设定了不同的查找目标。

实验步骤如下：1. 初始化一个有序数组arr；2. 输入要查找的目标元素target；3. 调用折半查找函数，传入数组arr和目标元素target；4. 根据查找结果输出查找成功或失败的信息。

三、实验结果我们进行了多次实验，分别在不同规模的有序数组中查找不同的目标元素。

以下是实验结果的总结：1. 当目标元素存在于数组中时，折半查找能够准确找到目标元素的位置，并输出查找成功的信息。

这证明了折半查找的正确性和有效性。

2. 当目标元素不存在于数组中时，折半查找会返回查找失败的信息。

这表明算法能够正确判断目标元素的存在与否。

四、实验分析通过实验结果的总结，我们可以得出以下分析：1. 折半查找算法的时间复杂度为O(logn)，其中n为数组的长度。

相比于线性查找算法的时间复杂度O(n)，折半查找具有更高的效率。

2. 折半查找算法要求数组必须是有序的，否则无法正常运行。

因此，在使用折半查找算法之前，需要确保数组的有序性。

3. 折半查找算法对内存空间的要求较低，只需要存储数组和几个变量即可。

这使得折半查找算法适用于大规模数据的查找。

C语言程序设计实验报告(实验大纲+过程)

《C程序设计》实验教学大纲一、适用范围大纲适用信息管理专业本科教学使用。

二、课程名称C程序设计三、学时数与学分总学时：90 总学分：4实验学时：28 实验学分：1四、教学目的和基本要求目的：通过C程序设计实验，培养学生对学习程序设计的兴趣，加深对讲授内容的理解，尤其是通过上机来掌握语法规则，使学生全面了解 C 语言的特点，熟练掌握 C 语言程序设计的基本方法和编程技巧。

基本要求：了解和熟悉C语言程序开发的环境；学会上机调试程序，善于发现程序中的错误，并且能很快地排除这些错误，使程序能正确运行，达到实验知识和理论知识的融会贯通。

上机实验前，学生必须事先根据题目的内容编好程序，然后在实验时输入程序、调试程序、直至运行结果正确为止，上机结束后，应整理出实验报告。

注：带*的实验项目为选做实验项目六、教材、讲义及参考书《C程序设计题解与上机指导》谭浩强主编清华大学出版社七、实验成绩评定办法实验成绩=平时实验表现+实验报告。

实验成绩占总成绩的20%。

实验成绩以等级形式给出，评定等级分优、良、中、及格、不及格五类。

1、平时考核：上机实验前，学生必须事先根据题目的内容编好程序，然后在实验时输入程序、调试程序、直至运行结果正确为止。

在实验中，教师可根据学生编程操作能力、观察和分析及运用知识能力、程序编制正确性以及学生的课堂纪律、实验态度、保持实验室卫生等方面的表现进行综合考核。

2、实验报告：学生实验后应按时完成实验报告。

八、实验教学大纲说明本大纲共安排28学时的实验，其中带*号实验项目为选做实验项目，实际课时为18学时。

实验项目多为设计性实验项目，每个设计性实验项目中都包含数个小的设计性题目，其中带*号的题目为选做题目，有时间和有能力的同学可以选做。

九、实验项目实验一C程序的运行环境和运行一个C程序的方法一、实验目的1.了解Visual C++6.0编译系统的基本操作方法，学会独立使用该系统。

2.了解在该系统上如何编辑、编译、连接和运行一个C程序。

递归问题实验报告

一、实验目的1. 理解递归算法的基本概念和原理。

2. 掌握递归算法的设计方法和实现技巧。

3. 通过具体实例，加深对递归算法在实际问题中的应用。

二、实验内容本次实验主要针对递归算法在排序、查找和数学问题中的应用进行探讨。

1. 排序问题（1）实验目的：使用递归算法实现快速排序。

（2）实验原理：快速排序是一种分而治之的排序算法。

其基本思想是：选取一个基准元素，将数组分为两个子数组，一个子数组的所有元素都比基准元素小，另一个子数组的所有元素都比基准元素大，然后递归地对两个子数组进行快速排序。

（3）实验步骤：① 定义一个递归函数，用于实现快速排序；② 在递归函数中，选择基准元素，并根据基准元素将数组分为两个子数组；③ 递归地对两个子数组进行快速排序；④ 输出排序后的数组。

（4）实验结果：通过实际编程，验证快速排序算法的正确性。

2. 查找问题（1）实验目的：使用递归算法实现折半查找。

（2）实验原理：折半查找是一种基于二分查找思想的递归查找算法。

其基本思想是：将待查找的序列分为两个子序列，然后确定目标值所在子序列，递归地对子序列进行查找。

（3）实验步骤：① 定义一个递归函数，用于实现折半查找；② 在递归函数中，根据目标值与中间元素的比较结果，确定目标值所在子序列；③ 递归地对子序列进行查找；④ 输出查找结果。

（4）实验结果：通过实际编程，验证折半查找算法的正确性。

3. 数学问题（1）实验目的：使用递归算法求解斐波那契数列。

（2）实验原理：斐波那契数列是一个著名的数列，其递推公式为：F(n) = F(n-1) + F(n-2)，其中F(1) = 1，F(2) = 1。

（3）实验步骤：① 定义一个递归函数，用于计算斐波那契数列的第n项；② 在递归函数中，根据n的值，计算斐波那契数列的第n项；③ 输出斐波那契数列的第n项。

（4）实验结果：通过实际编程，验证斐波那契数列递归算法的正确性。

三、实验总结1. 通过本次实验，我们对递归算法的基本概念和原理有了更深入的理解。

折半查找插入排序高斯消去法实验报告

算法设计与分析基础应用数学学院二零一六年六月实验三折半查找插入排序和高斯消去法一、实验性质由算法伪代码设计java代码二、实验学时3学时三、实验目的1、理解折半查找的算法过程，并设计相应的java程序。

2、理解插入排序的算法过程，并设计相应的java程序。

3、理解高斯消去法的算法过程，并设计相应的java程序。

四、实验要求实验一、折半查找：由用户在输入要查询的数字，经运行程序，实现非递归的折半查找，并输出用户所查数字所在位置。

实验二、插入排序：由用户输入一串数字（7个），按照提示要求输入。

经插入排序，将用户输入数字进行排序输出，并可以给出出入排序过程。

实验三、高斯消去法：给定一个方程组的系数矩阵及一个解向量，通过高斯消去法，将矩阵变为上三角矩阵，从而快速求出矩阵所在方程的解。

五、实验内容实验一、折半查找：1、实现非递归的折半查找。

2、输入：一个升序数组a[]，和一个需要查找的数组k。

3、输出：一个数组k元素的下标，如果没有查找到，则提示用户。

实验二、插入排序：1、用插入排序对给定的数字进行排序。

2、输入：n个可以排序元素构成的数组a[]；3、输出：非降序的依次输出排列数组a[]。

实验三、高斯消去法：1、对一个方程组的系数矩阵a[][]，应用高斯消元法。

2、用该方程组右边的值构成的向量b来扩展矩阵。

3、输出：一个可以代替a[][]的上三角等阶矩阵图，相应的右边的值位于最后一列。

实验报告实验一折半查找：Java代码：package cn;import java.util.Scanner;public class ZheBan {public static void main(String[] args){int []a={3,14,27,31,39,42,55,70,74,81,85,93,98};Scanner can = new Scanner(System.in);System.out.println("请输入要查找的数字：");int k=can.nextInt();int l=0,r=a.length;while(l<=r){int m;m=(l+r)/2;if(k==a[m]){System.out.print("您查找的数字在第"+(m+1)+"位");break;}else if(k<a[m]){r=m-1;}else {l=m+1;}}if(l>r){System.out.print("未找到您要查找的数字。

C语言程序设计100例之(21)：折半查找

C语言程序设计100例之（21）：折半查找例21 折半查找问题描述顺序查找是一种最简单和最基本的检索方法。

其基本思想是：从检索表的一端（如表中第一个记录或最后一个记录）开始，逐个进行记录的关键字和给定值的比较。

若某个记录的关键字和给定值比较相等，则查找成功；否则，若直至检索表的另一端（如最后一个记录或第一个记录），其关键字和给定值比较都不等，则表明表中没有待查记录，查找不成功。

顺序查找可以写成一个简单的一重循环，循环中依次将检索表（不妨设为数组a）中的元素与给定值比较，若相等，用break退出循环。

算法描述为：for (i=0; i< n;i++)if (a[i]==x) break;这样，循环结束后，若循环控制变量i小于数组元素个数n，则查找成功；否则，查找失败。

顺序查找实现简单，但效率不高。

当待查找序列有序时，即各检索表中元素的次序是按其记录的关键字值的大小顺序存储的。

此时采用折半查找会大幅提高查找效率。

折半查找的基本思想是先确定待查数据的范围（区间），然后逐步缩小范围直到找到或找不到该记录为止。

具体做法是：先取数组中间位置的数据元素与给定值比较。

若相等，则查找成功；否则，若给定值比该数据元素的值小（或大），则给定值必在数组的前半部分（或后半部分），然后在新的查找范围内进行同样的查找。

如此反复进行，直到找到数组元素值与给定值相等的元素或确定数组中没有待查找的数据为止。

因此，折半查找每查找一次，或成功，或使查找数组中元素的个数减少一半，当查找数组中不再有数据元素时，查找失败。

输入一个整数，在给定的有序数组中查找该整数是否存在，若存在，给出其数组的下标；若不存在，输出查找不成功信息。

输入格式第一行是一个正整数N (1 ≤N ≤100000)，代表数组中元素的个数。

第二行有N个整数，这N个整数从小到大排列好了。

第三行是一个整数M，代表待查找元素的个数。

接下来的M行，每行有一个整数x，表示每个待查找的元素。

折半查找程序实验报告

1. 理解折半查找（也称为二分查找）的原理和步骤。

2. 掌握在计算机程序中实现折半查找的方法。

3. 通过实验加深对折半查找算法的理解，并提高编程能力。

二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.83. 开发工具：PyCharm三、实验原理折半查找是一种在有序数组中查找特定元素的算法。

其基本思想是将查找区间分为两半，然后判断目标值位于哪一半区间内，再对那一半区间进行同样的操作，直到找到目标值或查找区间为空。

折半查找的步骤如下：1. 初始化两个指针，low指向数组的第一个元素，high指向数组的最后一个元素。

2. 计算中间位置mid = (low + high) / 2。

3. 判断中间位置的元素是否为目标值：a. 如果mid位置的元素等于目标值，则查找成功。

b. 如果mid位置的元素大于目标值，则将high指针减1，继续查找左半区间。

c. 如果mid位置的元素小于目标值，则将low指针加1，继续查找右半区间。

4. 重复步骤2和3，直到找到目标值或low大于high，表示查找失败。

四、实验内容1. 编写一个折半查找的Python程序。

2. 使用该程序对不同的有序数组进行查找操作，并记录查找时间。

3. 分析折半查找算法的性能。

1. 创建一个有序数组。

2. 定义折半查找函数。

3. 调用折半查找函数，并记录查找结果和查找时间。

4. 修改数组，重复步骤3。

5. 分析实验结果。

六、实验代码```pythondef binary_search(arr, target):low = 0high = len(arr) - 1while low <= high:mid = (low + high) // 2if arr[mid] == target:return midelif arr[mid] > target:high = mid - 1else:low = mid + 1return -1# 创建有序数组arr = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]# 查找目标值target = 7# 调用折半查找函数result = binary_search(arr, target)# 输出查找结果if result != -1:print(f"元素{target}在数组中的位置为：{result}")else:print(f"元素{target}在数组中不存在")```七、实验结果与分析1. 对于不同的有序数组，折半查找函数均能正确地找到目标值或返回-1表示查找失败。

折半查找法实验报告

1. 理解折半查找法的基本原理和适用条件。

2. 掌握折半查找法的实现方法。

3. 通过实验验证折半查找法的效率。

二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发工具：Visual Studio 2019三、实验内容1. 实现折半查找法。

2. 对折半查找法进行测试，包括：a. 对已排序的数组进行查找；b. 对未排序的数组进行查找；c. 查找不存在的元素。

四、实验步骤1. 定义一个整型数组，并对其进行排序。

2. 实现折半查找函数，包括：a. 定义折半查找函数的参数，包括数组、目标值和数组的长度；b. 实现折半查找算法；c. 返回查找结果，包括找到的位置和未找到。

3. 对已排序的数组进行查找，输出查找结果。

4. 对未排序的数组进行查找，输出查找结果。

5. 对不存在的元素进行查找，输出查找结果。

```cpp#include <iostream>#include <algorithm>// 折半查找函数int binarySearch(const int arr, int target, int left, int right) { while (left <= right) {int mid = left + (right - left) / 2;if (arr[mid] == target) {return mid; // 找到目标值，返回位置} else if (arr[mid] < target) {left = mid + 1; // 在右侧查找} else {right = mid - 1; // 在左侧查找}}return -1; // 未找到目标值}int main() {// 测试数组int arr[] = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};int n = sizeof(arr) / sizeof(arr[0]);int target = 11; // 目标值// 对数组进行排序std::sort(arr, arr + n);// 对已排序的数组进行查找int index = binarySearch(arr, target, 0, n - 1);if (index != -1) {std::cout << "已排序数组中找到目标值：" << target << "，位置为：" << index << std::endl;} else {std::cout << "已排序数组中未找到目标值：" << target << std::endl;}// 对未排序的数组进行查找int unsortedArr[] = {9, 5, 3, 7, 1, 11, 13, 17, 15, 19};int unsortedIndex = binarySearch(unsortedArr, target, 0, n - 1);if (unsortedIndex != -1) {std::cout << "未排序数组中找到目标值：" << target << "，位置为：" << unsortedIndex << std::endl;} else {std::cout << "未排序数组中未找到目标值：" << target << std::endl;}// 对不存在的元素进行查找int notExistTarget = 20;int notExistIndex = binarySearch(arr, notExistTarget, 0, n - 1);if (notExistIndex != -1) {std::cout << "数组中找到目标值：" << notExistTarget << "，位置为：" << notExistIndex << std::endl;} else {std::cout << "数组中未找到目标值：" << notExistTarget <<std::endl;}return 0;}```六、实验结果与分析1. 对已排序的数组进行查找，折半查找法成功找到了目标值，查找效率较高。

编程实现折半查找算法。 -回复

编程实现折半查找算法。

-回复中括号内的内容为主题：编程实现折半查找算法一、介绍折半查找算法，也被称为二分查找算法，是一种高效的查找算法。

它可以在有序的数据集合中查找特定元素的位置，其时间复杂度为O(log n)。

本文将带你一步一步了解并编程实现折半查找算法。

二、算法思想1. 确定查找区间的起始和结束位置。

2. 计算区间的中间位置。

3. 如果中间位置的元素等于目标元素，则查找成功返回该位置。

4. 如果中间位置的元素大于目标元素，则在前半部分继续查找。

5. 如果中间位置的元素小于目标元素，则在后半部分继续查找。

6. 重复步骤2-5，直到找到目标元素或者区间为空。

三、代码实现下面是使用Python语言实现折半查找算法的代码：pythondef binary_search(arr, target):low = 0high = len(arr) - 1while low <= high:mid = (low + high) 2guess = arr[mid]if guess == target:return midelif guess > target:high = mid - 1else:low = mid + 1return -1代码说明：1. 函数`binary_search`接受一个有序数组`arr`和目标元素`target`作为参数。

2. 初始化变量`low`为区间左端的索引，`high`为区间右端的索引。

3. 使用`while`循环在区间内进行查找，直到找到目标元素或者区间为空。

4. 计算区间的中间位置`mid`，并将该位置的元素赋值给变量`guess`。

5. 比较`guess`和`target`的大小，如果相等，则查找成功返回`mid`。

6. 如果`guess`大于`target`，则目标元素在前半部分，将`high`更新为`mid - 1`。

7. 如果`guess`小于`target`，则目标元素在后半部分，将`low`更新为`mid + 1`。

顺序查找与折半查找实验报告

顺序查找与折半查找实验报告姓名：许严班级：计122 学号：12130230501.问题描述实现顺序查找与折半查找的程序设计，并比较两种查找方法的性能。

2.基本要求（1）设计查找表的存储结构。

（2）设计查找算法，对同一组实验数据实现查找。

（3）输入：查找表的数据个数和数据由键盘输入，数据元素类型为整型，以菜单方式选择顺序查找或折半查找中的一种，并由键盘输入想要查找的数据。

（4）输出：若查找成功输出其位置和查找次数，若查找失败输出信息和查找次数。

3.实现提示（1）存储设计由于要对一组实验数据实现顺序查找与折半查找，只能采用顺序表存放查找表数据，存储结构定义与教材一致。

设关键字类型为整型，利用前面实验建立的线性表类，生成一个线性表对象，线性表中的数据个数、数据以及待查找的数据由键盘输入。

（2）算法设计由于折半查找法要求数据是有序的，可设立一个创建有序顺序表的函数Sort(int*fp,int length)；设立一个顺序查找函数SequenSearch(int*fp,int length)实现顺序查找；设立一个折半查找函数实现折半查找；编写一个主函数main(),在主函数中设计一个简单的菜单，根据用户的选择分别调用顺序查找和折半查找算法。

4.程序设计(1) using namespace std;struct Node{int key;};class SSearch{private:Node *ST;int len;public:SSearch();~SSearch();void Create(int n);void Display();void Sort();void Sort_n(int arr[]);void SequenceSearch(int key);void Search(int key);};SSearch::SSearch(){ST=0;len=0;}SSearch::~SSearch(){if(ST) delete[]ST;len=0;}void SSearch::Create(int n){len=n;ST=new Node[len];cout<<"请输入"<<n<<"个数据元素：\n";int i=0;while(i<len){cin>>ST[i].key;i++;}cout<<"静态表创建成功！：）\n";}void SSearch::Display(){cout<<"表中数据元素依次为：\n";for(int i=0;i<len;i++)cout<<ST[i].key<<'\t';cout<<endl;}voidSSearch::Sort() //冒泡排序{int t;for(int i=1;i<len;i++){bool y=1;for(int j=0;j<len-i;j++){if(ST[j].key>ST[j+1].key){t=ST[j].key;ST[j].key=ST[j+1].key;ST[j+1].key=t;y=0;}}if(y) return;}}void SSearch::Sort_n(int arr[]){int t;for(int i=1;i<len;i++){bool y=1;for(int j=0;j<len-i;j++){if(arr[j]>arr[j+1]){t=arr[j];arr[j]=arr[j+1];arr[j+1]=t;y=0;}}if(y) return;}}void SSearch::SequenceSearch(int key){ST[0].key=key;int count=1,i=len-1; //计数边梁count为1的原因是下面的for语句先判定在count++ for(;ST[i].key!=key;i--,count++);if(i){cout<<"查找成功！\n在顺序表的第"<<i<<"个位置（从0开始），一共比较了"<<count<<"次。

折半查找的实验报告

折半查找的实验报告折半查找的实验报告引言：在计算机科学领域，查找是一项基本操作。

而折半查找，也被称为二分查找，是一种高效的查找算法。

本实验旨在通过实际操作和数据分析，探究折半查找算法的原理和性能。

实验设计：本次实验使用C++语言来实现折半查找算法，并通过编写测试程序来验证算法的正确性和性能。

我们使用了一个已排序的整数数组，其中包含了10000个元素。

实验过程中，我们将记录算法的查找次数和运行时间，并与线性查找算法进行对比。

实验步骤：1. 首先，我们定义一个包含10000个已排序整数的数组，并选择一个待查找的目标值。

2. 接下来，我们实现折半查找算法。

该算法的基本思想是将待查找的目标值与数组的中间元素进行比较，如果相等则返回找到的位置，如果目标值小于中间元素，则在左半部分继续查找，否则在右半部分继续查找。

重复这个过程，直到找到目标值或者确定目标值不存在。

3. 我们编写测试程序，分别使用折半查找算法和线性查找算法来查找目标值，并记录查找次数和运行时间。

4. 重复多次实验，以获得更准确的结果。

同时，我们还可以改变目标值的位置，观察算法的性能变化。

实验结果：经过多次实验，我们得到了如下结果：- 折半查找算法的平均查找次数为log2(10000)≈13次，而线性查找算法的平均查找次数为10000次。

- 折半查找算法的平均运行时间为0.0001秒，而线性查找算法的平均运行时间为0.01秒。

- 当目标值位于数组的中间位置时，折半查找算法的性能最佳；而当目标值位于数组的两端时，折半查找算法的性能最差。

讨论与分析：通过对实验结果的分析，我们可以得出以下结论：1. 折半查找算法的时间复杂度为O(log n)，而线性查找算法的时间复杂度为O(n)。

因此，折半查找算法在大规模数据中的查找效率远高于线性查找算法。

2. 折半查找算法适用于已排序的数据集，而线性查找算法对数据集的有序性没有要求。

因此，在已排序的数据集中使用折半查找算法可以提高查找效率。

查找-静态查找表-折半查找（有序表）

查找-静态查找表-折半查找（有序表）⽂字描述以有序表表⽰静态查找表时，可⽤折半查找算法查找指定元素。

折半查找过程是以处于区间中间位置记录的关键字和给定值⽐较，若相等，则查找成功，若不等，则缩⼩范围，直⾄新的区间中间位置记录的关键字等于给定值或者查找区间的⼤⼩⼩于零时(表明查找不成功)为⽌。

⽰意图算法分析折半查找过程可以⽤⼀颗⼆叉判定树来表⽰，⽽具有n个结点的判定树的深度为[log2n]+1，所以折半查找法在查找成功和不成功时，与给定值进⾏⽐较的关键字个数都不会超过[log2n]+1. 现讨论折半查找算法的平均查找长度。

为讨论⽅便，假设有序表长度为n=2h-1，则描述折半查找的判定树是深度为h的满⼆叉树。

假设每个记录的查找概率相等Pi = 1/n, 则折半查找查找成功的平均查找长度当n⾜够⼤时，平均查找长度约为log2(n+1)-1 可见，折半查找的效率⽐顺序查找要⾼，但是折半查找只适⽤于有序表，且限于顺序存储结构，对线性链表⽆法有效地进⾏折半查找。

代码实现1/*2 ./a.out 5 13 19 21 37 56 64 75 80 88 923*/4 #include <stdio.h>5 #include <stdlib.h>67#define EQ(a, b) ((a) == (b))8#define LT(a, b) ((a) < (b))9#define LQ(a, b) ((a) <= (b))10#define MAX_SIZE 5011#define DEBUG1213 typedef int KeyType;14 typedef char InfoType;15/*数据元素类型定义*/16 typedef struct{17//关键字域18 KeyType key;19//其他域20 InfoType otherinfo;21 }ElemType;22/*静态查找表的顺序存储结构*/23 typedef struct{24//数据元素存储空间基址，建表时按实际长度分配，0号单元留空25 ElemType *elem;26//表长度27int length;28 }SSTable;2930/*折半查找算法31 *32 *顺序表中的元素应该按照由⼩到⼤顺序排列.33 *34 *在顺序表ST中顺序查找其关键字等于key的数据元素。

折半搜索实验报告

软件学院数据结构课程设计报告设计题目: 折半搜索学号姓名年级专业软件工程班级学期日期: 年月日设计报告内容大纲:需求描述：a. 结合课程学习内容和自己理解设计功能，准确演示算法思想。

支持演示中间过程。

能单步演示。

b.软件要易用。

c.软件可以对输入用例案例重复演示。

d.输入的用例数据可编辑。

e. 软件要健壮，对非法的输入能给出合适的提示，不能直接导致软件崩溃。

实现思想:折半查找的算法思想是将数列按有序化(递增或递减)排列，查找过程中采用跳跃式方式查找，即先以有序数列的中点位置为比较对象，如果要找的元素值小于该中点元素，则将待查序列缩小为左半部分，否则为右半部分。

通过一次比较，将查找区间缩小一半。

折半查找是一种高效的查找方法。

它可以明显减少比较次数，提高查找效率。

但是，折半查找的先决条件是查找表中的数据元素必须有序。

数据结构设计：1. 首先确定整个查找区间的中间位置mid = （ left + right ）/ 22. 用待查关键字值与中间位置的关键字值进行比较，若相等，则查找成功，若大于，则在后（右）半个区域继续进行折半查找，若小于，则在前（左）半个区域继续进行折半查找3. 对确定的缩小区域再按折半公式，重复上述步骤。

最后，得到结果：要么查找成功，要么查找失败。

折半查找的存储结构采用一维数组存放。

功能设计：1.单步执行，可显示算法实现全过程。

2.随机生成数组。

3.可选数组元素个数。

4.可重复执行运行环境说明：java系统测试用例收获及体会通过这次的程序设计增强了我的动手能力，修改程序中错误的能力。

让我深刻的感受到做一个程序首先要满足客户的要求，程序要简便，易操作，要完全考录到别人应用的感受。