查找算法的实现

Ⅰ 二叉树查找树算法实现

#include<stdio.h>
#include<stdlib.h>
#define OK 1
#define ERROR 0
#define OVERFLOW -1
#define EQ(a,b) ((a)==(b))
#define LT(a,b) ((a)<(b))
typedef int ElemType;
typedef int Status;
typedef struct TElemType{
int key;
int num;
}TElemType;
typedef struct BiTNode{
TElemType data;
struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

Status SearchBST(BiTree T,int key,BiTree f,BiTree &p){
if(!T) { p=f; return ERROR;}
else if(EQ(T->data.key,key)) { p=T; return OK; }
else if(LT(key,T->data.key))
return SearchBST(T->lchild,key,T,p);
else return SearchBST(T->rchild,key,T,p);
}
Status SearchBST1(BiTree T,int key,BiTree f,BiTree &p){
if(!T) { p=f; return ERROR;}
else if(EQ(T->data.key,key)) {
printf("%d %d",p->data.key,p->data.num);
p=T; return OK; }
else if(LT(key,T->data.key))
return SearchBST(T->lchild,key,T,p);
else return SearchBST(T->rchild,key,T,p);
}
Status InsertBST(BiTree &T,TElemType e){
BiTree s,p;
if(!SearchBST(T,e.key,NULL,p)){
s=(BiTree)malloc(sizeof(BiTNode));
s->data=e;
s->lchild=s->rchild=NULL;
if(!p) T=s;
else if(LT(e.key,p->data.key)) p->lchild=s;
else p->rchild=s;
return OK;
}
}
Status Output(TElemType e){
printf("%d ",e.key);
printf("%d\n",e.num);
}
Status PreOrderTraver( BiTree T){//二叉树先序遍历
if(T==NULL) return ERROR;
else{
Output(T->data);
PreOrderTraver(T->lchild);
PreOrderTraver(T->rchild);}
return OK;
}
int main()
{
BiTree T,f=NULL,q;
TElemType a;
int i,n,b;
printf("请输入你要创建的二叉排序树的结点个数:\n");
scanf("%d",&n);
for(i=0;i<n;i++){
scanf("%d",a.key);
scanf("%d",a.num);
InsertBST(T,a);
}
printf("请输入你要查找的关键字: ");{
scanf("%d",b);
if(SearchBST1(T,b,f,q)) printf("查找成功！\n");
else printf("查找失败！\n");}
printf("二叉树的先序遍历:\n");
PreOrderTraver(T);
system("pause");
return 0;
}
这个就是！希望可以帮助你！

Ⅱ php如何实现折半查找算法

定义：折半查找技术，也就是二分查找。它的前提是线性表中的记录必须是关键码有序（通常从大到小有序），线性表必须采用顺序存储。

折半查找的基本思想：取中间记录作为比较对象，若给定值与中间记录的关键字，则在中间记录的关键字相等，则查找成功；若给定值小于中间记录的作伴去继续查找；若给定值大于中间记录的关键字，则在中间记录的右半区继续查找。不断重复上述过程，直到查找成功，或所有查找区域无记录，查找失败为止。

实现代码：
<?php //递归方式 function bin_recur_search($arr,$val){ global $time; if(count($arr) >= 1){ $mid = intval(count($arr) / 2); $time++; if($arr[$mid] == $val){ return '值为:'.$arr[$mid].'<br>查找次数：'.$time.'<br>'; }elseif($arr[$mid] > $val){ $arr = array_splice($arr,0,$mid); return bin_recur_search($arr, $val); }else{ $arr = array_slice($arr,$mid + 1); return bin_recur_search($arr, $val); } } return '未找到'.$val; } //非递归方式 function bin_search($arr,$val){ if(count($arr) >= 1){ $low = 0; $high = count($arr); $time = 0; while($low <= $high){ $time++; $mid = intval(($low + $high)/2); if($val == $arr[$mid]){ return '索引：'.$mid.'<br>值为：'.$arr[$mid].'<br>查找次数：'.$time; }elseif($val > $arr[$mid]){ $low = $mid + 1; }else{ $high = $mid - 1; } } } return '未找到'.$val; } $arr = array(1,3,5,7,7,9,25,68,98,145,673,8542); echo bin_recur_search($arr, 673); echo bin_search($arr, 673); ?>
运行结果：
值为:673 查找次数：4 索引：10 值为：673 查找次数：4
更多关于PHP相关内容感兴趣的读者可查看本站专题：《PHP数据结构与算法教程》、《php程序设计算法总结》、《php字符串(string)用法总结》、《PHP数组(Array)操作技巧大全》、《PHP常用遍历算法与技巧总结》及《PHP数学运算技巧总结》

Ⅲ java中的查找算法如何实现... 高手帮帮忙

这个。。。我随便乱说几句啊，说的不对别见笑。

有一个数组 当中存有一些字符串
另外有一个字典文件 我也将它导入一个数组 有50000多个单词
然后要找出字符串中包含的单词

由你给的条件可知：
1。数组 应该是从前到后依次顺序扫描字符串。
2。50000多个单词的字典文件一定优化。具体优化要看具体内容吧。
比如你可以按单词的首字母排序，然后分组。等扫描字符串的时候可以分组比较。但这种方法应该没省多少时间。
你还可以把50000多个单词的字典文件按单词的长度进行分组。比如1个字母的分成一组，二个字母的分成一组。。。。N个字母的分成一组，这样就分成了N组。然后扫描字符串的时候你可以按后续匹配（好象叫这个算法吧，名字记不清了）算法，这样就可以省很多时间了。
你还可以这样做，因为你要查的是单词，单词一定有意义。那你可以直接把你的字符串数组先进行语法、语义分析并分割，然后再去匹配你的字典。这样应该是最快的。但这要用到自然语言处理。。。

Ⅳ C语言 查找算法实现

#include

int main() {
int i,x,n,*result = NULL;
int a[10],low,high,mid;

scanf_s("%d",&n);
// 确保输入的数据是非递减的
for(i = 0 ; i < n && i < 10 ; i++) {
scanf_s("%d",&a[i]);
}

fflush(stdin); // 如果输入的数组元素多于10个，则废弃
scanf_s("%d",&x);

low = 0,high = n - 1;
while(low <= high) {
mid = (low + high) / 2;
if(x == a[mid]) {
result = &a[mid]; // 这里给出的是查找到该元素的指针
break;
}
else if(x < a[mid]) {
high = mid - 1;
}
else {
low = mid + 1;
}
}
if(result != NULL) {
printf("%d\n",*result);
}
else {
printf("no result\n");
}
return 0;
}

Ⅳ java二分法查找的递归算法怎么实现

publicclass二分法递归查找{
	publicstaticvoidmain(String[]args){

		//定义数组,注意,二分查找数组必须是有序的数组!
		int[]arr={1,3,5,7,9,11,13,15,17};
		
		//接受查找后的返回值:索引值,如果没有则是-1;
		//测试查找元素:9
		inta=binary(arr,9,0,arr.length-1);
		System.out.println("被查找数字索引位置在:"+a);
	}
	//参数列表依次为:被查找的数组,查找的数字,头索引,尾索引!
	publicstaticintbinary(int[]arr,intkey,intstar,intend)//递归
	{
		//每次进来创建,中间索引值!
		intmid=(star+end)/2;
		//如果被查找数小于头,或者尾,或者头索引大于尾索引,则说明无该数,返回-1;
		if(key<arr[star]||key>arr[end]||star>end){
			return-1;
		}
		//如果中间值小于被查找数,则重新定义头索引移至中间+1位置,筛选掉一半数字!
		if(arr[mid]<key){
			//开始递归!
			returnbinary(arr,key,mid+1,end);
			//否则如果中间值大于被查找数,则重新尾索引移至中间-1位置,筛选掉一半数字!
		}elseif(arr[mid]>key){
			//开始递归!
			returnbinary(arr,key,star,mid-1);
		}else{
			//否者就是找到了,返回该索引!
			returnmid;
		}
	}
}

Ⅵ PHP二分查找算法的实现方法示例

本文实例讲述了PHP二分查找算法的实现方法。分享给大家供大家参考，具体如下：
二分查找法需要数组是一个有序的数组
假设我们的数组是一个递增的数组，首先我们需要找到数组的中间位置.
1.
要知道中间位置就需要知道起始位置和结束位置，然后取出中间位置的值来和我们的值做对比。
2.
如果中间值大于我们的给定值，说明我们的值在中间位置之前，此时需要再次二分，因为在中间之前，所以我们需要变的值是结束位置的值，此时结束位置的值应该是我们此时的中间位置。
3.
反之，如果中间值小于我们给定的值，那么说明给定值在中间位置之后，此时需要再次将后一部分的值进行二分，因为在中间值之后，所以我们需要改变的值是开始位置的值，此时开始位置的值应该是我们此时的中间位置，直到我们找到指定值。
4.
或者中间值等于最初的起始位置，或结束位置（此时说明给定值未找到），下面我们来用代码实现~
//循环实现
function
getValue($num,$arr)
{
//查找数组的中间位置
$length=count($arr);
$start=0;
$end=$length;
$middle=floor(($start+$end)/2);
//循环判断
while($start>$end-1)
{
if($arr[middle]==$num)
{
return
middle+1;
}
elseif($arr[middle]<$num)
{
//如果当前要查找的值比当前数组的中间值还要打，那么意味着该值在数组的后半段
//所以起始位置变成当前的middle的值，end位置不变。
$start=$middle;
$middle=floor(($start+$end)/2);
}
else{
//反之
$end=$middle;
$middle=floor(($start+$end)/2);
}
}
return
false;
}
//递归实现
/*
*
从数组中获取元素值
*
@param1
int
$num，要查找的目标值
*
@param2
array
$arr，要查找的数组
*
@param3
int
$start，查找的起始位置
*
@param4
int
$end，查找的结束位置
*
@return
mixed，找到了返回位置，没找到返回false
*/
function
getValue4($num,$arr,$start
=
0,$end
=
100){
//采用二分法查找
$middle
=
floor(($end
+
$start)
/
2);
//判断
if($arr[$middle]
==
$num){
//已经找到了，递归的出口
return
$middle
+
1;
}elseif($arr[$middle]
<
$num){
//要查找的元素在数组的后半段
$start
=
$middle
+
1;
//边界值
if($start
>=
$end){
//没有找到，但是已经超出边界值，递归出口
return
false;
}
//调用自己去查找：递归点
return
getValue4($num,$arr,$start,$end);
//getValue4($num,$arr,51,100)
}else{
//要查找的元素在数组的前半段
$end
=
$middle
-
1;
//判断边界值
if($end
<
0)return
false;
//调用自己：递归点
return
getValue4($num,$arr,$start,$end);
//getValue4($num,$arr,0,49)
}
//都没有找到
return
false;
}
更多关于PHP相关内容感兴趣的读者可查看本站专题：《PHP数据结构与算法教程》、《PHP基本语法入门教程》、《php面向对象程序设计入门教程》、《php字符串(string)用法总结》及《php查找技巧与方法总结》
希望本文所述对大家PHP程序设计有所帮助。

Ⅶ 查找的计算机算法

⒈顺序查找的思想是：
将查找值顺序逐个与结点值进行比较，相等即为查找成功，否则查找失败.
程序如下：
program sxcz;
const n=7;
type
arr=array[1..n] of integer;
var x1,i:integer;
a:arr;
b:boolean;
place:integer;
procere search(r:arr;m,x:integer; var found:boolean;var p:integer);
begin
p:=1;found:=false;
while(p<=m) and not found do
if r[p]=x then found:=true else p:=p+1;
end;
begin
write('Enter array:');
for i:=1 to n do read(a[i]);
writeln;
write('Enter search data:');
read(x1）；
search(a,n,x1,b,place);
if b then begin writeln('yes');writeln('Place of',x1:5,'is:',place); end
else writeln('no');
end. ⒈二分查找的基本思想：首先将结点按关键字排序，其次将查找值与中间位置的值比较，相等，查找成功；不等，则中间数据大于或小于查找值，无论怎样查找将在一半的数据中查找。
⒉例：输入序列数据查找指定值.
程序：
program sxcz;
const n=7;
type
arr=array[1..n] of integer;
var x1,i:integer;
a:arr;
place:integer;
procere paixv(var r:arr;m:integer);
var k,j,i,t:integer;
begin
k:=m;
while k>0 do
begin
j:=k-1;k:=0;
for i:=1 to j do
if r[i]>r[i+1] then
begin t:=r[i];a[i]:=r[i+1];r[i+1]:=t;k:=i;end;
end;
end;
procere search(r:arr;m,x:integer; var p:integer);
var low,high,mid:integer;
begin
p:=0;low:=1;high:=m;
while low<=high do
begin
mid:=(low+high) div 2;
if x>r[mid] then low:=mid+1 else
if x<r[mid] then high:=mid-1 else
begin p:=mid;exit;end;
end;
end;
begin
write('Enter array:');
for i:=1 to n do read(a[i]);
writeln;
write('Enter search data:');
read(x1）；
paixv(a,n);
search(a,n,x1,place);
if place<>0 then writeln('yes') else writeln('no');
end. 因为二叉排序树的左子树若不为空则左子树的所有结点的值均小于它的根结点的值，而右子树若不为空，则右子树的所有结点的值均不小大于它的根结点的值，根据这个性质查找算法如下：
program pxtree;
const
a:array[1..8] of integer=（10,18,3,8,12,2,7,3）；
type point=^nod;
nod=record
w:integer;
right,left:point ;
end;
var root,first:point;k:boolean;i,x:integer;
procere maketr(d:integer;var p:point);
begin
if p=nil then
begin
new(p);
with p^ do begin w:=d;right:=nil;left:=nil end;
if k then begin root:=p; k:=false end;
end
else with p^ do if d>=w then maketr(d,right) else maketr(d,left);
end;
function searchtr(x:integer;p:point):boolean;
begin
if p=nil then searchtr:=false
else if x=p^.w then searchtr:=true
else if x<p^.w then searchtr:=searchtr(x,p^.left)
else searchtr:=searchtr(x,p^.right);
end;
begin
first:=nil;k:=true;
for i:=1 to 8 do maketr(a[i],first);
write('want find data x:');read(x);
if searchtr(x,first) then writeln('yes') else writeln('No');
end. 以上讲的查找方法基于比较的，查找效率依赖比较次数，其实理想的查找希望不经比较，一次存取便能得到所查记录，那就必须在记录的存储位置和它的关键字之间建立一个确定的对应关系f，这样查找k时，只要根据这个对应关系f找到给定值k的像f(k）。这种对应关系f叫哈希（hash）函数。按这种思想建立的表叫哈希表（也叫散列表）。哈希表存取方便但存储时容易冲突（collision）：即不同的关键字可以对应同一哈希地址。如何确定哈希函数和解决冲突是关键。
⒈哈希函数的构造方法
直接寻址法：H(k)=k 或H(k)=a*k+b（线形函数）
如：人口数字统计表 地址 1 2 3 ... 100 年龄 1 2 3 ... 100 人数 67 3533 244 ... 4 数字分析法：取关键字的若干数位组成哈希地址
如：关键字如下：若哈希表长为100则可取中间两位10进制数作为哈希地址。 81346532 81372242 81387422 81301367 81322817 81338967 81354157 81368537 平方取中法：关键字平方后取中间几位数组成哈希地址
折叠法：将关键数字分割成位数相同的几部分（最后一部分的位数可以不同）然后取几部分的叠加和（舍去进位）作为哈希地址。
除留余数法：取关键字被某个不大于表长m的数p除后所得的余数为哈希地址。
H(k)=k mod p p<=m
随机数法：H(k)=rondom(k）。
⒉处理冲突的方法
假设地址集为0..n-1，由关键字得到的哈希地址为j(0<=j<=n-1）的位置已存有记录，处理冲突就是为该关键字的记录找到另一个空的哈希地址。在处理中可能得到一个地址序列Hi i=1，2，...k
0<=Hi<=n-1），即在处理冲突时若得到的另一个哈希地址H1仍发生冲突，再求下一地址H2，若仍冲突，再求H3...。怎样得到Hi呢？
开放寻址法：Hi=(H(k)+di) mod m （H(k）为哈希函数；m为哈希表长；di为增量序列）
当di=1，2，3，... m-1 时叫线性探测再散列。
当di=1，-1，2，-2，3，-3，...,k,-k时叫二次探测再散列。
当di=random（m）时叫伪随机探测序列。
例：长度为11的哈希表关键字分别为17，60，29，哈希函数为H(k)=k mod 11，第四个记录的关键字为38，分别按上述方法添入哈希表的地址为8，4，3（随机数=9）。
再哈希法：Hi=RHi(key) i=1,2,...,k，其中RHi均为不同的哈希函数。
链地址法：这种方法很象基数排序，相同的地址的关键字值均链入对应的链表中。
建立公益区法：另设一个溢出表，不管得到的哈希地址如何，一旦发生冲突，都填入溢出表。
⒊哈希表的查找
例：如下一组关键字按哈希函数H(k)=k mod 13和线性探测处理冲突所得的哈希表a[0..15]: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 14 01 68 27 55 19 20 84 79 23 11 10 当给定值k=84，则首先和a[6]比在依次和a[7],a[8]比结果a[8]=84查找成功。
当给定值k=38，则首先和a[12]比，再和a[13]比，由于a[13]没有，查找不成功，表中不存在关键字等于38的记录。 查找第k小元素即在n个元素中（未排序）找到第k小的元素。方法同快速排序，采用递归方式。
程序如下：
program kspv;
const n=7;
type
arr=array[1..n] of integer;
var
b:arr;
i,k:integer;
function p(s,t:integer):integer;
var i,j,t1,x:integer;
begin
i:=s;j:=t;x:=b[i];
repeat
while (b[j]>=x) and (j>i) do j:=j-1;
if j>i then begin t1:=b[i]; b[i]:=b[j];b[j]:=t1;end;
while (b[i]<=x) and (i<j) do i:=i+1;
if i<j then begin t1:=b[j];b[j]:=b[i];b[i]:=t1; end
until i=j;
b[i]:=x;
p:=i;
end;
function find(s,t,k:integer):integer;
var p1,q:integer;
begin
if s=t then find:=b[s] else
begin
p1:=p(s,t);
q:=p1-s+1;
if k<=q then find:=find(s,p1,k) else find:=find(p1+1,t,k-q);
end;
end;
begin
write('input data:');
for i:=1 to n do read(b[i]);readln;
write('input k:');read(k);
write('output data:');
writeln('kthsmall:=',find（1,n,k));
end.

Ⅷ 数据库得查询功能是怎么实现的

数据库的查询功能实现原理：

数据库查询是数据库的最主要功能之一。我们都希望查询数据的速度能尽可能的快，因此数据库系统的设计者会从查询算法的角度进行优化。最基本的查询算法当然是顺序查找（linear search），这种复杂度为O(n)的算法在数据量很大时显然是糟糕的，好在计算机科学的发展提供了很多更优秀的查找算法，例如二分查找（binary search）、二叉树查找（binary tree search）等。如果稍微分析一下会发现，每种查找算法都只能应用于特定的数据结构之上，例如二分查找要求被检索数据有序，而二叉树查找只能应用于二叉查找树上，但是数据本身的组织结构不可能完全满足各种数据结构（例如，理论上不可能同时将两列都按顺序进行组织），所以，在数据之外，数据库系统还维护着满足特定查找算法的数据结构，这些数据结构以某种方式引用（指向）数据，这样就可以在这些数据结构上实现高级查找算法。这种数据结构，就是索引。

图1展示了一种可能的索引方式。左边是数据表，一共有两列七条记录，最左边的是数据记录的物理地址（注意逻辑上相邻的记录在磁盘上也并不是一定物理相邻的）。为了加快Col2的查找，可以维护一个右边所示的二叉查找树，每个节点分别包含索引键值和一个指向对应数据记录物理地址的指针，这样就可以运用二叉查找在O(log2n)O(log2n)的复杂度内获取到相应数据。

Ⅸ C语言编写数据结构查找算法

实验五 查找的实现
一、 实验目的
1．通过实验掌握查找的基本概念；
2．掌握顺序查找算法与实现；
3．掌握折半查找算法与实现。
二、 实验要求
1． 认真阅读和掌握本实验的参考程序。
2． 保存程序的运行结果，并结合程序进行分析。
三、 实验内容
1、建立一个线性表，对表中数据元素存放的先后次序没有任何要求。输入待查数据元素的关键字进行查找。为了简化算法，数据元素只含一个整型关键字字段，数据元素的其余数据部分忽略不考虑。建议采用前哨的作用，以提高查找效率。
2、查找表的存储结构为有序表，输入待查数据元素的关键字利用折半查找方法进行查找。此程序中要求对整型量关键字数据的输入按从小到大排序输入。
一、顺序查找
顺序查找代码：
#include"stdio.h"
#include"stdlib.h"
typedef struct node{
intkey;
}keynode;
typedef struct Node{
keynoder[50];
intlength;
}list,*sqlist;
int Createsqlist(sqlist s)
{
inti;
printf("请输入您要输入的数据的个数:\n");
scanf("%d",&(s->length));
printf("请输入您想输入的%d个数据;\n\n",s->length);
for(i=0;i<s->length;i++)
scanf("%d",&(s->r[i].key));
printf("\n");
printf("您所输入的数据为:\n\n");
for(i=0;i<s->length;i++)
printf("%-5d",s->r[i].key);
printf("\n\n");
return1;
}
int searchsqlist(sqlist s,int k)
{
inti=0;
s->r[s->length].key=k;
while(s->r[i].key!=k)
{

i++;
}
if(i==s->length)
{
printf("该表中没有您要查找的数据！\n");
return-1;
}
else
returni+1;
}
sqlist Initlist(void)
{
sqlistp;
p=(sqlist)malloc(sizeof(list));
if(p)
returnp;
else
returnNULL;
}
main()
{
intkeyplace,keynum;//
sqlistT;//
T=Initlist();
Createsqlist(T);
printf("请输入您想要查找的数据的关键字:\n\n");
scanf("%d",&keynum);
printf("\n");
keyplace=searchsqlist(T,keynum);
printf("您要查找的数据的位置为:\n\n%d\n\n",keyplace);
return2;
}
顺序查找的运行结果：
二、折半查找
折半查找代码：
#include"stdio.h"
#include"stdlib.h"
typedef struct node{
intkey;
}keynode;
typedef struct Node{
keynoder[50];
intlength;
}list,*sqlist;
int Createsqlist(sqlist s)
{
inti;
printf("请输入您要输入的数据的个数:\n");
scanf("%d",&(s->length));
printf("请由大到小输入%d个您想输入的个数据;\n\n",s->length);
for(i=0;i<s->length;i++)
scanf("%d",&(s->r[i].key));
printf("\n");
printf("您所输入的数据为:\n\n");
for(i=0;i<s->length;i++)
printf("%-5d",s->r[i].key);
printf("\n\n");
return1;
}
int searchsqlist(sqlist s,int k)
{
intlow,mid,high;
low=0;
high=s->length-1;
while(low<=high)
{
mid=(low+high)/2;
if(s->r[mid].key==k)
returnmid+1;
elseif(s->r[mid].key>k)
high=mid-1;
else
low=mid+1;
}
printf("该表中没有您要查找的数据!\n");
return-1;
}
sqlist Initlist(void)
{
sqlistp;
p=(sqlist)malloc(sizeof(list));
if(p)
returnp;
else
returnNULL;
}
main()
{
intkeyplace,keynum;//
sqlistT;//
T=Initlist();
Createsqlist(T);
printf("请输入您想要查找的数据的关键字:\n\n");
scanf("%d",&keynum);
printf("\n");
keyplace=searchsqlist(T,keynum);
printf("您要查找的数据的位置为:\n\n%d\n\n",keyplace);
return2;
}
折半查找运行结果：
三、实验总结：
该实验使用了两种查找数据的方法（顺序查找和折半查找），这两种方法的不同之处在于查找方式和过程不同，线性表的创建完全相同，程序较短，结果也一目了然。

Ⅹ 二分搜索算法是利用什么实现的算法

二分搜索算法是利用排除剩余元素中一半的元素实现的算法。

在计算机科学中，二分搜索（英语：binary search），也称折半搜索（英语：half-interval search）、对数搜索（英语：logarithmic search），是一种在有序数组中查找某一特定元素的搜索算法。

二分搜索算法原理：

1、如果待查序列为空，那么就返回－1，并退出算法；这表示查找不到目标元素。如果待查序列不为空，则将它的中间元素与要查找的目标元素进行匹配，看它们是否相等。如果相等，则返回该中间元素的索引，并退出算法；此时就查找成功了。如果不相等，就再比较这两个元素的大小。

2、如果该中间元素大于目标元素，那么就将当前序列的前半部分作为新的待查序列；这是因为后半部分的所有元素都大于目标元素，它们全都被排除了。

3、如果该中间元素小于目标元素，那么就将当前序列的后半部分作为新的待查序列；这是因为前半部分的所有元素都小于目标元素，它们全都被排除了。