二分查找案例

/**
 * 二分查找
 * 1，二分查找的数组前提是有序的
 */
public class BinarySearch {
    public static void main(String[] args) {
        int array[] = {1, 8, 10, 89, 1000, 1000, 1000, 1234};
        int i = binarySearch(array, 0, array.length, 0);
        System.out.println(i);//查找到元素即返回下标
        //查找到所有的元素，返回下标
        ArrayList<Integer> arrayList = binarySearch1(array, 0, array.length, 1000);
        System.out.println(arrayList);
    }

    /**
     * 二分查找的实现
     *
     * @param array     数组
     * @param left      左边索引
     * @param right     右边索引
     * @param findValue 需要查找的值
     * @return 如果找到，返回下标，如果没有找到，返回-1
     */
    public static int binarySearch(int array[], int left, int right, int findValue) {
        int middle = (left + right) / 2;
        int midValue = array[middle];
        //退出递归的条件
        if (left > right) {
            return -1;
        }
        if (findValue > midValue) {
            return binarySearch(array, middle + 1, right, findValue);
        } else if (findValue < midValue) {
            return binarySearch(array, left, middle - 1, findValue);
        } else {
            return middle;
        }
    }

    /**
     * {1,8, 10, 89, 1000, 1000，1234} 当一个有序数组中，有多个相同的数值时，如何将所有的数值都查找到，比如这里的 1000.
     * 思路分析
     * 1，在找到mid索引值，不要马上返回
     * 2，向mid索引值的左边扫描，将等于1000的元素的下标加入到一个集合中
     * 3，向mid索引值的右边扫描，将等于1000的元素的下标加入到一个集合中
     * 4，将得到的集合返回
     *
     * @param array
     * @param left
     * @param right
     * @param findValue
     * @return
     */
    public static ArrayList<Integer> binarySearch1(int array[], int left, int right, int findValue) {
        int middle = (left + right) / 2;
        int midValue = array[middle];
        //退出递归的条件
        if (left > right) {
            return new ArrayList<>();
        }
        if (findValue > midValue) {
            return binarySearch1(array, middle + 1, right, findValue);
        } else if (findValue < midValue) {
            return binarySearch1(array, left, middle - 1, findValue);
        } else {
            ArrayList<Integer> indexList = new ArrayList<>();
            //向mid索引值的左边扫描，将等于1000的元素的下标加入到一个集合中
            int temp = middle - 1;
            while (true) {
                if (temp < 0 || array[temp] != findValue) {
                    break;
                }
                indexList.add(temp);
                temp -= 1;
            }
            indexList.add(middle);
            //向mid索引值的右边扫描，将等于1000的元素的下标加入到一个集合中
            temp = middle + 1;
            while (true) {
                if (temp > array.length - 1 || array[temp] != findValue) {
                    break;
                }
                indexList.add(temp);
                temp += 1;
            }
            return indexList;
        }
    }
}