查找算法——二分查找算法（递归方式）

基本思想：此处我们采用递归的方式进行二分查找。二分查找的前提是待查找的序列是有序的，若数组无序，需要先进行排序。

二分查找的基本思路：首先确定数组序列的中间下标，然后让待查找的数与中间元素进行比较，若待查找的数大于中间值，说明其在中间值的右边，因此递归的向右进行查找，若待查找的数小于中间值，说明其在中间值的左边，因此递归的向左进行查找，若待查找的值恰好等于中间值，则说明就找到了。

上述方式采用递归实现，因此需要给出递归结束的条件：

1.找到，则结束

2.递归完整个数组，也没有找到，说明不存在，需要返回，条件：left>right，即左索引大于右索引。

根据上述思路，给出代码实现：

    public static void main(String[] args) {
        int[] arr = {1, 8, 10, 89, 1000, 1234};
        int resIndex = binarySearch(arr, 0, arr.length -1, 589);
        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;
        }
    }

改进，考虑一个数组里有多个相同的值，可以利用集合对所有符合的索引值进行保存，返回对应集合即可。

    public static void main(String[] args) {
        int[] arr = {1, 8, 10, 89, 1000,1000, 1000,1234};

        //测试 方法2
        List<Integer> resIndexList = binarySearch2(arr, 0, arr.length - 1, 1000);
        System.out.println("resIndexList = " + resIndexList);
    }
    //改进，查找到所有符合的结果，如找1000，数组中有2个1000
    //1.在找到mid值时，不要马上返回
    //2.向mid索引值的左边扫描，将所有满足1000的元素的下标加入到集合ArrayList
    //3.向mid索引值的右边扫描，将所有满足1000的元素的下标加入到集合ArrayList
    //4.将ArrayList返回
    public static ArrayList<Integer> binarySearch2(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 binarySearch2(arr, mid + 1, right, findVal);//递归
        } else if (findVal < midVal) {//向左递归
            return binarySearch2(arr, left, mid - 1, findVal);

        } else {
            //1.在找到mid值时，不要马上返回
            //2.向mid索引值的左边扫描，将所有满足1000的元素的下标加入到集合ArrayList
            //3.向mid索引值的右边扫描，将所有满足1000的元素的下标加入到集合ArrayList
            //4.将ArrayList返回
            ArrayList<Integer> resIndexList = new 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);//放中间
            //向右边扫描
            temp = mid + 1;
            while (true) {
                if(temp > arr.length - 1 || arr[temp] != findVal) {
                    break;
                }
                //否则把temp加进去
                resIndexList.add(temp);
                temp += 1;//右移
            }
             return resIndexList;

        }
    }