查询资料：二分查找法

二分查找

编辑

同义词 二分查找法一般指二分查找

二分查找又称折半查找，优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而查找频繁的有序列表。首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

中文名
二分查找
外文名
Binary-Search
别    称
折半查找
应用学科
计算机
优    点
查找速度快
缺    点
待查表为有序表

目录

  1. 1 算法要求
  2. 2 算法复杂度
  3. 3 代码示例
  4. ? Python源代码
  1. ? pascal源代码
  2. ? C语言代码
  3. ? Java代码
  4. ? AAuto代码
  5. ? PHP代码
  1. ? C++代码
  2. ? AS3代码
  3. ? JavaScript代码
  4. ? PHP代码

算法要求

编辑

  1. 必须采用顺序存储结构

2.必须按关键字大小有序排列。

算法复杂度

编辑

二分查找的基本思想是将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()=O(logn)

下面提供一段二分查找实现的伪代码:

BinarySearch(max,min,des)

mid-<(max+min)/2

while(min<=max)

mid=(min+max)/2

if mid=des then

return mid

elseif mid >des then

max=mid-1

else

min=mid+1

return max

折半查找法也称为二分查找法，它充分利用了元素间的次序关系，采用分治策略，可在最坏的情况下用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。

代码示例

编辑

Python源代码


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

def binarySearch(lists,select):

    is_none=False

    iflists!=[]:

    cen_num=len(lists)/2

    tlag=lists[cen_num]

    gt_list=lists[0:cen_num]

    lt_list=lists[cen_num+1:]

if tlag==select:

    is_none=True

    return is_none

elif tlag>select:

    is_se=binarySearch(gt_list,select)

    if notis_se:

        return binarySearch(lt_list,select)

    return is_none

    elif tlag<select:

        is_se=binarySearch(lt_list,select)

if notis_se:

    return binarySearch(gt_list,select)

return is_none

pascal源代码


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

programjjzx(input,output);

var

a:array[1..10]ofinteger;

i,j,n,x:integer;

begin

[‘输入10个从小到大的数：‘]

for i:=1 to 10 do read(a[i]);

[‘输入要查找的数：‘]

readln(x);

i:=1;n:=10;j:=trunc((i+n)/2);

repeat

if a[j]>x then

begin

n:=j-1;j:=trunc((i+n)/2)

end

else if a[j]<x then

begin

i:=j+1;j:=trunc((i+n)/2)

end;

until(a[j]=x)or(i>=n);{为什么是这个结束循环条件——i>n表示所查找的范围已经空了（就是没找到）}

if a[j]=x then

writeln(‘查找成功！位置是：‘,j:3)

else

writeln(‘查找失败，数组中无此元素！‘)

end.

C语言代码


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

int BinSearch(SeqList *R，int n,KeyType K)

{

//在有序表R[0..n-1]中进行二分查找，成功时返回结点的位置，失败时返回-1

int low=0，high=n-1，mid；//置当前查找区间上、下界的初值

while(low<=high)

{

if(R[low].key==K)

return low;

if(R[high].key==k)

return high;

//当前查找区间R[low..high]非空

mid=low+((high-low)/2)；

//使用(low+high)/2会有整数溢出的问题

//（问题会出现在当low+high的结果大于表达式结果类型所能表示的最大值时，

//这样，产生溢出后再/2是不会产生正确结果的，而low+((high-low)/2)不存在这个问题

if(R[mid].key==K)

return mid；//查找成功返回

if(R[mid].key<K)

low=mid+1；//继续在R[mid+1..high]中查找

else

high=mid-1;//继续在R[low..mid-1]中查找

}

if(low>high)

return -1；//当low>high时表示所查找区间内没有结果，查找失败

}//BinSeareh

------------上面代码复杂难懂-----------------

int bsearchWithoutRecursion(intarray[],int low,int high,int target)

{

while(low<=high)

{

int mid=(low+high)/2;

if(array[mid]>target)

high=mid-1;

elseif(array[mid]<target)

low=mid+1;

else//findthetarget

return mid;

}

//the array does not contain the target

return-1;

}

----------------------------------------

递归实现


1

2

3

4

5

6

7

8

9

10

11

12

13

14

intbinary_search(constintarr[],intlow,inthigh,intkey)

{

int mid=low+(high-low)/2;

if(low>high)

return -1;

else{

if(arr[mid]==key)

return mid;

else if(arr[mid]>key)

return binary_search(arr,low,mid-1,key);

else

return binary_search(arr,mid+1,high,key);

}

}

Java代码


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

public static int binarySearch(Integer[] srcArray, int des) {

    int low = 0;

    int high = srcArray.length - 1;

    while ((low <= high) && (low <= srcArray.length - 1)

            && (high <= srcArray.length - 1)) {

        int middle = (high + low) >> 1;

        if (des == srcArray[middle]) {

            return middle;

        } else if (des < srcArray[middle]) {

            high = middle - 1;

        } else {

            low = middle + 1;

        }

    }

    return -1;

}

AAuto代码


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

//二分查找

functionbinSearch(t,v){

varp=#t;

varp2;

varb=0;

do{

p2=p;

p=b+math.floor((p-b)/2)//二分折半运算

if(p==b)return;

if(t[p]<v){//判断下限

b=p;

p=p2;

}

}while(t[p]>v)//判断上限

returnt[p]==v&&p;

}

//测试

tab={}

//创建数组，每个元素都是随机数

for(i=1;10;1){

tab[i]=math.random(1,10000)

}

//插入一个已知数

table.push(tab,5632)

//排序

table.sort(tab)

io.open()

io.print("数组",table.tostring(tab))

io.print("使用二分查找，找到5632在位置：",binSearch(tab,5632))

}

PHP代码


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

function binsearch($x,$a){

$c=count($a);

$lower=0;

$high=$c-1;

while($lower<=$high){

$middle=intval(($lower+$high)/2);

if($a[$middle]>$x)

$high=$middle-1;

elseif($a[$middle]<$x)

$lower=$middle+1;

else

return $middle;

}

return -1;

}

C++代码


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

int binSearch(const int *Array,int start,int end,int key)

{

    int left,right;

    int mid;

    left=start;

    right=end;

    //注释中为递归算法，执行效率低，不推荐

    /*

    if(key<Array[mid])

    {

        return(binSearch(Array,left,mid,key));

    }

    else if(key>Array[mid])

    {

        return(binSearch(Array,mid+1,right,key));

    }

    else

    return mid;

    */

    while(left<=right)

    {

        mid=(left+right)/2;

        if(key==Array[mid])  return mid;

        else if(key<Array[mid]) right=mid-1;

        else if(key>Array[mid]) left=mid+1;

    }

    return -1;

    //找不到就返回-1

}

AS3代码


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

publicstaticfunctionbinSearch(list:Array,low:int,high:int,key:int):int{

if(low>high)

return-1;

varmid:int=low+int((high-low)/2);

varindex:int=-1

if(list[mid]==key){

index=mid;

}elseif(list[mid]<key){

low=mid+1;

index=binSearch(list,low,high,key);

}else{

high=mid-1;

index=binSearch(list,low,high,key);

}returnindex;

}

JavaScript代码


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

varArr=[3,5,6,7,9,12,15];

functionbinary(find,arr,low,high){

if(low<=high){

if(arr[low]==find)

returnlow;

if(arr[high]==find)

returnhigh;

varmid=Math.ceil((high+low)/2);

if(arr[mid]==find){

returnmid;

}elseif(arr[mid]>find){

returnbinary(find,arr,low,mid-1);

}else{

returnbinary(find,arr,mid+1,high);

}

}

return-1;

}

binary(15,Arr,0,Arr.length-1);

PHP代码


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

/*二分查找：前提，该数组已经是一个有序数组，必须先排序，再查找。*/

functionbinarySearch(&$array,$findVal,$leftIndex,$rightIndex){

$middleIndex=round(($rightIndex+$leftIndex)/2);

if($leftIndex>$rightIndex){

echo‘查无此数<br/>‘;

return;

}

if($findVal>$array[$middleIndex]){

binarySearch($array,$findVal,$middleIndex+1,$rightIndex);

}elseif($findVal<$array[$middleIndex]){

binarySearch($array,$findVal,$leftIndex,$middleIndex-1);

}else{

echo"找到数据:index=$middleIndex;value=$array[$middleIndex]<br/>";

if($array[$middleIndex+1]==$array[$middleIndex]&&$leftIndex<$rightIndex){

binarySearch($array,$findVal,$middleIndex+1,$rightIndex);

}

if($array[$middleIndex-1]==$array[$middleIndex]&&$leftIndex<$rightIndex){

binarySearch($array,$findVal,$leftIndex,$middleIndex-1);

}

}

}
时间： 2024-10-26 05:58:30

查询资料：二分查找法的相关文章

二分查找法 冒泡排序法

二分查找又称折半查找,优点是比较次数少,查找速度快,平均性能好; 其缺点是要求待查表为有序表,且插入删除困难.因此,折半查找方法适用于不经常变动而查找频繁的有序列表. 首先,假设表中元素是按升序排列,将表中间位置记录的关键字与查找关键字比较,如果两者相等,则查找成功; 否则利用中间位置记录将表分成前.后两个子表,如果中间位置记录的关键字大于查找关键字,则进一步查找前一子表,否则进一步查找后一子表. 重复以上过程,直到找到满足条件的记录,使查找成功,或直到子表不存在为止,此时查找不成功. 二分查找

二分查找法

今年是大年初四,晚上闲的没事儿干,在手机上随手写了二分查找法,对有序数组或者循环有序数组都挺管用! public int binarySearch(int []nums,int key){ return binarySearch(nums,key,0,nums.length); } public int binarySearch(int []nums,int key,int left,int right){ int mid = (left + right) / 2; if(left <= rig

Java学习 （七）、数组，查找算法，二分查找法，冒泡排序，选择排序，插入排序

一.常用数组查找算法 工作原理:它又称为顺序查找,在一列给定的值中进行搜索,从一端的开始逐一检查每个元素,知道找到所需元素的过程. 例1:查找指定的数在数组中出现的位置,找到返回下标,找不到返回-1 1 import java.util.Scanner; 2 public class LinearSearch{ 3 public static void main(String []argas) 4 { 5 int [] array={10,100,90,65,80,92}; 6 System.o

冒泡排序法与二分查找法

冒泡排序(Bubble Sort) 是一种计算机科学领域的较简单的排序算法. 它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成. 这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端,故名. 算法原理 冒泡排序算法的运作如下:(从后往前) 比较相邻的元素.如果第一个比第二个大,就交换他们两个. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对.在这一点,最后的元素应该

【C/C++学院】（3）二维数组/二分查找法/指针/模块注射

1.二维数组 二维数组可以当做一个一维数组, 每一个元素又是一个一维数组. #include <stdio.h> #include <stdlib.h> void main() { int a[3][4] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 }; for (int i = 0; i < 3; i++) { for (int j = 0; j < 4; j++) { printf("%d,%d,%d,%x,%x &

php 二分查找法算法详解

一.概念:二分查找又称折半查找,优点是比较次数少,查找速度快,平均性能好:其缺点是要求待查表为有序表,且插入删除困难.因此,折半查找方法适用于不经常变动而查找频繁的有序列表.首先,假设表中元素是按升序排列,将表中间位置记录的关键字与查找关键字比较,如果两者相等,则查找成功:否则利用中间位置记录将表分成前.后两个子表,如果中间位置记录的关键字大于查找关键字,则进一步查找前一子表,否则进一步查找后一子表.重复以上过程,直到找到满足条件的记录,使查找成功,或直到子表不存在为止,此时查找不成功. 二.代

[c/c++] programming之路（15）、多维数组和二分查找法,小外挂

一.多维数组 1 #include<stdio.h> 2 #include<stdlib.h> 3 4 void main(){ 5 int num[3][4]; 6 int i,j; 7 for (i = 0; i < 3; i++) 8 { 9 for (j = 0; j < 4; j++) 10 { 11 num[i][j]=4*i+j+1; 12 printf("%-3d",num[i][j]); 13 } 14 printf("\

选择、冒泡排序，二分查找法以及一些for循环的灵活运用

import java.util.Arrays;//冒泡排序 public class Test { public static void main(String[] args) { int[] array = { 31, 22, 15, 77, 52, 32, 18, 25, 16, 7 }; // 冒泡 --> 两两比较 --> 提取出最大的数 在最后一位 //拿第一位和它后面的一位进行 两两比较 System.out.println(Arrays.toString(array)); fo

二分查找法以及拉格朗日插值查找法

不管是二分查找法还是拉格朗日法,必须先排序,否则无法使用. 插值查找发速度比二分查找法要快 插值查找法,数据均匀是1次找到,不均匀是多次,即使这样这样它也是快于二分的. 那个1.0挺重要的一个技巧,将那个比例变成实数. #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include <stdlib.h> #define N 1024 void search(int a[N],int num) { int tou = 0; int