二分查找多种情况分析

首先二分查找主要分为三类，分别是：寻找一个数，寻找左侧边界，寻找右侧边界

public class Test {

    public static void main(String[] args) {
        int[] nums = {1, 2, 2, 2, 3};
        System.out.println(binarySearchLeftBound(nums, 3));
    }

    /**
     * 普通的二分查找，搜索边界为[left, right]
     *
     * @param nums
     * @param target
     * @return
     */
    /*public static int binarySearch(int[] nums, int target) {
        //搜索区间为[left,right]
        int left = 0, right = nums.length - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] == target) {
                return mid;
            } else {
                if (nums[mid] > target) {
                    right = mid - 1;
                } else {
                    left = mid + 1;
                }
            }
        }
        return -1;
    }*/
    public static int binarySearch(int[] nums, int target) {
        //搜索区间为[left,right)
        int left = 0, right = nums.length;
        while (left < right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] == target) {
                return mid;
            } else {
                if (nums[mid] > target) {
                    right = mid;
                } else {
                    left = mid + 1;
                }
            }
        }
        return -1;
    }

/*    public static int binarySearchLeftBound(int[] nums, int target) {
        //搜索区间为[left,right]
        int left = 0, right = nums.length - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] >= target) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        //如果left超出边界说明搜索不到，如果left没有超出边界也要和target进行比较
        return left >= nums.length || nums[left] != target ? -1 : left;
    }*/

    public static int binarySearchLeftBound(int[] nums, int target) {
        //搜索区间为[left,right)
        int left = 0, right = nums.length;
        while (left < right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] >= target) {
                right = mid;
            } else {
                left = mid + 1;
            }
        }
        //跳出循环时left = right,，如果等于nums.length就表示没有
        if (left == nums.length) return -1;
        return nums[left] == target ? left : -1;
    }


    /*public static int binarySearchRightBound(int[] nums, int target) {
        //搜索区间为[left,right]
        int left = 0, right = nums.length - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] <= target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        //由于right小于0，需要进行判断
        return right < 0 || nums[right] != target ? -1 : right;
    }*/

    public static int binarySearchRightBound(int[] nums, int target) {
        //搜索区间为[left,right)
        int left = 0, right = nums.length;
        while (left < right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] <= target) {
                left = mid + 1;
            } else {
                right = mid;
            }
        }
        //跳出循环时left = right,由于是右边界判断是否正确时要索引减1
        if (left == 0 && nums[left] != target) return -1;
        return nums[left - 1] == target ? left - 1 : -1;
    }

}