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
     }