二分查找算法及其变种

前言

二分查找算法也称为折半查找算法，是一种在查找算法中普遍使用的算法。其算法的基本思想是：在有序表中，取中间的记录作为比较关键字，若给定值与中间记录的关键字相等，则查找成功；若给定的值小于中间记录的关键字，则在中间记录的左半区间继续查找；若给定值大于中间记录的关键字，则在中间记录的右半区间继续查找；不断重复这个过程，直到查找成功。否则查找失败。这个思想与孔子中的中庸思想和相似。

二分查找算法的实现

基于上述的思想，可以很快写出如下代码：

public int binarySearch(int[] a,int key) {
        int low = 0;
        int high = a.length - 1;
        int mid = 0;
        while(low <= high){
            mid = (low + high) / 2;
            if(a[mid] == key) return mid;
            if(a[mid] > key) high = mid - 1;
            if(a[mid] < key) low = mid + 1;
        }
        return -1;
    }
 
 
1
2
3
4
5
6
7
8
9
10
11
12
 
 
1
2
3
4
5
6
7
8
9
10
11
12

实际上，二分查找的过程可以绘制成一棵二叉树，每次二分查找的过程就相当于把原来的树划分为两棵子树，所以每次二分之后下次就只需要查找其中一半的数据就可以了。那么二分查找算法的时间复杂度是多少呢？在最好的情况下，只需要查找一次就可以了，因为这时候中间记录的关键字与要查找的key是相等，自然一次就够了。在最坏的情况下是从根节点查找到最下面的叶子结点，这个过程需要的时间复杂度是 O(logn) 。

需要注意的是，虽然二分查找算法的效率很高（这也是二分查找算法被广泛应用的原因），但是仍然是有使用条件的：有序。就是说在需要频繁进行插入或者删除操作的数据记录中使用二分查找算法不太划算，因为要维持数据的有序还需要额外的排序开销。

二分查找算法的变种一：插值查找算法

可以发现二分查找每次都是选取中间的那个记录关键字作为划分依据的，那为什么不可以是其他位置的关键字呢？在有些情况下，使用二分查找算法并不是最合适的。举个例子：在1-1000中，一共有1000个关键字，如果要查找关键字10，按照二分查找算法，需要从500开始划分，这样的话效率就比较低了，所以有人提出了插值查找算法。说白了就是改变划分的比例，比如三分或者四分。

插值查找算法对二分查找算法的改进主要体现在mid的计算上，其计算公式如下： 

mid=low+key−a[low]a[high]−key(high−low)

而原来的二分查找公式是这样的： 

mid=low+12(high−low)

所以我们发现主要变化的地方是 12 这个系数。其思想可以总结如下：插值查找是根据要查找的关键字的key与查找表中最大最小记录的关键字比较之后的查找算法，其核心是上述计算mid的计算公式。由于大体框架与二分查找算法是一致的，所以时间复杂度仍然是 O(logn) 。

二分查找算法变种二：斐波那契查找算法

从前面的分析中可以看到，无论划分的关键字太大或者太小都不合适，所以又有人提出了斐波那契查找算法，其利用了黄金分割比原理来实现的。

一个数列如果满足F(n)=F(n-1)+F(n-2)，则称这个数列为斐波那契数列。在斐波那契查找算法中计算mid的公式如下：

mid=low+F(k−1)−1

其实现代码如下：

package com.rhwayfun.algorithm.search;

public class FibonacciSearch {

    public int fibonacciSearch(int[] a,int key){
        int low = 0,high = a.length - 1,mid = 0,k = 0,i =0;
        //计算数组的长度的值在斐波那契数列的位置
        while(a.length > F(k) - 1){
            k++;
        }
        //将不满的数值补全
        int[] newArray = new int[F(k) - 1];
        System.arraycopy(a, 0, newArray, 0, a.length);
        for(i = a.length; i < F(k) - 1; i++)
            newArray[i] = a[a.length - 1];
        a = newArray;
        //查找过程
        while(low <= high){
            mid = low + F(k-1) - 1;
            if(key < a[mid]){
                high = mid - 1;
                k = k - 1;
            }else if(key > a[mid]){
                low = mid + 1;
                k = k - 2;
            }else{
                if(mid < a.length){
                    return mid;
                }else{
                    //说明是补全之后的数值
                    return a.length - 1;
                }
            }
        }
        return 0;
    }

    //返回第n项斐波那契数列的值
    private int F(int n) {
        if(n == 0){
            return 0;
        }else if(n == 1){
            return 1;
        }
        int one = 1;
        int two = 0;
        int sum = 0;
        for (int i = 2; i <= n; i++) {
            sum = one + two;
            two = one;
            one = sum;
        }
        return sum;
    }

    public static void main(String[] args) {
        int[] a = {0,1,16,24,35,47,59,62,73,88,99};
        int i = new FibonacciSearch().fibonacciSearch(a, 59);
        System.out.println(a[i]);
    }
}

 
 
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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
 
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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

可以看出斐波那契查找算法的核心是如果要查找的记录在右侧，则左边就不会再去查找了，不断反复进行下去，知道查找成功。虽然斐波那契查找算法的时间复杂度也是 O(logn) ，但是从性能看，仍然是优于二分查找算法的。