Java二分查找（12）

二分查找

1、概念

对于区间[a，b]上连续不断且f(a)⋅f(b)<0的函数y=f(x)，通过不断地把函数f(x)的零点所在的区间一分为二，使区间的两个端点逐步逼近零点，进而得到零点近似值的方法叫二分法。

2、思路分析

• 1. 首先确定该数组的中间的下标mis=(left+right)/2
• 2. 然后让需要查找的数findVal和arr[mid]比较
     • 2.1 findVal>arr[mid]，则查找的数在mid右边，需要递归向右查找（right不变，left = mid + 1）
     • 2.2 findVal<arr[mid]，则查找的数在mid的左边，需要递归的向左查找（left不变，right = mid - 1）
     • 2.3 如果findVal=arr[mid]，说明找到，就返回。

3、核心思想

1. 先找到数组中中间的元素，如果要查找的元素比中间元素小，则排除中间元素右侧的所有元素，如果比中间元素大，则排除左侧所有元素。
2. 然后递归再对剩下的元素进行二分查找。

4、时间复杂度O(log(n)),空间复杂度O(1))

需求：现在有数组{1,3,5,9,8,10}，要求找出8元素，如果找到了，就提示找到，并给出下标值。

public class BinarySearch2 {
    public static void main(String[] args) {
        int[] arr = {1,3,5,9,8,10};
        Arrays.sort(arr);
        //int index = binarySearch1(arr, 9);
        int index = binarySearch2(arr, 0, arr.length - 1, 8);
        System.out.println(index);
    }
  //递归方式
    public static int binarySearch2(int[] arr, int left, int right, int findVal){
        //如果低位下标大于高位下标，结束
        if (left > right){
            return -1;
        }
        int mid = (left + right) / 2;
        if (findVal < arr[mid]){//向左递归
            return binarySearch2(arr,left,mid - 1,findVal);
        } else if (findVal > arr[mid]){//向右递归
            return binarySearch2(arr,mid + 1,right,findVal);
        }
        //当findVal = midVal
        return mid;
    }

    public static int binarySearch1(int[] arr, int findVal){
        int low = 0;
        int high = arr.length - 1;
        while (low <= high){
            int mid = (low + high)/2;
            if (findVal == arr[mid]){
                return mid;
            } else if (findVal < arr[mid]){//则查找的在左边，需要向左递归
                high = mid - 1;
            } else if (findVal > arr[mid]){
                low = mid + 1;
            }
        }
        return -1;
    }
}

某一天需求变化了：现有数组{1,3,5,9,8,9,10}，有多个相同的数值了，如何将所有的数值 都查找到

思路：首先找到mid值不要马上返回，而是向mid索引的左右扫面，将满足的条件的元素放入ArraList集合。

public class BinarySearch {
    public static void main(String[] args) {
        int arr[] = {1,8,9,11,98,98,98,98,98,1000};
        List<Integer> search = binarySearch(arr, 0, arr.length - 1, 98);
        System.out.println("search=" + search);
    }
    public static List<Integer> binarySearch(int[] arr,int left,int right,int findVal) {
        if (left > right) {
            return new ArrayList<Integer>();
        }
        int mid = (right + left) / 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 {
            List<Integer> list = new ArrayList<Integer>();
            int temp = mid - 1;//mid - 1是指中间值索引向左边的第一个，然后接下while循环扫面所有
            while (true) {
                if (temp < 0 || arr[temp] != findVal) {
                    break;
                }else {
                    //向mid索引左边扫面，将所有满足条件的放入集合ArrayList
                    list.add(temp);//用到自动装箱功能
                    temp -= 1;//temp向左移
                }
            }
            list.add(mid);
            //向mid索引右边扫面，将所有满足条件的放入集合ArrayList
            temp = mid + 1;
            while (true) {
                if (temp > arr.length - 1 || arr[temp] != findVal) {
                    break;
                }else {
                    //向mid索引左边扫面，将所有满足条件的放入集合ArrayList
                    list.add(temp);//用到自动装箱功能
                    temp += 1;//temp向右移
                }
            }
            return list;
        }
    }

二分查找总结：

• 使用二分查找的前提是该数组是有序的

• 优点：是比较次数少，查找速度快，平均性能好。

• 缺点：是要求待查表为有序表，且插入删除困难。