Java数据结构与算法———（52）二分查找（多个）

在一个有序数组中{1, 8, 10, 89, 1000, 1000, 1000, 1234}有多个相同的数值，用二分查找法将所有的数值都查找到，比如查找1000。

一、代码

import java.util.ArrayList;

/**
 * 二分查找，要求数组必须有序 二分查找，用递归实现
 * 
 * @author Lee
 *
 */
public class BinarySearch {

	public static void main(String[] args) {
		int[] arr = {1, 8, 10, 89, 1000, 1000, 1000, 1234};
		
		//int resIndex = binarySearchPro(arr, 0, arr.length - 1, 1000);
		//System.out.println("resIndex = " + resIndex);
		
		ArrayList<Integer> resIndexList = binarySearchPro(arr, 0, arr.length - 1, 1000);
		System.out.println("resIndexList = " + resIndexList);
	}
	
	
	/**
	 * 在一个有序数组中{1, 8, 10, 89, 1000, 1000, 1234}有多个相同的数值，如何用二分查找法将所有的数值都查找到，比如1000
	 * 
	 * 思路分析
	 * 1. 在上面的 binarySearch 方法中，当找到索引值 mid 时，先不要马上返回
	 * 2. 继续向索引值 mid 左边扫描，将所有等于 1000 的元素下标，加入到集合 ArrayList 中
	 * 3. 继续向索引值 mid 右边扫描，将所有等于 1000 的元素下标，加入到集合 ArrayList 中
	 * 4. 将 ArrayList 返回
	 */
	
	/**
	 * 
	 * @param arr     原数组
	 * @param left    左边的索引
	 * @param right   右边的索引
	 * @param findVal 要查找的值
	 * @return 找到就返回下标，没有找到就返回-1
	 */
	public static ArrayList<Integer> binarySearchPro(int[] arr, int left, int right, int findVal) {
		
		// 当 left > right 时，说明已经递归完整个数组，而且没有找到，返回一个空的ArrayList<Integer>，通过检查其实际元素个数来确定是否找到findVal
		if (left > right) {
			return new ArrayList<Integer>();
		}

		int mid = (left + right) / 2;
		int midVal = arr[mid];

		if (findVal > midVal) {// 向右递归
			return binarySearchPro(arr, mid + 1, right, findVal);
		} else if (findVal < midVal) {// 向左递归
			return binarySearchPro(arr, left, mid - 1, findVal);
		} else {
			// 思路分析
			// 1. 在上面的 binarySearch 方法中，当找到索引值 mid 时，先不要马上返回
			// 2. 继续向索引值 mid 左边扫描，将所有等于 1000 的元素下标，加入到集合 ArrayList 中
			// 3. 继续向索引值 mid 右边扫描，将所有等于 1000 的元素下标，加入到集合 ArrayList 中
			// 4. 将 ArrayList 返回

			ArrayList<Integer> resIndexList = new ArrayList<Integer>();
			
			// 继续向索引值 mid 左边扫描，将所有等于 1000 的元素下标，加入到集合 ArrayList 中
			int temp = mid - 1;
			while (true) {
				// temp < 0 表示下标已经小于了数组的最小下标，已经扫描到了数组外
				// arr[temp] != findVal 表示在 mid 左边出现了一个等于findVal的数，因为原数组arr已经有序，所以既然如果左边出现了一个不等于findVal的值，再往左的数肯定也不等于findVal
				if (temp < 0 || arr[temp] != findVal) {
					break;//退出左边的扫描
				}
				//否则，就将temp放入到 resIndexList 中
				resIndexList.add(temp);
				temp--;//temp左移
			}

			resIndexList.add(mid);//由于mid是中间的下标，所以先扫描完左边再把中间的下标放进去，这样输出就是按从小到大的顺序输出下标
			
			//继续向索引值 mid 右边扫描，将所有等于 1000 的元素下标，加入到集合 ArrayList 中
			temp = mid + 1;
			while(true) {
				// temp > arr.length - 1 表示下标已经大于了数组的最大下标，已经扫描到了数组外
				// arr[temp] != findVal 表示在 mid 右边出现了一个等于findVal的数，因为原数组arr已经有序，所以既然如果右边出现了一个不等于findVal的值，再往右的数肯定也不等于findVal
				if(temp > arr.length - 1 || arr[temp] != findVal) {//退出
					break;
				}
				//否则，就将 temp 放入到 resIndexList 中
				resIndexList.add(temp);
				temp++;//temp右移
			}
			
			//返回
			return resIndexList;
		}
	}
}

二、结果

resIndexList = [4, 5, 6]