折半查找算法及程序实现教案
折半查找程序实验报告
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）定义以及思想(有序)折半查找法是效率较⾼的⼀种查找⽅法。
假设已经按照从⼩到⼤的顺序排列好的五个整数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; }。
C++二分查找（折半查找）算法实例详解
C++⼆分查找（折半查找）算法实例详解本⽂实例讲述了C++⼆分查找(折半查找)算法。
分享给⼤家供⼤家参考，具体如下：⼆分查找⼜称折半查找，优点是⽐较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插⼊删除困难。
因此，折半查找⽅法适⽤于不经常变动⽽查找频繁的有序列表。
⼆分查找思想⾸先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字⽐较，如果两者相等，则查找成功；否则利⽤中间位置记录将表分成前、后两个⼦表，如果中间位置记录的关键字⼤于查找关键字，则进⼀步查找前⼀⼦表，否则进⼀步查找后⼀⼦表。
重复以上过程，直到找到满⾜条件的记录，使查找成功，或直到⼦表不存在为⽌，此时查找不成功。
基本算法C语⾔实现代码：int binary_search(int arr[], int len, int elem){int low = 0;int high = len - 1;while (low <= high){int mid = (low + high) / 2;if (elem == arr[mid]){ //相等，返回midreturn mid;}else if (elem > arr[mid]){low = mid + 1; //元素⽐区间中间元素⼤，取区间中间元素的下⼀个元素作为新区间起始位置}else{high = mid - 1; //元素⽐区间中间元素⼩，取区间中间元素的上⼀个元素作为新区间结束位置}}return -1;}添加检测是否是已排好序数组的程序实例#include <iostream>using namespace std;int binary_search(int arr[], int len, int elem){int low = 0;int high = len - 1;while (low <= high){int mid = (low + high) / 2;if (elem == arr[mid]){return mid;}else if (elem > arr[mid]){low = mid + 1;}else{high = mid - 1;}}return -1;}//检测是否排好序int is_sorted(int arr[], int len){int sorted = 1;for (int i = 0; i < len - 1; i++){sorted = sorted && arr[i] <= arr[i + 1];}return sorted;}int main(){int arr[] = { 1, 3, 5, 7, 9, 11, 12, 15, 18, 23, 25, 26 }; int len = sizeof(arr) / sizeof(int);int pos;int sorted = is_sorted(arr, len);if (sorted){pos = binary_search(arr, len, 26);cout << "pos = " << pos << endl;}system("pause");}运⾏结果：pos = 11请按任意键继续. . .希望本⽂所述对⼤家C++程序设计有所帮助。
数据结构-折半查找,哈希查找
一、实验目的熟练掌握顺序查找，折半查找和哈希表等算法的程序实现。
二、实验内容1、实现折半查找的算法编写一个程序，输出在顺序表（1,2,3,4,,6,7,8,9,10）中采用折半查找方法查找关键字9的过程要求：输出查找过程中的比较对象和被查找元素的位置。
2、实现哈希表的相关运算算法编写程序实现哈希表的构造过程。
要求：建立关键字序列（16,74,60,43,54,90,46,31,29,88,77）对应的哈希表A[0...12]，哈希函数为H（k）=k%p，并采用开放定址法中的线性探测法解决冲突。
输出构造完成后的哈希表。
程序源代码及运行结果（运行结果可以截图，也可以文字描述分析）1#include<stdio.h>#include<stdlib.h>int fun(int a[],int key){int high=9;int low=0;int mid=(high+low)/2;printf("与之相比较的值为:");while(high>=low){if(key==a[mid]){printf("%-2d",a[mid]);printf("\nkey为数组中第%d个元素\n",mid+1);break;}if(key<a[mid]){ printf("%-2d",a[mid]);high=mid-1;mid=(high+low)/2;}if(key>a[mid]){ printf("%-2d",a[mid]);low=mid+1;mid=(high+low)/2;}}}int main(){int a[10]={1,2,3,4,5,6,7,8,9,10};fun(a,9);system("pause");}运行截图：2#include<stdio.h>int main(){int a[11]={16,74,60,43,54,90,46,31,29,88,77};int A[13]={0};int p=11,H;for(int i=0;i<11;i++){H=a[i]%p;while(A[H]!=0){H++;if(H==12){H=0;}}A[H]=a[i];}for(int i=0;i<13;i++){if(A[i]!=0){printf("%d ",A[i]);}}}运行截图三、小结（不少于100字）感觉好像没有真正理解哈希表，折半查找比较好理解，实现起来也比较容易，自己对代码的熟练程度还不够，课后还会多多练习，查找的方式还有很多，课后应该多看书，对每种算法都有一定的了解。
折半查找算法及程序实现教案
折半查找算法及程序实现一、教材分析教学重点：以图示法方式，演示折半查找算法的基本思想。
教学难点：由折半查找算法的思想到程序代码编写的转换,尤其是其中关键性语句的编写是教学中的难点.二、学情分析学生应该已经掌握程序设计的基本思想,掌握赋值语句、选择语句、循环语句的基本用法和VB基本操作，这节课学生可能会遇到的最大问题是：如何归纳总结对分查找解决不同情况问题的一般规律，鉴于此,在教学中要积极引导学生采取分解动作、比较迁移等学习策略。
三、教学目标知识与技能:理解对分查找的概念和特点,通过分步解析获取对分查找的解题结构,初步掌握对分查找算法的程序实现。
过程与方法:通过分析多种不同的可能情况,逐步归纳对分查找的基本思想和方法,确定解题步骤。
情感态度与价值观:通过实践体验科学解题的重要性，增强效率意识和全局观念，感受对分查找算法的魅力,养成始终坚持、不断积累才能获得成功的意志品质。
四、教学策略与手段1、教学线索：游戏引领——-提出对分查找原理-—- 解析对分查找的算法特征---实践解决问题。
2、学习线索：分解问题—-—归纳问题———实践提升，在三个阶段的不断推进中明确对分查找算法，总结规律。
五、教学过程1、新课导入(1）热身:游戏（2分钟）找同学上来找一本上千页电话册里面的一个名字。
（课程导入我写的不是很详细，自己设计哦)(2）教师引导：所以我不希望只有他一个人体验这种方便，我们教室里还有一大帮人,其实这种什么不止用于查找电话铺,还可以运用到实际生活中，教室里有这么多人，坦白说，按学校的老方法一个人一个人的数，对所有老师来说都及其费力，那我们想想,是不是数数2368,这样好点对吗？。
不要小看这种想法，他其实是非常棒的，他能把解决问题的时间缩短一半,因此我们提出了这种算法2、新课：首先我们一起来看一看折半查询算法中的“折半"的含义.师：何为折半呢？生:减半；打一半的折扣.例如，我手里拿着一根绳子，现在我们来进行折半试验,首先拿住绳子的两个端点，然后从中点的位置进行对折，这样绳子就缩短为原来长度一半，然后将一半的绳子继续执行与刚才相同的操作，使得绳子的长度逐渐的缩短，直到绳子长度短得不能再进行折半了。
折半查找和二叉排序树
折半查找和二叉排序树一、实验目的1、掌握查找的特点。
2、掌握折半查找的基本思想及其算法。
3、熟悉二叉排序树的特点，掌握二叉排序树的插入、删除操作。
二、实验内容1、设有关键字序列k={ 5 ,14 ,18 ,21 ,23 ,29 ,31 ,35 }，查找key=21和key=25的数据元素。
2、根据关键字序列{45、24、53、12、37、93}构造二叉排序树，并完成插入13删除关键字53和24的操作。
三、实验环境TC或VC++或Java四、实验步骤1、折半查找（1）从键盘输入上述8个整数5 ,14 ,18 ,21 ,23 ,29 ,31 ,35，存放在数组bub[8]中，并输出其值。
（2）从键盘输入21，查找是否存在该数据元素，若存在，则输出该数据元素在表中的位置，否则给出查找失败的信息。
（3）从键盘输入25，查找是否存在该数据元素，若存在，则输出该数据元素在表中位置，否则给出查找失败的信息。
2、二叉排序树（1）二叉排序树存储定义（2）从键盘上输入六个整数45、24、53、12、37、9构造二叉排序树（3）输出其中序遍历结果。
（4）插入数据元素13，输出其中序遍历结果。
（5）删除数据元素24和53，输出其中序遍历结果。
五、问题讨论1、折半查找递归算法该怎么描述？2、二叉排序树中序遍历结果有什么特点？3、在二叉树排序树中插入一个新结点，总是插入到叶结点下面吗？4、在任意一棵非空二叉排序树中，删除某结点后又将其插入，则所得二排序叉树与原二排序叉树相同吗？六、实验报告内容1、实验目的2、实验内容和具体要求3、完成情况和实验记录，实验记录为实验过程中遇到的问题及解决方法4、程序清单5、所输入的数据及相应的运行结果6、问题回答7、实验心得实验代码：#include<stdio.h>#include<stdlib.h>typedef struct BiTNode{int data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;int bub[100];void menu(){printf("********主目录*******\n");printf(" 折半或顺序查找1\n");printf(" 二叉排序树2\n");printf(" 结束程序0\n");printf("*********************\n");}void menu1(){printf("*******目录①*******\n");printf(" 输出元素1\n");printf(" 顺序查找2\n");printf(" 折半查找3\n");printf(" 结束此查找0\n");printf("********************\n");}void menu2(){printf("**********目录②*********\n");printf("输出树的中序遍历结果1\n");printf(" 插入数据元素2\n");printf(" 删除数据元素3\n");printf(" 结束二叉排序0\n");printf("*************************\n"); }void Search(){int i,m,n,key,k;printf("输入元素个数：");scanf("%d",&m);printf("依次输入元素：");for(i=1;i<=m;i++){scanf("%d",&bub[i]);}printf("输入关键字：");scanf("%d",&key);bub[0] = key;do{menu1();printf("选择查找方式：");scanf("%d",&n);switch(n){case 1:for(i=1;i<=m;i++){printf("%d,",bub[i]);}printf("\n");break;case 2:for(i=m;i>=0;i--){if(bub[i]==key){if(i!=0){printf("查找的数据元素在第%d位！\n",i);break;}else{printf("查找失败\n");}}}break;case 3:k = Search_Bin(m,key);if(k!=0)printf("查找的数据元素在第%d位！\n",k);elseprintf("查找失败\n");break;case 0:printf("查找结束\n");break;default:printf("选择错误\n");}}while(n!=0);}int Search_Bin(int m,int key){int low,high,mid;low = 1;high = m;while(low<=high){mid = (low+high)/2;if(key==bub[mid])return mid;else if(key<bub[mid])high = mid-1;elselow = mid+1;}return 0;}BiTree Insert(){BiTree T=NULL,q=NULL,p=NULL;int m;printf("输入数据(-10000停止输入)：");scanf("%d",&m);while(m!=-10000){q = (BiTree)malloc(sizeof(BiTNode));q->data = m;q->lchild = q->rchild=NULL;if(!T)T = q;else{p = T;while(1){if(m<p->data){if(p->lchild==NULL){p->lchild = q;break;}p = p->lchild;}else{if(p->rchild==NULL){p->rchild = q;break;}p = p->rchild;}}}scanf("%d",&m);}return T;}void Inorder(BiTree T){if(T){Inorder(T->lchild);printf("%d,",T->data);Inorder(T->rchild);}}int Search_CH(BiTree T,int elem,BiTree f,BiTree *p) {if(!T){*p = f;return 0;}else if(elem==T->data){*p = T;return 1;}else if(elem<T->data)Search_CH(T->lchild,elem,T,p);elseSearch_CH(T->rchild,elem,T,p);}BiTree InsertBST(BiTree T,int elem){BiTree p=NULL,s=NULL;if(!Search_CH(T,elem,NULL,&p)){s = (BiTree)malloc(sizeof(BiTNode));s->data = elem;s->lchild = s->rchild = NULL;if(!p)T = s;else if(elem<p->data)p->lchild = s;elsep->rchild = s;printf("插入成功\n");return T;}printf("输入已有元素，插入失败\n");return T;}BiTree Delete(BiTree T,int elem){BiTree p=NULL,q=NULL,f=NULL,s=NULL;p = T;while(p){if(elem == p->data)break;q = p;if(elem <p->data)p = p->lchild;elsep = p->rchild;}if(!p)printf("查找失败，删除失败\n");return T;}if(!(p->lchild)){if(!q)T = p->rchild;else if(q->lchild == p)q->lchild = p->rchild;elseq->rchild = p->rchild;free(p);}else{f = p;s = p->lchild;while(s->rchild){f = s;s = s->rchild;}if(f==p)f->lchild = s->lchild;elsef->rchild = s->lchild;p->data = s->data;free(s);}printf("删除成功\n");return T;}void ErChaPaiXu(){BiTree T;int m,key;T = Insert();domenu2();printf("输入你的选择：");scanf("%d",&m);switch(m){case 1:printf("中序遍历结果为：");Inorder(T);printf("\n");break;case 2:printf("输入要插入的元素：");scanf("%d",&key);T = InsertBST(T,key);break;case 3:printf("输入要删除的元素：");scanf("%d",&key);T = Delete(T,key);break;case 0:printf("结束二叉排序\n");break;default:printf("输入错误\n");}}while(m!=0);}void main(){int m;do{menu();printf("输入你的选择：");scanf("%d",&m);switch(m){case 1:Search();break;case 2:ErChaPaiXu();break;case 0:printf("程序已结束\n");break;default:printf("输入错误\n");}}while(m!=0);}。
Python查找算法之折半查找算法的实现
Python查找算法之折半查找算法的实现⼀、折半查找算法折半查找算法⼜称为⼆分查找算法，折半查找算法是将数据分割成两等份，⾸先⽤键值(要查找的数据)与中间值进⾏⽐较。
如果键值⼩于中间值，可确定要查找的键值在前半段；如果键值⼤于中间值，可确定要查找的键值在后半段。
然后对前半段(后半段)进⾏分割，将其分成两等份，再对⽐键值。
如此循环⽐较、分割，直到找到数据或者确定数据不存在为⽌。
折半查找的缺点是只适⽤于已经初步排序好的数列；优点是查找速度快。
⽣活中也有类似于折半查找的例⼦，例如，猜数字游戏。
在游戏开始之前，⾸先会给出⼀定的数字范围(例如0~100)，并在这个范围内选择⼀个数字作为需要被猜的数字。
然后让⽤户去猜，并根据⽤户猜的数字给出提⽰(如猜⼤了或猜⼩了)。
⽤户通常的做法就是先在⼤范围内随意说⼀个数字，然后提⽰猜⼤了/猜⼩了，这样就缩⼩了猜数字的范围，慢慢地就猜到了正确的数字，如下图所⽰。
这种做法与折半查找法类似，都是通过不断缩⼩数字范围来确定数字，如果每次猜的范围值都是区间的中间值，就是折半查找算法了。
例如，已经有排序好的数列：12、45、56、66、77、80、97、101、120，要查找的数据是 101，⽤折半查找步骤如下：步骤1：将数据列出来并找到中间值 77，将 101 与 77 进⾏⽐较，如下图所⽰。
步骤2：将 101 与 77 进⾏⽐较，结果是 101 ⼤于 77，说明要查找的数据在数列的右半段。
此时不考虑左半段的数据，对在右半段的数据再进⾏分割，找中间值。
这次中间值的位置在 97 和 101之间，取 97，将 101 与 97 进⾏⽐较，如下图所⽰。
步骤3：将 101 与 97 进⾏⽐较，结果是 101 ⼤于 97，说明要查找的数据在右半段数列中，此时不考虑左半段的数据，再对剩下的数列分割，找中间值，这次中间值位置是 101，将 101 与 101进⾏⽐较，如下图所⽰。
步骤4：将 101 与 101 进⾏⽐较，所得结果相等，查找完成。
编程实现折半查找算法。
编程实现折半查找算法。
中括号内的内容为主题：编程实现折半查找算法一、介绍折半查找算法，也被称为二分查找算法，是一种高效的查找算法。
它可以在有序的数据集合中查找特定元素的位置，其时间复杂度为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`。
数据结构实验报告折半查找
数据结构实验报告折半查找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表示查找失败。
折半查找
深圳大学实验报告课程名称：数据结构实验与课程设计实验项目名称：顺序查找、折半查找实验学院：计算机与软件学院专业：指导教师：杨芳报告人：张健哲学号：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.了解折半查找算法的原理和流程；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)级别的，并与线性查找算法进行对比，强调折半查找算法的高效性。
《猜数游戏——折半查找原理》教学课件
例如：查找59的过程如下
数列 12 25 31 37 52 56 59 70 82 87 序号 1 2 3 4 5 6 7 8 9 10
查找68
数列 12 25 31 37 52 56 59 70 82 87 序号 1 2 3 4 5 6 7 8 9 10
折半查找条件
1是被查找数据按大小有序排列; 2是程序实现时要在内存中按顺序存储。
A、1 B、2
C、３
D、４
习题
2、关键字序列为{12，32，41，45，62，75，77}，当
折半查找值为６2的数据时，（ ）次比较后查找成功。
A、1 B、2
C、３
D、４
思考题
在1000个递增有序排列的运动员编 号中查找指定编号，试问：在最坏情况 下，需要进行几次比较？
项目六 查找数据 任务 2 折半查找
例如：查找59的过程如下
数列 12 25 31 37 52 56 59 70 82 87 序号 1 2 3 4 5 6 数列 12 25 31 37 52 56 59 70 82 87 序号 1 2 3 4 5 6 7 8 9 10
折半查找原理
首先用待查找数据与数列中间位置元素比较，如果相 等，则查找完成；若不相等，则通过比较两者大小的办法， 来确定后续查找在哪半边进行，以此类推，直到查找成功， 或者确定数列中没有待查找数据。
习题
1、对线性表进行折半查找时，要求线性表必须（） A、以顺序方式存储 B、以链表方式存储 C、以顺序方式存储，且结点按关键字有序排列 D、以链表方式存储，且结点按关键字有序排列
习题
1、对线性表进行折半查找时，要求线性表必须（） A、以顺序方式存储 B、以链表方式存储 C、以顺序方式存储，且结点按关键字有序排列 D、以链表方式存储，且结点按关键字有序排列
《折半查找算法》的教学设计及反思
《折半查找算法》的教学设计及反思.江苏省白蒲高级中学刘兴圣226511授课题目：折半查找算法适应范围：高一年级所属科目：教科版高中信息技术选修模块——算法与程序设计模块授课章节：第三章第3节《在数组中查找数据》教学设计（一）教学目标知识与技能：让学生理解折半查找法的基本思想，并能够编写程序代码。
过程与方法：带领学生一同分析问题、体会理解算法设计思想，先掌握编写关键性语句，再到完整程序的书写，并最终通过分析代码进一步加深理解折半查找算法的设计思想。
让学生从中逐渐学会解决问题的基本方法。
情感态度与价值观：在分析折半查找算法的过程中，引导学生积极思考和分析问题，培养学生严谨的思维习惯。
通过各组讨论、实践活动，养成良好的与人协作交流能力。
（二）教材分析教学重点：以图示法方式，演示折半查找算法的基本思想。
教学难点：由折半查找算法的思想到程序代码编写的转换，尤其是其中关键性语句的编写是教学中的难点。
（三）学情分析学习对象是高一学生，本节知识内容是在学习了数组的相关知识和顺序查找算法之后进行的，由于折半查找算法逻辑性比较强，同时学生对算法的相关概念还比较陌生，基础相对欠缺，以及学生的差异比较大，所以在教学过程中尽量要放慢讲解的速度，循序渐进的展开知识点要素，让学生能够对相关的问题进行充分思索、分析，再到问题解决。
（四）教学策略创设趣味问题情境，引导学生了解什么是折半查找算法，以图示法方式来演示折半查找算法的基本思想，并以伪代码形式描述算法中的关键性语句，最终到完整程序代码的书写。
对课题中的关键环节采用日常生活问题引入，让学生通过比较，由浅入深地引导学生思考、讨论。
通过讲授、演示观察、讨论相结合，充分调动学生的主观能动性，以达到主动式学习、探究性学习。
（五）教学方法：图示法，讲授法。
（六）教学准备：多媒体教室。
（七）课时安排：一课时教学过程一、导入（2~3分钟）上一节课我们一起学习了顺序查询法，知道它一般应用在这种情况之下：待查数据表没有顺序，且数据表的长度比较短。
折半查找及其改进(算法与数据结构课程设计)
折半查找及其改进（算法与数据结构课程设计）一、问题描述查找是在一个数据元素集合中查找关键字等于某个给个数据元素关键字的过程，也称为检索。
给出一个特定的元素某，在含有n个元素的数列中判断是否存在这个元素，如果存在，返回此元素在数列中的位置，否则返回零。
数列查找在实际中的应用十分广泛，因此数列查找算法的好坏直接影响到程序的优劣。
本设计要求读取文件中的数据建立查找表,并设计算法实现折半查找及其改进查找。
二、基本要求1、选择合适的存储结构，读取已知文件数据建立查找表；2、完成基于递归和非逆归的折半查找算法的设计；3、完成基于区间约束对折半查找算法的改进算法的设计；4、完成三分查找算法的设计。
三、测试数据文件in.t某t中100个数据：1,2,3…98,99,100。
1、读取文件in.t某t中前50位数，查找元素:582、读取文件in.t某t中前50位数，查找元素:183、读取文件in.t某t中前100位数，查找元素：184、读取文件in.t某t中前100位数，待查元素：58四、算法思想1、折半查找的算法思想是以处于区间中间位置记录的关键字和给定值比较，若相等，则查找成功，如不等，则缩小范围，直至新的区间中间位置记录的关键字等于给定值或区间大小小于零时为止。
2、缩小区间查找算法的思想是先求出有序数列中每相邻两个元素之差的最大值的一个上界，设为m．要查找的数值为key，然后在每次循环做折半之前先进行一次筛选工作，即将low右移(key-a[low]/m)位，high值左移(a[high]-key)/m位，从而把尽可能多的不必要的元素过滤掉，缩小查找范围继续查找，直至新的区间中间位置记录的关键字等于给定值或区间大小小于零时为止。
3、三分查找的算法思想是在给出n个已经排好序的数，在n/3和2n/3处各取一个数，跟给定值key比较，确定待查数所在的范围,直至新的区间中间位置记录的关键字等于给定值或区间大小小于零时为止。
数据结构折半排序查找
折半查询一、实验目的1，掌握排序算法及基本思想及实现的技术；能够根据实际问题特点的要求选择合理的排序方法，理解排序在数据处理中的重要性；2.学会比较各种排序方法的稳定性分析以及在最好、最坏和平均情况的时间性能分析。
3.掌握顺序查找和折半查找两种查找的算法及实现技术；了解它们各自的优缺点。
4.熟悉各种查找方法的适用范围和条件；掌握顺序查找、折半查找的基本思想及效率分析。
二、实验环境1.硬件：每个学生需配备计算机一台。
操作系统：DOS或Windows2.软件：DOS或Windows操作系统+Turbo C;三、实验要求1.本次实验较为简单，每个同学独立按时完成，通过实验掌握记录的概念，为以后数据库技术打好基础。
2.如果输入数据较为繁琐，可减低每个班的人数。
3.输入输出数据要有提示，方便用户操作。
四、实验内容1.现在某个学院有20名同学分属于2个班级（Class1和Class2，每个班有10名同学，每个同学记录包括：班级、学号、姓名、性别、电话号码等信息）。
2.以学号为主关键字，以班级为次关键字，建立一个顺序表，表中的每个数据元素是一个记录，其中的某个域用来存储关键字的值，按关键字的值进行顺序查找。
为分析排序方法的稳定性，关键字可用次关键字。
#include"stdio.h"#include"malloc.h"#include"string.h"typedef struct{int cla;int num;char name[7];char sex;long phnum;}stu_hc;typedef struct{stu_hc *elem;int length;int sum;}sqlist_hc;sqlist_hc *initlist_hc(){sqlist_hc *l;int n;l=(sqlist_hc*)malloc(sizeof(sqlist_hc));if(!l)printf("出错!\n");printf("输入学生人数:");scanf("%d",&n);l->length=0;l->sum=n;l->elem=(stu_hc*)malloc(n*sizeof(stu_hc));if(!l->elem)printf("出错!\n");return(l);}int place_hc(sqlist_hc *l,int c,int num){int low,high,mid,j=-1,i;low=0;high=l->length-1;while(low<=high){mid=(low+high)/2;if(l->elem[mid].num>num)high=mid-1;else{j=mid;low=mid+1;}}i=j;for(j=mid;j>=i;j--){if(j==-1||num>l->elem[j].num)break;else if(num==l->elem[j].num&&c>l->elem[j].cla)break;} return(++j);}void move_hc(sqlist_hc *l,int j){int i;for(i=l->length-1;i>=j;i--){l->elem[i+1].cla=l->elem[i].cla;strcpy(l->elem[i+1].name,l->elem[i].name);l->elem[i+1].num=l->elem[i].num;l->elem[i+1].sex=l->elem[i].sex;l->elem[i+1].phnum=l->elem[i].phnum;}}void createlist_hc(sqlist_hc *l){int i,j,c,num;char nam[7],s;long p;printf("输入学生信息(class name num sex phonenum):\n"); for(i=0;i<l->sum;i++){flushall();scanf("%d %s %d %c %ld",&c,nam,&num,&s,&p);j=!(l->length)?0:place_hc(l,c,num);move_hc(l,j);l->elem[j].cla=c;strcpy(l->elem[j].name,nam);l->elem[j].num=num;l->elem[j].sex=s;l->elem[j].phnum=p;l->length++;}}void seekstu_hc(sqlist_hc *l){int low,high,mid,num,c;printf("输入查找人的学号和班级号:");scanf("%d %d",&num,&c);while(num!=-1||c!=-1){low=0;high=l->length-1;while(low<=high){mid=(low+high)/2;if(l->elem[mid].num<num)low=mid+1;else if(l->elem[mid].num>num)high=mid-1;else{if(l->elem[mid].cla<c)mid++;else if(l->elem[mid].cla>c)mid--;break;}}printf("%d,%s,%d,%c,%ld\n",l->elem[mid].cla,l->elem[mid].name,l->elem[mid].num,l->elem[mid].sex,l->elem[ mid].phnum);printf("输入查找人的学号和班级号:");scanf("%d %d",&num,&c);}}void printlist_hc(sqlist_hc*l){int i,j=0;printf("当前表中信息如下:class/name/num/sex/phonenum\n");for(i=0;i<l->sum;i++){printf("%d/%s/%d/%c/%ld",l->elem[i].cla,l->elem[i].name,l->elem[i].num,l->elem[i].sex,l->elem[i].phnum);if(++j==3){j=0;printf("\n");}}printf("\n");}main(){sqlist_hc *l;l=initlist_hc();createlist_hc(l);printlist_hc(l);seekstu_hc(l);printf("作者:黄晨");}。
查找-二分法查找（折半查找法）
查找-⼆分法查找（折半查找法）实现查找指定数值在元素有序的数组中存储的位置（索引），返回该位置（索引）。
解题步骤：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;}。
C语言实现折半查找法（二分法）
C语⾔实现折半查找法（⼆分法）折半查找法也叫做⼆分查找，顾名思义，就是把数据分成两半，再判断所查找的key在哪⼀半中，再重复上述步骤知道找到⽬标key;注意：折半查找法仅适⽤于对已有顺序的数组、数据进⾏操作很显然，折半查找法相对于其他查找⽅法例如顺序查找法效率要⾼很多；下⾯我们来实际操作⼀下，了解⼆分查找的奥义。
例如：要在数组arr[]={8,7,9,6,4,1,2,5,3,10,11};中查找key=7的位置；⾸先，我们要先将数组arr中的数据成员进⾏排序。
arr[]= {1,2,3,4,5,6,7,8,9,10,11};如图所⽰：将该组数据⼩端记作low，⼤端记作high,中间值记作mid;⼆分法查找时，将所查找的key与mid⽐较，例如key=7，即可缩⼩查找范围在mid和high之间；如图所⽰即可找到key=low=7;注意：（敲⿊板）如果中间数mid不是整数，需要进⾏取整。
代码如下：#include<stdio.h>int BinSearch(int arr[],int len,int key) //折半查找法（⼆分法）{int low=0; //定义初始最⼩int high=len-1; //定义初始最⼤int mid; //定义中间值while(low<=high){mid=(low+high)/2; //找中间值if(key==arr[mid]) //判断min与key是否2020111122411718相等return mid;else if(key>arr[mid]) //如果key>mid 则新区间为[mid+1,high]low=mid+1;else //如果key<mid 则新区间为[low,mid-1]high=mid-1;}return -1; //如果数组中⽆⽬标值key，则返回 -1 ；}int main(){int arr[]={1,2,3,4,5,6,7,8,9,10,11}; //⾸先要对数组arr进⾏排序printf("%d \n",BinSearch(arr,(sizeof(arr)/sizeof(arr[0])),7));return 0;}运⾏结果如下：希望对您有所帮助！以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。
折半查找的递归算法
折半查找的递归算法1. 介绍折半查找，也称为二分查找，是一种在有序数组中查找目标值的常用算法。
它的时间复杂度为O(logN)，相比于线性查找的O(N)效率更高。
折半查找的核心思想是每次将查找范围缩小一半，直到找到目标值或者确认目标值不存在。
2. 算法原理折半查找算法的原理非常简单，基本思路如下： 1. 确定查找范围的起始位置（一般为数组的首尾元素）。
2. 计算范围的中间位置。
3. 判断中间位置的元素与目标值的关系： - 如果中间元素等于目标值，查找成功。
- 如果中间元素大于目标值，缩小查找范围至左侧一半，回到第2步。
- 如果中间元素小于目标值，缩小查找范围至右侧一半，回到第2步。
4. 重复步骤2和3，直到找到目标值或者确认目标值不存在。
3. 递归实现折半查找可以使用递归的方式实现，递归版本的算法如下：def binary_search_recursive(arr, target, left, right):if left > right:return -1mid = (left + right) // 2if arr[mid] == target:return midif arr[mid] > target:return binary_search_recursive(arr, target, left, mid - 1) else:return binary_search_recursive(arr, target, mid + 1, right)在递归版本的算法中，参数arr是要进行查找的有序数组，target是目标值，left和right分别表示当前查找范围的左右边界。
算法的停止条件是左边界大于右边界，表示无法再缩小查找范围。
4. 算法分析接下来我们来分析折半查找的递归算法的时间复杂度和空间复杂度。
时间复杂度每次递归时，查找范围缩小一半，因此递归的层数最多为log2(N)。
实验二 折半查找算法设计
实验二折半查找算法设计题目：折半查找算法设计问题描述：（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、重复上述过程，直到找到目标元素或查找完整个数组，如果查找完整个数组仍未找到目标元素，则说明目标元素不存在。
三、二分法查找的适用范围二分法查找适用于有序的数组，这是基本的前提条件，除此之外，还有以下几个方面的适用：1、查找的单个元素相对较大，且数组较大；2、查找次数相对较少，这是因为要求先排序；3、查找数据变动不大或者不进行修改操作。
四、二分法查找的注意事项在使用二分法查找的过程中，需要注意以下几个问题：1、二分法查找必须是已经排过序的数组，否则是不可行的；2、在查找过程中，必须注意处理数据可能存在的越界问题；3、在进行二分法查找之前，需要进行预处理，尤其是数据的排序。
二分查找是一种高效的查找算法，尤其是在处理有序的大规模数据时更是如此。
对于需要在教学中查找各种教案的老师们，掌握二分法查找的方法，可以大大提高教学效率，让教学工作变得更加轻松！。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
对分查找算法及程序实现一、设计思想对分查找是计算机科学中的一个基础算法。
对于一个基础算法的学习，同样可以让学生在一定的情境下，经历分析问题、确定算法、编程求解等用计算机解决问题的基本过程。
本堂课以一个游戏暖场，同时激活学生的思维，引导学生去探索游戏或生活背后的科学原理。
为了让学生在教师的引导下能自我解析算法的形成过程，本课分解了问题动作，找出问题的全部可能情况，在对全部可能情况总结归纳的情况下，得出对分查找的基础算法，最后在程序中得到实现，从而使学生建立起对分查找算法形成的科学逻辑结构。
二、教材分析本课的课程标准内容：（一）计算机解决问题的基本过程（1）结合实例，经历分析问题、确定算法、编程求解等用计算机解决问题的基本过程，认识算法和程序设计在其中的地位和作用。
（三）算法与问题解决例举 C 查找、排序与问题解决（2）通过实例，掌握使用数据查找算法设计程序解决问题的方法。
本课的《学科教学指导意见》内容：基本要求：1.初步掌握对分查找算法。
2.初步掌握对分查找算法的程序实现。
教材内容：第二章算法实例 2.4.3对分查找和第五章5.4查找算法的程序实现，课题定为对分查找算法及程序实现，安排两个课时，第一课时着重是对分查找算法的形成和初步程序实现，第二课时利用对分查找算法解决一些实际问题的程序实现，本教学设计为第一课时。
从《课程标准》和《学科教学指导意见》对本课教学内容的要求来看，要求学生能从问题出发，通过相应的科学步骤形成对分查找的算法。
对学生来说，要求通过这一课时的学习能初步掌握或了解对分查找的前提条件、解决问题的对象，明确对分查找算法结构和对分查找的意义。
三、学情分析学生应该已经掌握程序设计的基本思想，掌握赋值语句、选择语句、循环语句的基本用法和VB基本操作，这节课学生可能会遇到的最大问题是：如何归纳总结对分查找解决不同情况问题的一般规律，鉴于此，在教学中要积极引导学生采取分解动作、比较迁移等学习策略。
四、教学目标知识与技能：理解对分查找的概念和特点，通过分步解析获取对分查找的解题结构，初步掌握对分查找算法的程序实现。
过程与方法：通过分析多种不同的可能情况，逐步归纳对分查找的基本思想和方法，确定解题步骤。
情感态度与价值观：通过实践体验科学解题的重要性，增强效率意识和全局观念，感受对分查找算法的魅力，养成始终坚持、不断积累才能获得成功的意志品质。
五、重点难点教学重点和难点：分解并理解对分查找的过程。
六、教学策略与手段1、教学线索：游戏引领---提出对分查找原理--- 解析对分查找的算法特征---实践解决问题。
2、学习线索：分解问题---归纳问题---实践提升，在三个阶段的不断推进中明确对分查找算法，总结规律。
七、教学过程1、新课导入（1）热身：游戏（2分钟）教师展示一件特色物品，让一个学生来猜这个物品的价格，其他学生只需要根据这个学生猜出的价格提示“高了”或是“低了”，如果学生能在五次内猜对这个物品的价格，就把这件物品“赠送”给他……。
（2）讨论：你觉得怎么样猜可以猜的快一点呢？有什么技巧吗？你从这个游戏当中得到什么启示？(3分钟)（3）教师引导：这个世界不是缺少问题，而是缺少发现，其实在这个游戏的背后，含有一个非常经典的算法。
引出对分查找的的概念。
2、新课：教学步骤一：分析对分查找的原理和思想。
（3分钟）（1）对分查找是效率很高的查找方法，但被查找的数据必须是有序的。
（2）首先将查找的数与有序数组内处于中间位置的数据比较，如果中间位置上的数与查找的数不同，根据有序性，就可确定应该在数组的前半部分还是后半部分继续查找。
（3）在新确定的范围内，继续按上述方法进行查找，直到获得最终结果。
教学步骤二：分解对分查找算法（5分钟）假设：用一个数组d（1 to 10）来存放升序的元素序列，用i表示查找范围的起始位置的下标，j表示终止位置的下标,mid表示中间位置元素的下标。
（1） 第一种情况：要找的值在后半部分； 以查找键KEY=48为例分析 第一次比较：范围d(1)～d(10),mid= (1+10)\2, d(mid)<Key 所以可以确定接下来要找的范围是后半部分。
比较后i=mid+1第二次比较：范围d(6)～d(10),mid= (6+10)\2,d(mid)<Key 所以可以确定接下来要找的范围是后半部分。
比较后：i=mid+1第三次比较：范围d(9)～d(10)，mid= (9+10)\2,d(mid)=Key ，找到了。
思考：如果要找的是52? i,j,mid 分别是多少？这也说明当i=j 的时候是查找的最后可能次数，这也是终止查找的一个关键条件。
教学步骤三：继续分解对分查找算法中包含的其他情况。
画一画：请仿照上面的画法,分别画出key=17和key=20的查找示意图。
（2） 第二种情况：要找的值在前半部分； 以查找键KEY=17为例分析：mijd(10) d(9) d(8) d(7) d(6) d(5) d(4) d(3) d(2) d(1)mi d ijd(10)d(9) d(8) d(7)d(6) i mi d i jd(10)d(9)d(5)d(4) d(3) d(2) d(1) imij mid(4)d(3) d(2) d(1) d(3) d(4)mi ji结果分析：第一次比较后：j=mid-1第二次比较后：i=mid+1第三次比较后：找到了 （3）第三种情况：要找的值找不到；以查找键KEY=20为例分析： 结果分析：第一次比较后：j=mid-1第二次比较后：i=mid+1第三次比较后：i=mid+1第四次比较：i=j 但是d(mid)≠key,所以找不到。
教学步骤四：对各种情况进行归纳总结。
（1）Key 与d(mid)的大小比较影响i,j 的取值的规律： i 的取值规律：if d(mid)<key then i=mid+1 j 的取值规律：if d(mid)>key then j=mid-1 用分支结构实现。
i jmid(4)d(3) d(2)d(1)ijmid d(4)i,j,midd(10d(9) d(8) d(7) d(6) d(5) d(4) d(3) d(2) d(1) ij mi(2)继续进行重复查找的条件： i≤j，用循环结构实现。
教学步骤五：构建对分查找的流程图教学步骤六：对分查找算法的初步程序实现。
教师事先设计好Vb窗体，学生只需要在相应的程序体输入代表算法思想的关键语句。
附主要程序体：Private Sub Command2_Click()Dim key As Integer, mid As Integer, i As Integer, j As Integerkey = Val(Text1.Text)i = 1: j = 10Do While i <= jmid = (i + j) \ 2If d(mid) = key ThenText2.Text = "找到了，是第" & mid & "个"Exit SubEnd IfIf d(mid) < key Theni = mid + 1Elsej = mid - 1End IfLoopText2.Text = "找不到"End Sub程序说明：1、获得要查找的数据key的值 key = Val(Text1.Text)2、i,j赋初值。
i = 1: j = 103、求mid的值。
mid = (i + j) \ 24、分三种情况，（1）如果key=d(mid),则如果 d(mid) = key 那么Text2.Text = "找到了，在第" + Str(mid) + "个"。
（2）如果key>d(mid),那么i=mid+1 否则 j=mid+15、重复上述的3,4步，直到i超出j(或者理解为i<=j不成立，所以不能用for next,而要用do while语句）6、如果有找到key,那执行第4步（1）步后应该输出找到的位置后退出程序，如果不退出，说明key没有找到，所以在相应位置要输出“找不到”。
教学步骤七：评价。
评价学生的程序实现情况，并讨论或实践问题：如果是降序序列，该怎么样改动程序？如果序列元素不是10个，而是100个或更多呢？教学步骤八：总结提升。
（1）由于对分查找过程中的每次比较都能使得搜索空间减半，对分查找将不会使用超过log2n次比较来找到目标值。
（2）提升对分查找算法的实际意义：同学们可能还没有意识到二分查找是多么高效，那不妨设想一下在一个包含一百万个人名的电话簿中找一个名字，二分查找可以让你不超过21次就能找到指定的名字。
如果你能够将世界上所有的人按照姓名排序，那么你可以在35步以内找到任何人。
八、作业：1、以下的三组元素序列能采用对分查找法来查找吗？(1) 19，33，35，53，56，67，78，99(2)53，35，67，78，56，99，33，19(3)99，67，56，45，33，10，9，1，0，-92、设计一个能用对分查找算法思想解决的实际问题。
【参考资料】网络文章类/。