二分查找


二分查找的思想：

有序的序列，每次都是以序列的中间位置的数来与待查找的关键字进行比较，每次缩小一半的查找范围，直到匹配成功。
一个情景：将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。
一些算法 - 图1

二分查找优缺点：

优点是比较次数少，查找速度快，平均性能好。
缺点是要求待查表为有序表，且插入删除困难。

使用条件：查找序列是顺序结构，有序，因此，折半查找方法适用于不经常变动而查找频繁的有序列表。

使用递归实现：

  1. /**
  2.      * 使用递归的二分查找
  3.      *title:recursionBinarySearch
  4.      *@param arr 有序数组
  5.      *@param key 待查找关键字
  6.      *@return 找到的位置
  7.      */
  8.     public static int recursionBinarySearch(int[] arr,int key,int low,int high){
  10.         if(key < arr[low] || key > arr[high] || low > high){
  11.             return -1;                
  12.         }
  14.         int middle = (low + high) / 2;            //初始中间位置
  15.         if(arr[middle] > key){
  16.             //比关键字大则关键字在左区域
  17.             return recursionBinarySearch(arr, key, low, middle - 1);
  18.         }else if(arr[middle] < key){
  19.             //比关键字小则关键字在右区域
  20.             return recursionBinarySearch(arr, key, middle + 1, high);
  21.         }else {
  22.             return middle;
  23.         }    
  25.     }

不使用递归实现（while循环）：

  1.     /**
  2.      * 不使用递归的二分查找
  3.      *title:commonBinarySearch
  4.      *@param arr
  5.      *@param key
  6.      *@return 关键字位置
  7.      */
  8.     public static int commonBinarySearch(int[] arr,int key){
  9.         int low = 0;
  10.         int high = arr.length - 1;
  11.         int middle = 0;            //定义middle
  13.         if(key < arr[low] || key > arr[high] || low > high){
  14.             return -1;                
  15.         }
  17.         while(low <= high){
  18.             middle = (low + high) / 2;
  19.             if(arr[middle] > key){
  20.                 //比关键字大则关键字在左区域
  21.                 high = middle - 1;
  22.             }else if(arr[middle] < key){
  23.                 //比关键字小则关键字在右区域
  24.                 low = middle + 1;
  25.             }else{
  26.                 return middle;
  27.             }
  28.         }
  30.         return -1;        //最后仍然没有找到，则返回-1
  31.     }

测试

  1. public static void main(String[] args) {
  3.         int[] arr = {1,3,5,7,9,11};
  4.         int key = 4;
  5.         //int position = recursionBinarySearch(arr,key,0,arr.length - 1);
  7.         int position = commonBinarySearch(arr, key);
  9.                if(position == -1){
  10.             System.out.println("查找的是"+key+",序列中没有该数！");
  11.         }else{
  12.             System.out.println("查找的是"+key+",找到位置为："+position);
  13.         }
  15.     }

recursionBinarySearch()的测试：key分别为0，9，10，15的查找结果：

查找的是-1,序列中没有该数！
查找的是5,找到位置为：
查找的是6,序列中没有该数！
查找的是20,序列中没有该数！

commonBinarySearch()的测试：key分别为-1，5，6，20的查找结果：

查找的是-1,序列中没有该数！
查找的是5,找到位置为：
查找的是6,序列中没有该数！
查找的是20,序列中没有该数！

时间复杂度

采用的是分治策略
最坏的情况下两种方式时间复杂度一样：O(log2 N)

空间复杂度

算法的空间复杂度并不是计算实际占用的空间，而是计算整个算法的辅助空间单元的个数
非递归方式：
由于辅助空间是常数级别的所以：
空间复杂度是O(1);
递归方式：
递归的次数和深度都是log2 N,每次所需要的辅助空间都是常数级别的：
空间复杂度：O(log2N )