二分查找算法

1.思路分析

1. 首先确定该数组的中间的下标: mid = (left + right) / 2
2. 然后让需要查找的数 findVal 和 arr[mid] 比较
   2.1 findVal > arr[mid] , 说明你要查找的数在mid 的右边, 因此需要递归的向右查找
   2.2 findVal < arr[mid], 说明你要查找的数在mid 的左边, 因此需要递归的向左查找
   2.3 findVal == arr[mid] 说明找到，就返回
3. 什么时候我们需要结束递归?
   3.1 找到就结束递归
   3.2 递归完整个数组，仍然没有找到findVal ，也需要结束递归 当 left > right 就需要退出

import java.util.ArrayList;
import java.util.List;

public class BinarySearch {

    //注意：使用二分查找的前提是该数组是有序的
    public static void main(String[] args) {
        int arr[] = { 1, 8, 10, 89,1000,1000, 1234 };
//        int resIndex = binarySearch(arr, 0, arr.length - 1, 8);
        List<Integer> list = binarySearch2(arr, 0, arr.length - 1, 1000);
        System.out.println("list = " + list);
    }

    /**
     * 二分查找算法(不能查找出相同的元素)
     * @param arr 原始数组
     * @param left 左边的索引
     * @param right 右边的索引
     * @param value 需要查找的值
     * @return
     */
    public static int binarySearch(int arr[], int left, int right, int value){
        //如果左边的索引 > 右边的索引，则表示不存在该值，直接退出
        if(left > right){
            return -1;
        }

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

        if(midValue < value){ //如果midValue < value则继续向右递归查找
            return binarySearch(arr, mid + 1, right, value);
        }else if(midValue > value){ //如果midValue > value则继续向左递归查找
            return binarySearch(arr, left, mid - 1, value);
        }else { //找到了 直接返回下表
            return mid;
        }
    }

    /** 1,8, 10, 89, 1000, 1000，1234} 当一个有序数组中，多个相同的数值时，如何将所有的数值都查找到，比如这里的 1000
     * @param arr
     * @param left
     * @param right
     * @param value
     * @return
     */
    public static List<Integer> binarySearch2(int arr[], int left, int right, int value){
        //如果左边的索引 > 右边的索引，则表示不存在该值，直接退出
        if(left > right){
            return new ArrayList<Integer>();
        }

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

        if(midValue < value){ //如果midValue < value则继续向右递归查找
            return binarySearch2(arr, mid + 1, right, value);
        }else if(midValue > value){ //如果midValue > value则继续向左递归查找
            return binarySearch2(arr, left, mid - 1, value);
        }else {
            /**
             * 思路分析：
             * 1.在找到mid的索引值，不要马上返回
             * 2.向mid索引值的左边扫描，将所有满足1000的元素的下标加入ArrayList中
             * 3.向mid索引值的右边扫描，将所有满足1000的元素的下标加入ArrayList中
             * 4.将A仍然有List返回
             */
            ArrayList<Integer> resIndexList = new ArrayList<>();
            //向mid索引值的左边扫描，将所有满足条件的加入resIndexList中
            int temp = mid - 1;
            while (true){
                if(temp < 0 || arr[temp] != value){
                    break;
                }
                //否则，将temp加入到resIndexList
                resIndexList.add(temp);
                temp -= 1; //temp左移
            }

            resIndexList.add(mid); //将中的值加入resIndexList

            //向mid索引值的右边扫描，将所有满足条件的加入resIndexList中
            temp = mid + 1;
            while (true){
                if(temp < 0 || arr[temp] != value){
                    break;
                }
                //否则，将temp加入到resIndexList
                resIndexList.add(temp);
                temp += 1; //temp左移
            }

            return resIndexList;
        }
    }
}

• 结果：