java实现二分查找-两种方式

原文：https://blog.csdn.net/maoyuanming0806/article/details/78176957

二分查找是一种查询效率非常高的查找算法。又称折半查找。

起初在数据结构中学习递归时实现二分查找，实际上不用递归也可以实现，毕竟递归是需要开辟额外的空间的来辅助查询。本文就介绍两种方法

二分查找算法思想

有序的序列，每次都是以序列的中间位置的数来与待查找的关键字进行比较，每次缩小一半的查找范围，直到匹配成功。

一个情景：将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

二分查找图示说明

图片来源百度图片，感谢分享者

二分查找优缺点

优点是比较次数少，查找速度快，平均性能好；

其缺点是要求待查表为有序表，且插入删除困难。

因此，折半查找方法适用于不经常变动而查找频繁的有序列表。

使用条件：查找序列是顺序结构，有序。

java代码实现

使用递归实现

[java]  view plain  copy

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){  
9.       
10.     if(key < arr[low] || key > arr[high] || low > high){  
11.         return -1;                
12.     }  
13.       
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.     }     
24.       
25. }  

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

[java]  view plain  copy

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  
12.       
13.     if(key < arr[low] || key > arr[high] || low > high){  
14.         return -1;                
15.     }  
16.       
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.     }  
29.       
30.     return -1;      //最后仍然没有找到，则返回-1  
31. }  

测试

测试代码：

[java]  view plain  copy

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

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

[java]  view plain  copy

1. 查找的是0,序列中没有该数！  
2.   
3. 查找的是9,找到位置为：4  
4.   
5. 查找的是10,序列中没有该数！  
6.   
7. 查找的是15,序列中没有该数！  

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

[java]  view plain  copy

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

时间复杂度

采用的是分治策略

最坏的情况下两种方式时间复杂度一样：O(log2 N)

最好情况下为O（1）

空间复杂度

  算法的空间复杂度并不是计算实际占用的空间，而是计算整个算法的辅助空间单元的个数

非递归方式：
  由于辅助空间是常数级别的所以：
  空间复杂度是O(1);

递归方式：

 递归的次数和深度都是log2 N,每次所需要的辅助空间都是常数级别的：
 空间复杂度：O(log2N )