二分查找法

  B+树索引并不能 找到给定键值的具体行，只能找到数据行所在页，数据库把当前页载入内存进行 二分查找，故学习二分查找算法，递归式和非递归。

 二分查找的 条件是 有序 

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

  

package com.my.gzh.algorithm;

public class BSearch {

    public static void main(String[] args) {

        int[] a = { 1, 9, 15, 20, 25, 30, 50 };

        System.out.println(BAlgorithmRecuresiveSearch(a, 0, 6, 30));
        System.out.println(BAlgorithmSearch(a, 0, 6, 30));

    }
    
    /**
     * 递归式
     * 
     * @param arr
     * @param low
     * @param upper
     * @param target
     * @return
     */
    public static int BAlgorithmRecuresiveSearch(int[] arr, int low, int upper, int target) {

        int mid = (low + upper) / 2;

        if (arr[mid] > target) {
            return BAlgorithmRecuresiveSearch(arr, low, mid, target);
        }
        if (arr[mid] < target) {
            return BAlgorithmRecuresiveSearch(arr, mid, upper, target);
        }
        return mid;
    }
    
    /**
     * 非递归
     * 
     * @param arr
     * @param low
     * @param upper
     * @param target
     * @return
     */
    public static int BAlgorithmSearch(int[] arr, int low, int upper, int target) {

        while (low < upper) {
            int mid = (low + upper) / 2;

            if (arr[mid] > target) {

                upper = mid - 1;
            } else if (arr[mid] < target) {
                low = mid + 1;
            } else {
                return mid;
            }

        }
        return -1;
    }
}