Java学习之二分查找算法

 好久没写算法了。只记得递归方法。。结果测试下爆栈了。

思路就是取范围的中间点，判断是不是要找的值，是就输出，不是就与范围的两个临界值比较大小，不断更新临界值直到找到为止，给定的集合一定是有序的。

自己写的代码：

package com.gh;

import java.util.Arrays;
/**
 * 二分查找算法实现
 * @author ganhang
 *
 */
public class Search {
    public static void main(String[] args) {
        search1(0, 10000, 20000);
        if(search2(0,2100000001,200000100)){
            System.out.println("找到了!");
        }
        else System.out.println("没找到!");
    }
    /**
     * 懒得传数组，直接在a到b找n。。。
     * 发现比数组的二分容易实现点
     * @param a
     * @param b
     * @param n
     */
    //想法太native递归爆栈了
    public static void search1(int a, int b, int n) {
        int tmp = (int) (a + b) / 2;
        if (a == tmp || b == tmp) {
            System.out.println("没找到！");
            return;
        }
        if (n == tmp) {
            System.out.println("找到了！");
        } else if (n > tmp)
            search1(tmp, b, n);
        else if (n < tmp)
            search1(a, tmp, n);
    }
    //递推实现
    public static boolean search2(int a,int b,int n) {
        int tmp;
        while(true){
            tmp=(int)(a+b)/2;
            if(n==tmp)return true;
            else if(n>tmp){a=tmp;}
            else if(n<tmp){b=tmp;}
            if(a==b)return false;
        }
    }
}

对比Arrays工具类的二分查找，自己注释了下

  private static int binarySearch0(int[] a, int fromIndex, int toIndex,
                                     int key) {
        int low = fromIndex;
        int high = toIndex - 1;// 一般是a的length-1，java里一般头封尾不封

        while (low <= high) {
            int mid = (low + high) >>> 1;//无符号右移一位相当于除2，但速度快点
            int midVal = a[mid];

            if (midVal < key)
                low = mid + 1;//优化
            else if (midVal > key)
                high = mid - 1;//优化
            else
                return mid; // key found返回下标
        }
        return -(low + 1);  // key not found.返回负数表示没找到，这技巧6
    }