第九关|二分查找

1、不重复的二分查找

二分查找将中间结果与目标进行比较，一次去掉一半，是简单的分治。

分治和递归不同，分治可以用递归，而递归不一定是分治。

1、循环方式

int mid = (low + high) /2 可以换成 int mid = left + ((right - left) >> 1)。首先移位运算效率比除高，其次，防止了low+high数据过大溢出，注意移位运算比+低，需要加括号。

    //这种方式可以少写几个参数，在函数里设置low和high但是递归方式不可以在函数里设置low和high的初值
    public static int binarySearch(int[] array, int low, int high, int target){

        while(low <= high) {

            int mid = low + ((high - low) >> 1);

            if (array[mid] == target) {
                return mid;
            } else if (array[mid] > target) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        return -1;
    }

2、递归方式

    public static int binarySearch(int[] array, int low, int high, int target){

        if(low <= high){

            int mid = low + ((high - low) >> 1);

            if(array[mid] == target){
                return mid;
            }else if(array[mid] > target){
                return binarySearch2(array, low, mid - 1, target);
            }else{
                return binarySearch2(array, mid + 1, high, target);
            }

        }
        return -1;
    }

2、重复的二分查找

在上面的基础上，元素存在重复，如果重复则找左侧第一个

1、循环方式

找到相等的首个位置向左线性查找

    public static int search(int[] nums, int target){

        if(nums == null || nums.length == 0){
            return -1;
        }

        if(nums[0] == target){
            return 0;
        }

        int left = 0;
        int right = nums.length - 1;

        while(left <= right){

            int mid = left + ((right - left) >> 1);
            if(nums[mid] > target){
                right = mid - 1;
            }else if(nums[mid] < target){
                left = mid + 1;
            }else{
                //往左找
                while(mid != 0 && nums[mid] == target){
                    mid--;
                }
                return mid + 1;
                //要是没有这个方法初对nums[0]的判断，应该是下面这样
                // while (mid != 0 && nums[mid] == target){mid--;}
                // if (mid == 0 && nums[mid] == target){return mid;}//多一个对nums[0]的判断
                // return mid + 1;
            }

        }
        return -1;
    }

2、递归方式

找到相等的首个位置，将right设为mid继续递归，向左找，找到<target,然后，left执行前一个if变成mid + 1后 == target，就可以返回了

    public static int search(int nums[], int target){
        if(nums == null || nums.length == 0){
            return -1;
        }

        return binSearch2(nums, target, 0, nums.length - 1);
    }

    public static int binSearch(int[] nums, int target, int left, int right) {

        if(left > right) return -1;

        //left所指
        if(nums[left] == target){
            return left;
        }

        int mid = left + ((right - left) >> 1);

        if(nums[mid] > target){
            return binSearch2(nums, target, left, mid - 1);
        }else if(nums[mid] < target){
            return binSearch2(nums, target, mid + 1, right);
        }else{
            //继续向左找，找到<target,然后，left执行前一个if变成mid + 1后 == target，就可以返回了，可以代入例子
            return binSearch2(nums, target, left, mid);
        }

    }