算法之二分查找

1.二分查找思路

• 二分查找算法的前提：数组必须是有序数组
• 二分查找算法思路分析（递归版）：
  • 定义两个辅助指针：left、right ，待查找的元素在 arr[left]~arr[right] 之间
  • left 初始值为 0 ，right 初始值为 arr.length - 1
  • 将数组分成两半：int mid = (left + right) / 2; ，取数组中间值与目标值 findVal 比较
    • 如果 mid > findVal ，说明待查找的值在数组左半部分
    • 如果 mid < findVal ，说明待查找的值在数组右半部分
    • 如果 mid == findVal ，查找到目标值，返回即可
  • 何时终止递归？分为两种情况：
    • 找到目标值，直接返回目标值 findVal ，结束递归即可
    • 未找到目标值：left > right，这样想：如果递归至数组中只有一个数时（left == right），还没有找到目标值，继续执行下一次递归时， left 指针和 right 指针总有一个会再走一步，这时 left 和 right 便会错开，此时 left > right ，返回 -1 并结束递归表示没有找到目标值

2.代码实现

   1）二分查找（单个值）

• 编写二分查找算法：查找到目标值就返回

  //注意：使用二分查找的前提是 该数组是有序的.
  public class BinarySearch {
  
  	public static void main(String[] args) {
          
  		int arr[] = { 1, 8, 10, 89, 1000, 1234 };
  		int resIndex = binarySearch(arr, 0, arr.length - 1, 1000);
  		System.out.println("resIndex=" + resIndex);
  
  	}
  
  	// 二分查找算法
  	/**
  	 * 
  	 * @param arr     数组
  	 * @param left    左边的索引
  	 * @param right   右边的索引
  	 * @param findVal 要查找的值
  	 * @return 如果找到就返回下标，如果没有找到，就返回 -1
  	 */
  	public static int binarySearch(int[] arr, int left, int right, int findVal) {
  
  		// 当 left > right 时，说明递归整个数组，但是没有找到
  		if (left > right) {
  			return -1;
  		}
  		int mid = (left + right) / 2;
  		int midVal = arr[mid];
  
  		if (findVal > midVal) { // 向 右递归
  			return binarySearch(arr, mid + 1, right, findVal);
  		} else if (findVal < midVal) { // 向左递归
  			return binarySearch(arr, left, mid - 1, findVal);
  		} else {
  
  			return mid;
  		}
  
  	}
      
  }
  

   

• 程序运行结果

  resIndex=4
  

   

   2）二分查找（所有值）

• 编写二分查找算法：查找到所有目标值，在找到目标值之后，分别往左、往右进行扩散搜索

  //注意：使用二分查找的前提是 该数组是有序的.
  public class BinarySearch {
  
  	public static void main(String[] args) {
  		
  		int arr[] = { 1, 8, 10, 89, 1000, 1000, 1000, 1234 };
  		List<Integer> resIndexList = binarySearch(arr, 0, arr.length - 1, 1000);
  		System.out.println("resIndexList=" + resIndexList);
  		
  	}
  
  
  	// 完成一个课后思考题:
  	/*
  	 * 课后思考题： {1,8, 10, 89, 1000, 1000，1234} 当一个有序数组中， 有多个相同的数值时，如何将所有的数值都查找到，比如这里的
  	 * 1000
  	 * 
  	 * 思路分析 1. 在找到mid 索引值，不要马上返回 2. 向mid 索引值的左边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList
  	 * 3. 向mid 索引值的右边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList 4. 将Arraylist返回
  	 */
  
  	public static List<Integer> binarySearch(int[] arr, int left, int right, int findVal) {
  		
  		// 当 left > right 时，说明递归整个数组，但是没有找到
  		if (left > right) {
  			return new ArrayList<Integer>();
  		}
  		int mid = (left + right) / 2;
  		int midVal = arr[mid];
  
  		if (findVal > midVal) { // 向 右递归
  			return binarySearch(arr, mid + 1, right, findVal);
  		} else if (findVal < midVal) { // 向左递归
  			return binarySearch(arr, left, mid - 1, findVal);
  		} else {
  			// 思路分析
  			// 1. 在找到mid 索引值，不要马上返回
  			// 2. 向mid 索引值的左边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList
  			// 3. 向mid 索引值的右边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList
  			// 4. 将Arraylist返回
  
  			List<Integer> resIndexlist = new ArrayList<Integer>();
  			// 向mid 索引值的左边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList
  			int temp = mid - 1;
  			while (true) {
  				if (temp < 0 || arr[temp] != findVal) {// 退出
  					break;
  				}
  				// 否则，就temp 放入到 resIndexlist
  				resIndexlist.add(temp);
  				temp -= 1; // temp左移
  			}
  			resIndexlist.add(mid); //
  
  			// 向mid 索引值的右边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList
  			temp = mid + 1;
  			while (true) {
  				if (temp > arr.length - 1 || arr[temp] != findVal) {// 退出
  					break;
  				}
  				// 否则，就temp 放入到 resIndexlist
  				resIndexlist.add(temp);
  				temp += 1; // temp右移
  			}
  
  			return resIndexlist;
  		}
  
  	}
  }
  

   

• 程序运行结果

  ​​​​​​​resIndexList=[4, 5, 6]