二分法查找

来源：互联网发布：云计算板块编辑：程序博客网时间：2024/06/01 09:43

算法：当数据量很大适宜采用该方法。采用二分法查找时，数据需是排好序的。主要思想是：（设查找的数组区间为array[low, high]）（1）确定该区间的中间位置K（2）将查找的值T与array[k]比较。若相等，查找成功返回此位置；否则确定新的查找区域，继续二分查找。区域确定如下：a.array[k]>T 由数组的有序性可知array[k,k+1,……,high]>T;故新的区间为array[low,……，K-1]b.array[k]<T 类似上面查找区间为array[k+1,……，high]。每一次查找与中间值比较，可以确定是否查找成功，不成功当前查找区间缩小一半。递归找，即可，时间复杂度:O(log2n)。

中文名: 二分法查找
外文名: Binary Search

算法: 当数据量很大适宜采用该方法
要求: 数据需是排好序的
主要思想是: 设查找的数组区间为array

二分法查找算法

编辑

假如有一组数为3，12，24，36，55，68，75，88要查给定的值24.可设三个变量front，mid，end分别指向数据的上界，中间和下界，mid=（front+end）/2.

1.开始令front=0（指向3），end=7（指向88），则mid=3（指向36）。因为mid>x，故应在前半段中查找。

2.令新的end=mid-1=2，而front=0不变，则新的mid=1。此时x>mid，故确定应在后半段中查找。

3.令新的front=mid+1=2，而end=2不变，则新的mid=2，此时a[mid]=x，查找成功。

如果要查找的数不是数列中的数，例如x=25，当第三次判断时，x>a[mid]，按以上规律，令front=mid+1，即front=3，出现front>end的情况，表示查找不成功。

例：在有序的有N个元素的数组中查找用户输进去的数据x。

算法如下：

1.确定查找范围front=0，end=N-1，计算中项mid=（front+end）/2。

2.若a[mid]=x或front>=end,则结束查找；否则，向下继续。

3.若a[mid]<x,说明待查找的元素值只可能在比中项元素大的范围内，则把mid+1的值赋给front，并重新计算mid，转去执行步骤2；若a[mid]>x，说明待查找的元素值只可能在比中项元素小的范围内，则把mid-1的值赋给end，并重新计算mid，转去执行步骤2。

[一维数组，折半查找]

二分法查找算法复杂度分析

编辑

二分法查找时间复杂度

1.最坏情况查找最后一个元素（或者第一个元素）Master定理T(n)=T(n/2)+O(1)所以T(n)=O(logn)
2.最好情况查找中间元素O(1)查找的元素即为中间元素（奇数长度数列的正中间，偶数长度数列的中间靠左的元素）

二分法查找空间复杂度：

S(n)=n

二分法查找java代码

编辑

?
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
public class BubbleTest
{
        public static int binary(int[] array, int value)
    {
        int low = 0;
        int high = array.length - 1;
        while(low <= high)
        {
            int middle = (low + high) / 2;
            if(value == array[middle])
        {
            return middle;
        }
            if(value > array[middle])
        {
            low = middle + 1;
        }
            if(value < array[middle])
        {
            high = middle - 1;
        }
        }
            return -1;
        }
            public static void main(String[] args)
        {
            int[] a = {1, 2, 3, 4, 5, 6, 7, 8, 9};
            int value = binary(a, 9);
            System.out.println(value);
    }
}

二分法查找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
#include<stdio.h>
//递归算法
int recurbinary(int *a, int key, int low, int high)
{
    int mid;
    if(low > high)
        return -1;
    mid = (low + high)/2;
    if(a[mid] == key) return mid;
    else if(a[mid] > key)
        return recurbinary(a,key,low,mid -1);
    else
        return recurbinary(a,key,mid + 1,high);
}
 
//非递归算法
int binary( int *a, int key, int n )
{
    int left = 0, right = n - 1, mid = 0;
    mid = ( left + right ) / 2;
    while( left < right && a[mid] != key )
    {
        if( a[mid] < key ) {
            left = mid + 1;
        } else if( a[mid] > key ) {
            right = mid - 1;
        }
        mid = ( left + right ) / 2;
    }
    if( a[mid] == key )
        return mid;
    return -1;
}
int main()
{
    int a[] = {1,2,3,4,5,6,7,8,9,12,13,45,67,89,99,101,111,123,134,565,677};
    int b[] = {677,1,7,11,67};
    int i;
    for( i=0; i<sizeof(b)/sizeof(b[0]); i++ )
    {
        //printf( "%d\n", recurbinary(a, b[i],0,sizeof(a)/sizeof(a[0])-1) );
        printf( "%d\n", binary( a, b[i], sizeof(a)/sizeof(a[0])));
    }
    return 0;
}

二分法查找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
#include<iostream>
#define N 10
using namespace std;
int main()
{
     int a[N],front,end,mid,x,i;
     cout<<"请输入已排好序的a数组元素:"<<endl;
     for(i=0;i<N;i++)
              cin>>a[i];
     cout<<"请输入待查找的数x:"<<endl;
     cin>>x;
     front=0;
     end=N-1;
     mid=(front+end)/2;
     while(front<end&&a[mid]!=x)
     {
        if(a[mid]<x)front=mid+1;
        if(a[mid]>x)end=mid-1;
        mid=(front+end)/2;
     }
     if(a[mid]!=x)
          printf("没找到！\n");
     else
          printf("找到了，在第%d项里",mid+1);
  return 0;
}

二分法查找php代码

编辑

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?php
function binarySearch($array, $val) {
    $count = count($array);
    $low = 0;
    $high = $count - 1;
    while ($low <= $high) {
        $mid = intval(($low + $high) / 2);
        if ($array[$mid] == $val) {
            return $mid;
        }
        if ($array[$mid] < $val) {
            $low = $mid + 1;
        } else {
            $high = $mid - 1;
        }
    }
    return false;
}

0 0