实验二 折半查找算法设计
折半查找（二分查找）
折半查找（⼆分查找）折半查找（⼆分查找）（1）定义以及思想(有序)折半查找法是效率较⾼的⼀种查找⽅法。
假设已经按照从⼩到⼤的顺序排列好的五个整数a0-a4,要查找的数是X，其基本思想是：设查找数据的范围下限为l=1,上限为l=5,求中点m=(1+h)/2,⽤x与中点元素am⽐较，若x=am,即找到，停⽌查找；否则，若x>am,替换下限l=m+1,到下半段继续查找；若x<am,即换上限h=m-1,到上半段继续查找，如此重复前⾯的过程直到找到或者l>h为⽌。
如果l>h,说明没有此数，打印找不到信息，程序结束（2）算法的实现//⼆分查找必须是有顺序的#include<stdio.h>int BinSearch(int *a,int n,int x);int main(void){int num,result;int arr[] = {1,2,3,4,5,6,7,8,9,10};printf("请输⼊你要查找的数据：");scanf("%d",&num);result=BinSearch(arr,10,num);if(result==-1)printf("没找到这个数据\n");elseprintf("在下标为%d的位置找到这个数num=%d\n",result,num);return 0;}int BinSearch(int *a,int n,int x){int low,high,mid;low=0;high = n-1;while(low<=high){//其中mid = (low+high)/2这个的位置。
因为在外部函数中并不能确定是否low⼀定⼩于high的mid = (low+high)/2;if(x>a[mid])low = mid+1;else if(x<a[mid])high = mid -1;elsereturn mid;}return -1; }。
算法分析与设计-实验二 二分查找实验报告
南阳理工学院算法分析与设计实验报告册开课学院：计算机与软件学院实验项目：实验2：二分查找实验时间：第6周周3（3,4）节实验地点： 15#515指导教师：学生姓名：学生学号：专业班级：2020-2021学年第1学期一、实验目的1.掌握分治算法的基本设计思路、适用条件2.非递归实现二分查找3.递归实现二分查找二、实验平台1.JDK1.82.IDEA三、实验内容1.二分查找：给定N个数据和待查找的数据x，采用二分查找算法来搜索x，输出x在N个数据中的位置。
四、算法设计1.问题分析根据问题需求可知，给定N个数据和待查找的数据X，使用二分查找算法来搜索x。
要使用二分查找算法，需要使数据有序，故可以将产生的数据进行排序（升序），之后取中间值记为data[mid]与x进行比较，如果x大于data[mid]则向数据的右侧再取mid进行比较问题的终止条件为左指针>右指针2.算法描述二分查找法（Binary Search）算法，也叫折半查找算法。
二分查找针对的是一个有序的数据集合，查找思想有点类似于分治思想。
每次都通过跟区间的中间元素对比，将带查找的区间缩小为之前的一半，知道找到要查找的元素，或者区间被缩小为0。
二分查找是一种非常非常高效的查询算法，时间复杂度为O(logn)。
3.算法求解步骤第一步：对原数据data进行排序第二步：设立左右指针left和right，左指针指向数组头部、右指针指向数组尾部第三步：根据left和right计算出mid，并判断data[mid]与目标值target的大小第四步：如果data[mid]大于target，则向右侧搜寻改变left指针值第五步：如果data[mid]小于target，则向左搜寻改变right指针值第六步：算法终止条件为找到target元素或者left>right四、算法源码public class BinarySearch {public static void main(String[] args) {int[] data = getData(10);System.out.println(Arrays.toString(data));// binarySearch_NotRecursion(data,data[9]);binarySearch_Recursion(data,data[3],0,data.length - 1);}// 生成待查找数据有序public static int[] getData(int length){Random random = new Random();int[] data = new int[length];for(int i = 0;i<length;i++){data[i] = random.nextInt(10*length);}Arrays.sort(data);return data;}// 二分查找非递归形式public static void binarySearch_NotRecursion(int[] data,int target){int left = 0;int right = data.length - 1;while(left <= right){int mid = (left + right) / 2;if (data[mid] == target){System.out.println("查找到需要的元素："+data[mid]+",在原数组中的下标为："+mid);return;}else if (data[mid] < target){left = mid + 1;}else if (data[mid] > target){right = mid - 1;}}System.out.println("未找到需要搜索的元素");}// 二分查找递归式public static void binarySearch_Recursion(int[] data,int target,int left,int right){if (left > right){System.out.println("未找到需要搜索的元素");五、测试数据由程序生成伪随机数进行测试[23, 28, 28, 39, 47, 72, 75, 77, 83, 92] 39查找到需要的元素：39,在原数组中的下标为：3[6, 16, 19, 22, 43, 64, 66, 78, 80, 90] 22查找到需要的元素：22,在原数组中的下标为：3 [15, 25, 54, 55, 70, 80, 83, 84, 87, 95] 95查找到需要的元素：95,在原数组中的下标为：9[5, 23, 40, 48, 48, 54, 56, 68, 76, 84] 10000 未找到需要搜索的元素六、程序运行结果（要求：截图说明算法运行的结果）测试1：（递归方式）测试2：（非递归方式）八、实验总结1.实验中遇到的问题及解决方法所遇问题：程序设计阶段递归方式最初每次都将数组截取指定部分进行查找，最终得到的结果难以获取目标元素在原数组的下标解决方法：在每次递归时将整个完整数组作为参数递归，但每次限定left和right的值，逻辑上将数组划分为左右部分2.实验收获了解到二分查找的算法思想学会二分查找的基本简单使用。
折半搜索实验报告
软件学院数据结构课程设计报告设计题目: 折半搜索学号姓名年级专业软件工程班级学期日期: 年月日设计报告内容大纲:需求描述：a. 结合课程学习内容和自己理解设计功能，准确演示算法思想。
支持演示中间过程。
能单步演示。
b.软件要易用。
c.软件可以对输入用例案例重复演示。
d.输入的用例数据可编辑。
e. 软件要健壮，对非法的输入能给出合适的提示，不能直接导致软件崩溃。
实现思想:折半查找的算法思想是将数列按有序化(递增或递减)排列，查找过程中采用跳跃式方式查找，即先以有序数列的中点位置为比较对象，如果要找的元素值小于该中点元素，则将待查序列缩小为左半部分，否则为右半部分。
通过一次比较，将查找区间缩小一半。
折半查找是一种高效的查找方法。
它可以明显减少比较次数，提高查找效率。
但是，折半查找的先决条件是查找表中的数据元素必须有序。
数据结构设计：1. 首先确定整个查找区间的中间位置mid = （ left + right ）/ 22. 用待查关键字值与中间位置的关键字值进行比较，若相等，则查找成功，若大于，则在后（右）半个区域继续进行折半查找，若小于，则在前（左）半个区域继续进行折半查找3. 对确定的缩小区域再按折半公式，重复上述步骤。
最后，得到结果：要么查找成功，要么查找失败。
折半查找的存储结构采用一维数组存放。
功能设计：1.单步执行，可显示算法实现全过程。
2.随机生成数组。
3.可选数组元素个数。
4.可重复执行运行环境说明：java系统测试用例收获及体会通过这次的程序设计增强了我的动手能力，修改程序中错误的能力。
让我深刻的感受到做一个程序首先要满足客户的要求，程序要简便，易操作，要完全考录到别人应用的感受。
数据结构实验报告折半查找
数据结构实验报告折半查找1. 引言数据结构是计算机科学中非常重要的一门课程，它研究的是数据的组织方式、存储结构和算法设计等内容。
在数据结构中，折半查找（Binary Search）是一种常用的查找算法，可以在有序的数据集合中快速找到目标元素。
本实验报告将介绍折半查找算法的原理、实现过程以及在不同数据规模下的性能分析。
2. 折半查找原理折半查找是一种分而治之的算法，通过比较目标元素与中间元素的大小关系，不断将待查找范围缩小一半，并在所需的时间内逐步逼近目标元素。
具体的折半查找算法如下：1. 设置左边界l和右边界r，初始时l=0，r=n-1（n为数据集合的长度）；2. 计算中间元素的下标mid = (l + r) / 2；3. 比较目标元素与中间元素的值，若相等，则返回目标元素的下标；4. 若目标元素小于中间元素的值，则将右边界r更新为mid-1；5. 若目标元素大于中间元素的值，则将左边界l更新为mid+1；6. 重复步骤2-5，直到找到目标元素或区间缩小为空。
折半查找的时间复杂度为O(log n)，比顺序查找的时间复杂度O(n)要小得多。
3. 折半查找的实现实现折半查找的关键就是要确定好左边界l和右边界r的初始值，并在每个循环中更新这两个边界的值。
下面是使用Python语言实现折半查找的代码示例：```pythondef binary_search(arr, target):l = 0r = len(arr) - 1while l <= r:mid = (l + r) // 2if arr[mid] == target:return midelif arr[mid] < target:l = mid + 1else:r = mid - 1return -1```在上述代码中，我们通过设置左边界l和右边界r来确定待查找范围。
通过不断更新这两个边界的值，最终可以找到目标元素的位置。
如果找不到目标元素，则返回-1表示查找失败。
折半查找算法及分析（手工过程）
折半查找算法及分析（⼿⼯过程）折半查找的⼿⼯过程：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时条件⼀直成⽴就会出现问题的！。
折半查找算法及程序实现教案
折半查找算法及程序实现教案教案：折半查找算法及程序实现一、教学目标1.了解折半查找算法的原理和流程；2.掌握折半查找算法的程序实现；3.能够分析和评估折半查找算法的时间复杂度。
二、教学内容1.折半查找算法的原理和流程；2.折半查找算法的程序实现；3.折半查找算法的时间复杂度分析。
三、教学过程1.导入，引入折半查找算法的背景和应用场景。
（5分钟）2.讲解折半查找算法的原理和流程。
（10分钟）折半查找算法，也称为二分查找算法，是一种分治思想的算法。
其运行时要求待查找数据必须是有序的。
基本思想是将待查找的数据与中间位置的数据进行比较，若相等则查找成功，若不相等则根据大小关系在前半部分或后半部分查找，如此不断缩小查找范围，直到找到目标元素或查找范围为空。
1）取查找范围的首尾元素确定中间位置元素，并与目标元素进行比较；2）若中间位置元素与目标元素相等，则查找成功，返回中间位置；3）若中间位置元素大于目标元素，则在前半部分继续查找，重复步骤1）；4）若中间位置元素小于目标元素，则在后半部分继续查找，重复步骤1）；5）若找到目标元素，则返回其位置，否则返回查找失败。
3.分组讨论与实践。
（15分钟）将学生分成若干小组，让每个小组分别完成以下任务：-根据讲解的折半查找算法原理，结合自己的理解，用自然语言描述折半查找算法；-编写折半查找算法的递归实现；-编写折半查找算法的非递归实现；-利用给定的有序数组，测试实现的算法是否正确。
4.小组展示与讨论。
（15分钟）每个小组派代表上台展示他们的实现，并陈述实现的思路和步骤。
其他小组可对其实现进行评议和提问，共同讨论折半查找算法的优化和改进。
5.整合和总结。
（10分钟）将小组讨论的结果整合起来，总结折半查找算法的特点和程序实现的要点。
6.展示折半查找算法的时间复杂度分析。
（10分钟）通过一张时间复杂度的图示，讲解折半查找算法的时间复杂度是log(n)级别的，并与线性查找算法进行对比，强调折半查找算法的高效性。
折半查找的实验报告
一、实验目的1. 理解折半查找算法的基本原理。
2. 掌握折半查找算法的实现方法。
3. 分析折半查找算法的时间复杂度和空间复杂度。
4. 比较折半查找算法与顺序查找算法的性能差异。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.83. 开发工具：PyCharm三、实验原理折半查找算法，又称二分查找算法，是一种在有序数组中查找特定元素的算法。
其基本原理是将待查找的元素与数组的中间元素进行比较，若相等，则查找成功；若小于中间元素，则在数组的左半部分继续查找；若大于中间元素，则在数组的右半部分继续查找。
重复此过程，直到找到目标元素或查找失败。
折半查找算法的时间复杂度为O(log2n)，空间复杂度为O(1)。
四、实验步骤1. 创建一个有序数组。
2. 实现折半查找算法。
3. 比较折半查找算法与顺序查找算法的性能差异。
五、实验代码```pythondef binary_search(arr, target):left, right = 0, len(arr) - 1while left <= right:mid = (left + right) // 2if arr[mid] == target:return midelif arr[mid] < target:left = mid + 1else:right = mid - 1return -1def sequential_search(arr, target):for i in range(len(arr)):if arr[i] == target:return ireturn -1# 创建有序数组arr = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]# 查找目标元素target = 7# 折半查找index_binary = binary_search(arr, target)# 顺序查找index_sequential = sequential_search(arr, target) # 比较性能import timestart_time = time.time()binary_search(arr, target)end_time = time.time()binary_time = end_time - start_timestart_time = time.time()sequential_search(arr, target)end_time = time.time()sequential_time = end_time - start_timeprint(f"折半查找结果：索引 {index_binary}")print(f"顺序查找结果：索引 {index_sequential}")print(f"折半查找耗时：{binary_time} 秒")print(f"顺序查找耗时：{sequential_time} 秒")```六、实验结果与分析1. 折半查找结果：索引 32. 顺序查找结果：索引 33. 折半查找耗时：0.0002 秒4. 顺序查找耗时：0.0005 秒实验结果表明，折半查找算法在查找相同目标元素时，耗时明显低于顺序查找算法。
《折半查找算法》的教学设计及反思
《折半查找算法》的教学设计及反思.江苏省白蒲高级中学刘兴圣226511授课题目：折半查找算法适应范围：高一年级所属科目：教科版高中信息技术选修模块——算法与程序设计模块授课章节：第三章第3节《在数组中查找数据》教学设计（一）教学目标知识与技能：让学生理解折半查找法的基本思想，并能够编写程序代码。
过程与方法：带领学生一同分析问题、体会理解算法设计思想，先掌握编写关键性语句，再到完整程序的书写，并最终通过分析代码进一步加深理解折半查找算法的设计思想。
让学生从中逐渐学会解决问题的基本方法。
情感态度与价值观：在分析折半查找算法的过程中，引导学生积极思考和分析问题，培养学生严谨的思维习惯。
通过各组讨论、实践活动，养成良好的与人协作交流能力。
（二）教材分析教学重点：以图示法方式，演示折半查找算法的基本思想。
教学难点：由折半查找算法的思想到程序代码编写的转换，尤其是其中关键性语句的编写是教学中的难点。
（三）学情分析学习对象是高一学生，本节知识内容是在学习了数组的相关知识和顺序查找算法之后进行的，由于折半查找算法逻辑性比较强，同时学生对算法的相关概念还比较陌生，基础相对欠缺，以及学生的差异比较大，所以在教学过程中尽量要放慢讲解的速度，循序渐进的展开知识点要素，让学生能够对相关的问题进行充分思索、分析，再到问题解决。
（四）教学策略创设趣味问题情境，引导学生了解什么是折半查找算法，以图示法方式来演示折半查找算法的基本思想，并以伪代码形式描述算法中的关键性语句，最终到完整程序代码的书写。
对课题中的关键环节采用日常生活问题引入，让学生通过比较，由浅入深地引导学生思考、讨论。
通过讲授、演示观察、讨论相结合，充分调动学生的主观能动性，以达到主动式学习、探究性学习。
（五）教学方法：图示法，讲授法。
（六）教学准备：多媒体教室。
（七）课时安排：一课时教学过程一、导入（2~3分钟）上一节课我们一起学习了顺序查询法，知道它一般应用在这种情况之下：待查数据表没有顺序，且数据表的长度比较短。
折半查找算法_实验报告
一、实验目的1. 理解折半查找算法的基本原理和实现方法。
2. 掌握在C语言中实现折半查找算法的技巧。
3. 比较折半查找算法与其他查找算法（如顺序查找）的性能差异。
4. 应用折半查找算法解决实际问题。
二、实验环境1. 编程语言：C语言2. 开发环境：Visual Studio Code3. 操作系统：Windows 10三、实验原理折半查找算法，又称二分查找算法，是一种在有序数组中查找特定元素的查找方法。
其基本原理如下：1. 将查找的有序数组分为左右两部分。
2. 比较查找元素与中间元素的大小关系。
3. 如果查找元素等于中间元素，则查找成功。
4. 如果查找元素小于中间元素，则在左半部分继续查找。
5. 如果查找元素大于中间元素，则在右半部分继续查找。
6. 重复步骤2-5，直到找到目标元素或查找范围为空。
四、实验内容1. 实现折半查找算法。
2. 比较折半查找算法与顺序查找算法的性能。
3. 应用折半查找算法解决实际问题。
五、实验步骤1. 创建一个有序数组。
2. 输入要查找的元素。
3. 使用折半查找算法查找目标元素。
4. 输出查找结果。
六、实验代码```c#include <stdio.h>// 折半查找算法int binary_search(int arr[], int left, int right, int target) { 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;printf("请输入要查找的元素：");scanf("%d", &target);int index = binary_search(arr, 0, n - 1, target);if (index != -1) {printf("找到元素 %d 在数组中的位置：%d\n", target, index);} else {printf("未找到元素 %d\n", target);}return 0;}```七、实验结果与分析1. 折半查找算法的时间复杂度为O(log2n)，而顺序查找算法的时间复杂度为O(n)。
折半查找的实验报告
折半查找的实验报告折半查找的实验报告引言：在计算机科学领域，查找是一项基本操作。
而折半查找，也被称为二分查找，是一种高效的查找算法。
本实验旨在通过实际操作和数据分析，探究折半查找算法的原理和性能。
实验设计：本次实验使用C++语言来实现折半查找算法，并通过编写测试程序来验证算法的正确性和性能。
我们使用了一个已排序的整数数组，其中包含了10000个元素。
实验过程中，我们将记录算法的查找次数和运行时间，并与线性查找算法进行对比。
实验步骤：1. 首先，我们定义一个包含10000个已排序整数的数组，并选择一个待查找的目标值。
2. 接下来，我们实现折半查找算法。
该算法的基本思想是将待查找的目标值与数组的中间元素进行比较，如果相等则返回找到的位置，如果目标值小于中间元素，则在左半部分继续查找，否则在右半部分继续查找。
重复这个过程，直到找到目标值或者确定目标值不存在。
3. 我们编写测试程序，分别使用折半查找算法和线性查找算法来查找目标值，并记录查找次数和运行时间。
4. 重复多次实验，以获得更准确的结果。
同时，我们还可以改变目标值的位置，观察算法的性能变化。
实验结果：经过多次实验，我们得到了如下结果：- 折半查找算法的平均查找次数为log2(10000)≈13次，而线性查找算法的平均查找次数为10000次。
- 折半查找算法的平均运行时间为0.0001秒，而线性查找算法的平均运行时间为0.01秒。
- 当目标值位于数组的中间位置时，折半查找算法的性能最佳；而当目标值位于数组的两端时，折半查找算法的性能最差。
讨论与分析：通过对实验结果的分析，我们可以得出以下结论：1. 折半查找算法的时间复杂度为O(log n)，而线性查找算法的时间复杂度为O(n)。
因此，折半查找算法在大规模数据中的查找效率远高于线性查找算法。
2. 折半查找算法适用于已排序的数据集，而线性查找算法对数据集的有序性没有要求。
因此，在已排序的数据集中使用折半查找算法可以提高查找效率。
查找-二分法查找（折半查找法）
查找-⼆分法查找（折半查找法）实现查找指定数值在元素有序的数组中存储的位置（索引），返回该位置（索引）。
解题步骤：1.定义3个⽤来记录索引值的变量，变量min记录当前范围最⼩索引值，初始值为0；变量max记录当前范围最⼤索引值，初始值为数组长度-1；变量mid记录当前当前范围最中间元素的索引值，初始值为(min+max) / 22.使⽤循环，判断当前范围下，最中间元素值与指定查找的数值是否相等若相等，结束循环，返回当前范围最中间元素的索引值mid若不相等，根据⽐较结果，缩⼩查询范围为上⼀次查询范围的⼀般中间元素值⽐要查询的数值⼤，说明要查询的数值在当前范围的最⼩索引位置与中间索引位置之间，此时，更新查询范围为:范围最⼤索引值 = 上⼀次中间索引位置 -1；中间元素值⽐要查询的数值⼩，说明要查询的数值在当前范围的最⼤索引位置与中间索引位置之间，此时，更新查询范围为:范围最⼩索引值 = 上⼀次中间索引位置 +1；在新的查询范围中，更新中间元素值的位置，再次使⽤最中间元素值与指定查找的数值是否相等。
中间索引值 = (范围最⼩索引值 +范围最⼤索引值) / 2;3.每次查询范围缩⼩⼀半后，使⽤if语句判断，查询范围是否⼩于0个元素，若⼩于0个元素，则说明指定数值没有查询到，返回索引值-1。
//⼆分查找法(折半查找法)public static int halfSearch(int[] arr,int number){int min =0; //最⼩下标int max =arr.length-1; //最⼤下标int mid = 0; //中间下标while (min<max){//没找到,更新范围继续找mid = (min+max)/2;if (arr[mid]>number){ //number在mid的左边max = mid-1; //改变最⼤下标}else if(arr[mid]<number){ //number在mid的右边min = mid+1; //改变最⼩下标}else{return mid;}}return -1;}。
二分搜索算法(折半查找)原理以及递归(recuition),迭代(iteration)的两种实现源代码
二分搜索算法(折半查找)原理以及递归（recuition），迭代（iteration）的两种实现源代码
折半查找法也称为二分查找法，它充分利用了元素间的次序关系，采用分治策略，可在最坏的情况下用O(log n)完成搜索任务。
【基本思想】
将n个元素分成个数大致相同的两半，取a[n/2]与欲查找的x作比较，如果x=a[n/2]则找到x，算法终止。
如果x<a[n/2]，则我们只要在数组a的左半部继续搜索x（这里假设数组元素呈升序排列）。
如果x>a[n/2]，则我们只要在数组a的右半部继续搜索x。
二分搜索法的应用极其广泛，而且它的思想易于理解。
第一个二分搜索算法早在1946 年就出现了，但是第一个完全正确的二分搜索算法直到1962年才出现。
Bentley在他的著作《Writing Correct Programs》中写道，90%的计算机专家不能在2小时内写出完全正确的二分搜索算法。
问题的关键在于准确地制定各次查找范围的边界以及终止条件的确定，正确地归纳奇偶数的各种情况，其实整理后可以发现它的具体算法是很直观的。
C++描述
递归实现（recuition）
迭代实现（iteration）。
实验二 折半查找算法设计
实验二折半查找算法设计题目：折半查找算法设计问题描述：（1）分析掌握折半查找算法思想，在此基础上，设计出递归算法和循环结构两种实现方法的折半查找函数。
（2）编写程序实现：在保存于数组的10000个有序数据元素中查找数据元素x是否存在。
数据元素x要包含两种情况：一种是数据元素x包含在数组中；另一种是数据元素x不包含在数组中（3）数组中数据元素的有序化既可以初始赋值时实现，也可以设计一个排序函数实现。
（4）根据两种方法的实际运行时间，进行两种方法时间效率的分析对比。
基本要求：（1）10000个数据可以初始赋值时实现，也可以调用系统的随机函数，再设计一个排序函数实现。
（2）两种方法时间效率的分析对比可以有两种方法，一种是理论分析方法，一种是实际记录运行时间。
（3）提交实验报告。
测试数据：运行算法时，当输入的数据小于10000，例如输入9999时，显示该数据在数组中，下标为9998，并且分别显示递归和循环结构下的时间；当输入的数据大于10000时，例如输入20000时，显示这个这个数据不再该数组中。
算法思想：设有数组a中元素按从小到大的次序排列，a的下界下标为low，上界下标为high，首先计算出a的中间位置下标mid=（low+high)/2,1.递归算法思想：比较x和a[mid],若x=a[mid]，则查找成功；若x<a[mid]，则随后调用算法自身在下标为low，上界下标为mid-1的区间继续查找；若x>a[mid]，则随后调用算法自身在下标为mid+1，上界下标为high的区间继续查找。
当查找区间小于等于0时，查找过程结束。
2.循环结构思想：用while(low <= high)控制循环，比较x和a[mid]，若x=a[mid]，则查找成功；若x<a[mid]，则随后在下标为low，上界下标为mid-1的区间继续查找；若x>a[mid]，则随后在下标为mid+1，上界下标为high的区间继续查找。
折半查找的实验报告
折半查找的实验报告
《折半查找的实验报告》
在计算机科学领域中，折半查找是一种常用的搜索算法，也被称为二分查找。
它的原理是在有序数组中查找特定元素的位置，通过将数组分成两部分并逐步
缩小搜索范围来实现。
本实验旨在验证折半查找算法的效率和准确性，以及探
讨其在实际应用中的优势和局限性。
实验过程分为以下几个步骤：
1. 数据准备：首先，我们准备了多组有序数组作为输入数据，每组数组包含不
同数量的元素。
这些数组涵盖了各种规模的数据集，以便全面测试折半查找算
法的性能。
2. 算法实现：我们编写了折半查找算法的实现代码，并在不同规模的数据集上
进行了测试。
算法的实现包括了边界条件的处理、搜索范围的缩小和结果的返
回等关键步骤。
3. 实验设计：为了验证折半查找算法的准确性和效率，我们设计了一系列实验，包括查找存在的元素、查找不存在的元素以及对比折半查找和线性查找算法的
性能。
4. 实验结果：通过对实验数据的分析和对比，我们得出了折半查找算法在不同
规模数据集上的搜索耗时和准确率。
同时，我们也探讨了折半查找算法相对于
线性查找算法的优势和局限性。
5. 结论与展望：最后，我们总结了实验结果，并对折半查找算法在实际应用中
的潜在价值和改进方向进行了展望。
通过本次实验，我们对折半查找算法有了更深入的理解，同时也为其在实际应
用中的优化和推广提供了一些思路。
希望本实验报告能够对相关领域的研究和应用有所启发，为进一步探索折半查找算法的性能和潜力提供参考。
实验12：顺序查找、折半查找实验报告
深圳大学实验报告课程名称：数据结构实验与课程设计实验项目名称：顺序查找、折半查找实验学院：计算机与软件学院专业：指导教师：**报告人：学号：班级：实验时间：实验报告提交时间：教务处制一、实验目的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指向待查区间的中点，即mid=(low+high)/2⑷、让Key与mid指向的记录关键字比较若Key=BinList[mid]，查找成功，结束若Key<BinList[mid]，则high=mid-1 [上半区间]若Key>BinList[mid]，则low=mid+1 [下半区间]⑸、重复⑶、⑷操作，直至low>high时，查找失败。
顺序查找与折半查找实验报告
顺序查找与折半查找实验报告姓名：许严班级：计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<<"次。
数据结构实验二分查找
数据结构实验二分查找一、实验目的通过本次实验，我们了解二分查找算法的原理以及实现方法，掌握如何使用二分查找算法在有序数组中查找目标元素。
二、实验原理二分查找，也称折半查找，是一种基于有序数组的查找算法。
它将目标元素与数组中间的元素进行比较，如果相等则返回目标元素的索引；如果目标元素小于中间元素，则在左半部分数组中进行查找；如果目标元素大于中间元素，则在右半部分数组中进行查找。
通过不断缩小查找范围，最终可以找到目标元素。
二分查找的步骤如下：1. 定义起始索引start为0，结束索引end为数组长度减一2. 将目标值与中间元素进行比较，如果相等则返回中间索引；如果目标值小于中间元素，则将结束索引end设置为中间索引减一，并重复步骤2；如果目标值大于中间元素，则将起始索引start设置为中间索引加一，并重复步骤23.如果起始索引大于结束索引，则目标元素不存在于数组中。
三、实验步骤1.创建一个有序数组，用于存放待查找的元素。
2. 定义一个函数binarySearch，接收一个目标值和有序数组作为参数，返回目标值在数组中的索引，如果不存在则返回-13. 在binarySearch函数中，定义起始索引start为0，结束索引end为数组长度减一4. 使用while循环，在起始索引小于等于结束索引时进行查找。
5. 在while循环中，计算中间索引mid，将目标值与中间元素进行比较。
6.如果目标值等于中间元素，则返回中间索引。
7. 如果目标值小于中间元素，则将结束索引end设置为中间索引减一8. 如果目标值大于中间元素，则将起始索引start设置为中间索引加一9. 当while循环结束时，表示目标元素不存在于数组中，返回-1四、实验代码```#include <iostream>using namespace std;int binarySearch(int target, int arr[], int size)int start = 0;int end = size - 1;while (start <= end)int mid = start + (end - start) / 2;if (arr[mid] == target)return mid;} else if (arr[mid] > target)end = mid - 1;} elsestart = mid + 1;}}return -1;int maiint arr[] = {1, 3, 5, 7, 9, 11};int target = 5;int size = sizeof(arr) / sizeof(arr[0]);int result = binarySearch(target, arr, size);if (result != -1)cout << "目标元素在数组中的索引为：" << result << endl; } elsecout << "目标元素不存在于数组中" << endl;}return 0;```五、实验结果对于有序数组{1,3,5,7,9,11}和目标元素5，使用二分查找算法可以找到目标元素的索引为2六、实验总结通过本次实验，我们了解了二分查找算法的原理和实现方法，在有序数组中成功找到目标元素。
二分查找（折半查找）
⼆分查找（折半查找）⼀、什么是⼆分查找⼆分查找也称折半查找（Binary Search），它是⼀种效率较⾼的查找⽅法。
但是，折半查找要求线性表必须采⽤顺序存储结构，⽽且表中元素按关键字有序排列⼆、算法复杂度⼆分查找的基本思想是将n个元素分成⼤致相等的两部分，取a[n/2]与x做⽐较，如果x=a[n/2],则找到x,算法中⽌；如果x<a[n/2],则只要在数组a的左半部分继续搜索x,如果x>a[n/2],则只要在数组a的右半部搜索x.时间复杂度即是while循环的次数。
总共有n个元素，渐渐跟下去就是n,n/2,n/4,....n/2^k（接下来操作元素的剩余个数），其中k就是循环的次数由于你n/2^k取整后>=1即令n/2^k=1可得k=log2n,（是以2为底，n的对数）所以时间复杂度可以表⽰O(h)=O(log2n)三、如何理解⼆分查找给定范围0到1000的整数：第⼀次我们选择500，发现偏⼤了，那么下⼀次的选择范围，就变成了1到499：第⼆次我们选择250，发现还是偏⼤了，那么下⼀次的选择范围，就变成了1到249：第三次我们选择125，发现偏⼩了，那么下⼀次的选择范围，就变成了126到249：以此类推，最坏的情况需要猜测多少次呢？答案是 log1000 = 10次，也就是让原本的区间范围进⾏10次 “折半”。
四、代码实现1.⾮递归⽅式1import java.util.Arrays;23public class test07 {4public static void main(String[] args) {5int[] arr = new int[]{15,66,48,9,54,11,87,100,40,8,9,7,12,13};6int key = 11; //要查找的数7 Arrays.sort(arr); //⼆分查找，之前⼀定要对数组进⾏元素排序8 System.out.println(Arrays.toString(arr)); //打印数组9 System.out.println(key+"元素的索引"+binarySearch(arr,key));10 }11public static int binarySearch(int[] array,int key){12//头指针初始位置13int low = 0;14//尾指针初始位置15int high = array.length - 1;16//判断查找的数是否在数组中，如果此处不加判断，则可能报ng.StackOverflowError栈内存溢出17if(low>high||key>array[high]||key<array[low]){18return -1;19 }20while(low<=high){21//计算中间值的索引，防⽌溢出22int mid = low+ (high - low)/2;23if(key==array[mid]){24return mid; //返回查询到的索引位置25 }else if (key>array[mid]){26 low = mid+1; //mid所对应的的值⽐key⼩，key应该在右边27 }else {28 high = mid-1; //mid所对应的的值⽐key⼤，key应该在左边29 }30 }31//若没有，则返回-132return -1;33 }34 }2.⾮递归⽅式1import ng.annotation.ElementType;2import java.util.Arrays;34public class test07 {5public static void main(String[] args) {6int[] arr = new int[]{15,66,48,9,54,11,87,100,40,8,9,7,12,13};7int key = 11; //要查找的数8//头指针初始位置9int low = 0;10//尾指针初始位置11int high = arr.length - 1;12 Arrays.sort(arr); //⼆分查找，之前⼀定要对数组进⾏元素排序13 System.out.println(Arrays.toString(arr)); //打印数组14 System.out.println(key+"元素的索引"+binarySearch(arr,low,high,key));15 }16public static int binarySearch(int[] array,int low,int high,int key){17//判断查找的数是否在数组中，如果此处不加判断，则可能报ng.StackOverflowError栈内存溢出18if(low>high||key>array[high]||key<array[low]){19return -1;20 }21//计算中间值的索引，防⽌溢出22int mid = low+ (high - low)/2;23if (key>array[mid]){24return binarySearch(array,mid+1,high,key); //mid所对应的的值⽐key⼩，key应该在右边25 }else if(key<array[mid]){26return binarySearch(array,low,mid-1,key); //mid所对应的的值⽐key⼤，key应该在左边27 }else{28return mid;29 }30 }31 }⼆分查找中值(mid)计算⼆分查找中值计算有三种⽅式：int mid = (low + high)/ 2;int mid = low + (high - low) / 2;int mid = (high + low) >>> 1上述两种算法看似第⼀种要简洁，第⼆种提取之后，跟第⼀种没有什么区别。
王贵孝 (2)
实验二：编程实现“折半查找”的过程。
折半查找的处理过程：在一个数据已排好序的数组中，首先比较要查找的值与数组中间的元素，如果两者相等，这查找结束;如果前者比后者小，则要查找的数据必然在数组的前半部，此后只需要在数组的前半部中继续折半查找；如果前者的数值比后者大，则要查找的数据必然在数组的后半部，此后只需在数组的后半部继续进行折半查找。
要求：（1）设定一个整型数组存放20个元素，采用直接赋值的方法在程序中初始化该数组（假设这些数据已排序）；（2）用scanf函数输入一个要找的数值；（3）对查找的结果给出相应的说明，如果找到该数值，则输出“Found”信息，并给出该数师叔祖中的第几个元素。
如果该数值不再数组中，则输出“Not found”信息；（4）修改程序，设定输入的数据是无序的，则先要对这些无序的数据进行排序，然后再采用“折半查找”；（5）修改程序，编写一个选择排序函数，对无序数据进行排序；编写一个查找函数对已排好的数据进行查找。
在主函数中输入数据（无序），调用上述函数，输出结果。
参考答案题一#include <stdio.h>#include <stdlib.h>void creat(int n){int i,j,k,min,max,pos1,pos2,a[n][n];for(i=0;i<n;i++){for(j=0;j<n;j++)scanf("%d",&a[i][j]);}for(i=0;i<n;i++){for(j=0;j<n;j++)printf("%3d",a[i][j]);printf("\n");}for(min=max=a[0][0],pos1=pos2=0,i=0;i<n;i++) {for(j=0;j<n;j++){if(min<a[i][j]){min=a[i][j];pos1=i;}if(max>a[0][0]){max=a[i][j];pos2=i;}}}if(pos1!=pos2){for(i=0;i<n;i++){k=a[pos1][i];a[pos1][i]=a[pos2][i];a[pos2][i]=k;}}else{printf("the min and max in the same line\n"); }for(i=0;i<n;i++){for(j=0;j<n;j++){printf("%3d",a[i][j]);}printf("\n");}}int main(){int n;printf("please input n=");scanf("%d",&n);creat(n);system("pause");}题二#include <stdio.h>#include <stdlib.h>int find(int *p,int n,int a){if(n==0){printf("Not Found\n");return 20;}if(a==p[n/2]){printf("Found");return n/2;}if(a>p[n/2])return find(p+n/2,n/2,a)+n/2; if(a<p[n/2])return find(p,n/2,a);}int selectsort(int a[],int n) {int i,j,k,min,m;min=a[0];k=0;for(i=0;i<n-1;i++){for(j=i+1,min=a[i];j<n;j++) {if(min>a[j]){min=a[j];k=j;}}if(min!=a[i]){m=a[i];a[i]=a[k];a[k]=m;}}}int main(){int i,j,k,a[20];printf("please input a[20]:\n");for(i=0;i<20;i++)scanf("%d",&a[i]);selectsort(a,20);for(i=0;i<20;i++)printf("%3d",a[i]);printf("\n");printf("please input a int to search:\n");scanf("%d",&k);j=find(a,20,k);if(j<20)printf("\n%d is the %dth munber\n",k,j+1); system("pause");}。
验证实验-折半查找
验证实验－折半查找一、折半查找－实验目的对给定的有序数组（假设长度为n），查找数组中与给定值k相等的元素。
二、折半查找－实验过程1、算法思想将数列按有序化排列(升序)，查找过程中采用跳跃式方式查找，即先以有序数列的中点位置为比较对象，如果要找的元素值小于该中点元素，则将待查序列缩小为前半部分，否则为后半部分。
通过一次比较，将查找区间缩小一半。
2、变量I：循环变量.J：查找次数计数器Key：需查找的值.Low：刚开始为第一个值所对应的下标.High：刚开始为最后一个值所对应的下标.Mid：第一个与最后一个值所对应下标和的一半Arr：一维数组,用来存放15个数据.3、步骤➢读取一组15个已升序排列的数据。
➢取出15个数最中间下标的数与关键字进行比较，进行查找➢若关键字等于这个数的话，则查找成功➢若关键字小于这个数的话，则范围缩小为表的前半部分➢若关键字大于这个数的话，则范围缩小为表的后半部分➢重复执行3）4）5）过程，直到low>high为止。
➢输出各次查询low,high,mid值，总查询次数，验证折半算法4、折半查找－流程图5、折半查找－程序代码/* 对给定的有序数组（假设长度为n），查找数组中与给定值k相等的元素。
*/ #include <stdio.h>#include "stdafx.h"#define N 15 //定义常量N 为数组长度void find(int arr[],int key,int i) //折半查找函数{int low=0,high=N-1,mid,j=0; //j计数查找次数while(low<=high){mid=(low+high)/2; //取中间位++j;printf("\n 第%2d次查找 low=%2d high=%2d mid=%2d",j,low,high,mid); //显示每次查找低中高位，查找次数if(arr[mid]==key) //查到数据，跳出循环break;if(arr[mid]<key) //查找的KEY大于中位值，查后半部low=mid+1;elsehigh=mid-1; //查找的KEY小于中位值，查前半部}if(low<=high) //查到数据printf("\n\n经过总共%2d次查找，找到该数字，该数字位于数组第%d 位,\n\n",j,mid+1);//显示查到的数据的值，下标值，总查找次数elseprintf("\n\n没有找到!"); //显示没有找到}void main(){int arr[N],key,i;printf("\n折半查找验证程序，设定被查数据有位，设定为：\n");for(i=0;i<N;i++) //输入15个排好序的数据{arr[i]=i+1;printf("%d ",arr[i]);}printf("\n请输入要查询的数字（－，输入小于等于零的数字退出验证程序）:");scanf("%d",&key); //输入KEYwhile(key>0){find(arr,key,N); //调用折半查找函数printf("\n请输入要查询的数字（－，输入小于等于零的数字退出验证程序）:");scanf("%d",&key); //输入KEY}}6、折半查找－运行结果输入一个数值为1至15的有序一维数据，查询2，7，8的结果的截屏。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验二折半查找算法设计
题目：折半查找算法设计
问题描述：（1）分析掌握折半查找算法思想，在此基础上，设计出递归算法和循环结构两种实现方法的折半查找函数。
（2）编写程序实现：在保存于数组的10000个有序数据元素中查找数
据元素x是否存在。
数据元素x要包含两种情况：一种是数据元素x
包含在数组中；另一种是数据元素x不包含在数组中
（3）数组中数据元素的有序化既可以初始赋值时实现，也可以设计一
个排序函数实现。
（4）根据两种方法的实际运行时间，进行两种方法时间效率的分析对
比。
基本要求：（1）10000个数据可以初始赋值时实现，也可以调用系统的随机函数，再设计一个排序函数实现。
（2）两种方法时间效率的分析对比可以有两种方法，一种是理论分析
方法，一种是实际记录运行时间。
（3）提交实验报告。
测试数据：运行算法时，当输入的数据小于10000，例如输入9999时，显示该数据在数组中，下标为9998，并且分别显示递归和循环结构下的时
间；当输入的数据大于10000时，例如输入20000时，显示这个这个
数据不再该数组中。
算法思想：设有数组a中元素按从小到大的次序排列，a的下界下标为low，上界下标为high，首先计算出a的中间位置下标mid=（low+high)/2,
1.递归算法思想：比较x和a[mid],若x=a[mid]，则查找成功；若
x<a[mid]，则随后调用算法自身在下标为low，上界下标为mid-1的
区间继续查找；若x>a[mid]，则随后调用算法自身在下标为mid+1，
上界下标为high的区间继续查找。
当查找区间小于等于0时，查找
过程结束。
2.循环结构思想：用while(low <= high)控制循环，比较x和a[mid]，
若x=a[mid]，则查找成功；若x<a[mid]，则随后在下标为low，上界
下标为mid-1的区间继续查找；若x>a[mid]，则随后在下标为mid+1，
上界下标为high的区间继续查找。
当查找区间小于等于0时，查找
过程结束。
模块划分：1.头文件time.h中包含time()和difftime(end,start)函数，分别实现取系统当前时间和end减去start的时间差；
2.头文件stdlib.h中包含rand()函数，实现随机数的生成；
3.void list(int a[])实现对随机数从小到大的排序；
4.int Search(int a[],int low,int high,int x)用递归算法实现折半查找数据
元素的函数；
5.int BSearch(int a[], int low, int high, int x)用循环结构实现折半查找
数据元素的函数；
6.void main()主函数，测试用递归算法和循环结构实现折半查找数据
元素的函数。
数据结构：
源程序：
#include<stdio.h>
#include<time.h>
int Bsearch(int a[],int x,int low,int high)
{
int mid;
if(low>high) return -1;
mid=(low+high)/2;
if(x==a[mid]) return mid;
else if(x<a[mid])
Bsearch(a,x,low,mid-1);
else
return Bsearch(a,x,mid+1,high);
}
int Csearch(int test[],int x,int low,int high)
{
for(int i=0;i<high;i=(low+high)/2)
{
if(x==test[i]) return i;
else if(x>test[i]) low=i+1;
else high=i-1;
}
if(i>=high) return -1;
}
void main()
{
time_t start,end;
double dif;
int Bsearch(int a[],int x,int low,int high);
int Csearch(int test[],int x,int low,int high);
int a[10000],x;
int low=0,high=10000,mid=0;
printf("请输入要查找的元素：\n");
scanf("%ld",&x);
printf("x=%ld\n",x);
for(int i=0;i<high;i++)
a[i]=i+1;
int bn;
time(&start);
bn=Bsearch(a,x,0,10000);
if(bn==-1) printf("x不在数组a中！\n");
else printf("x在数组a中，下标为%d\n",bn);
time(&end);
dif=difftime(end,start);
printf("递归折半方法耗时为：%f秒\n",dif);
int flag;
time(&start);
flag=Csearch(a,x,0,10000);
if(flag==-1) printf("x不在数组a中！\n");
else printf("x在数组a中，下标为%ld\n",flag);
time(&end);
dif=difftime(end,start);
printf("循环折半算法耗时为：%f秒\n",dif); }
测试情况：
测试结果分析：
程序运行结果和人工模拟分析过程完全相同。
说明程序设计正确。
但是因为测试程序中数组中的元素过少不能体现出两种情况即递归和循环结构两种算法
的时间差别。
理论分析知循环结构的效率高于递归结构。