34. 在排序数组中查找元素的第一个和最后一个位置 Java Leetcode 常规解法

题目：

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。

你的算法时间复杂度必须是 O(log n) 级别。

如果数组中不存在目标值，返回 [-1, -1]。

示例 1:

输入: nums = [5,7,7,8,8,10], target = 8
输出: [3,4]
示例 2:

输入: nums = [5,7,7,8,8,10], target = 6
输出: [-1,-1]

思路：

1.采用二分搜索的变形，不断收窄左右边界。

2.注意条件的范围。

3.考虑到target存在以及target不存在的状况。

采用常规左闭右开写法和左闭右闭写法两种方式。

先写二分搜索的常规思路:

查找某个target,

static int binary(int[] nums, int target) {
        if (nums.length == 0) return -1;
        int left = 0;
        int right = nums.length - 1;
        while (left <= right) {
            int pivot = left + (right - left);
            if (target == nums[pivot]){
                return  pivot;
            }else if(target>=pivot){
                left=pivot+1;
            }else if(target<=pivot)
                right=pivot-1;
        }
        return -1;

    }

接着是左闭右开的左边界查找

  static int leftbound(int[] nums, int target) {
        if (nums.length == 0) return -1;
        //采用二分法找左边界
        int left = 0;
        int right = nums.length//注意
        while (left < right) {
            int pivot = (left + right) / 2;
            if (target > nums[pivot]) {
                left = pivot + 1; 
            } else if (target < nums[pivot]) {
                right = pivot;//注意
            } else if (nums[pivot] == target) {
                right = pivot;//注意
            }

        }

这里要注意三点

（1）因为right=nums.length 因此下面的while()里的条件是left<right,也就是[left,right),如果右边闭合的话，索引就越界了。接下来寻找循环终止的时刻。第一种情况就是找到了target,也就是if(target==nums[pivot])。另一种情况就是while(){}结束，（）里的区间为空，显然[left,right)的终止条件是left=right，因为[left,left)为空，就像【2,2）为空。

（2）当(target==nums[pivot])以及(target<nums[pivot])时right=pivot,之所以是right=pivot，是因为查找区间是[left,right)。

（3）不要忽略掉异常情况！taget不在数组里怎么办？？既然是找左边界，那就是从左不断往右移，走到(left==right=nums.length)时，发现还是没有那就返回-1.如果左边界存在等于target那就返回left,若不存在则返回-1.

        // target 比所有数都大
        if (left == nums.length) return -1;
        return nums[left] == target ? left : -1;

 对于右边界，则是target比所有数都小。

        // target 比所有数都小
        if (left == 0) return -1;
        return nums[left-1] == target ? (left-1) : -1;

 下面是全部的代码实现，Leetcode已通过

class Solution {
    public int[] searchRange(int[] nums, int target) {
        return new int[]{leftbound(nums, target), rightbound(nums, target)};
    }

    static int leftbound(int[] nums, int target) {
        if (nums.length == 0) return -1;
        //采用二分法找左边界
        int left = 0;
        int right = nums.length;
        while (left < right) {
            int pivot = (left + right) / 2;
            if (target > nums[pivot]) {
                left = pivot + 1;
            } else if (target < nums[pivot]) {
                right = pivot;
            } else if (nums[pivot] == target) {
                right = pivot;
            }

        }
        // target 比所有数都大
        if (left == nums.length) return -1;
        return nums[left] == target ? left : -1;

    }

    static int rightbound(int[] nums, int target) {
        if (nums.length == 0) return -1;
        int left = 0;
        int right = nums.length;
        while (left < right) {
            int pivot = (left + right) / 2;
            ;
            if (target > nums[pivot]) {
                left = pivot + 1;
            } else if (target < nums[pivot]) {
                right = pivot;
            } else if (target == nums[pivot]) {
                left = pivot + 1;
            }
        }

        // target 比所有数都小
        if (left == 0) return -1;
        return nums[left-1] == target ? (left-1) : -1;
    }
}