LeetCode 34 在排序数组中查找元素的第一个和最后一个位置 附java代码

题目要求如下：

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

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

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

 

自己想的解法，循环遍历数组，设置一个flag，当第一次找到target的时候，flag设为false。然后继续遍历数组，有等于target

就放入到第二个数组元素中。但是这个的时间复杂度是O（n） 级别 ，虽然能过，但是很明显不符合题目要求。

 

    public int[] searchRange(int[] nums, int target) {

        int[] result = new int[2];
        result[0] = -1;
        result[1] = -1;
        boolean flag = true;
        for (int i = 0 ; i < nums.length ; i++) {
            if (flag && target == nums[i]) {
               flag = false;
                result[0] = i;
            }
            if (!flag&& target == nums[i]) {
                result[1] = i;
            }
        }
        return result;
    }

 

O（log n）级别，并且是有序数组，其实很容易想到二分查找算法。但是二分查找算法是优先查找中位数的。

一般的二分查找如下：

 

 public static int searchNumber(int[] nums, int target) {
        int left = 0;
        int 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 if (nums[mid] < target) {
                left = mid + 1;
            }
        }
        return -1;
    }

诸如 [1,2,2,2,3] 这样的数组，它会优先返回2。我们需要改造上面的算法让其返回最左匹配和最右匹配的数组索引。

代码如下：

public static int searchLeftNumber(int[] nums, int target) {
        if (nums == null || nums.length == 0) {
            return -1;
        }
        int left = 0;
        int right = nums.length - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] == target) {
                right =  mid -1 ;
            } else if (nums[mid] > target) {
                right = mid - 1;
            } else if (nums[mid] < target) {
                left = mid + 1;
            }
        }
        if (left>=nums.length || nums[left] !=target) {
            return -1;
        }
        return left;
    }

 public static int searchRightNumber(int[] nums, int target) {
        if (nums == null || nums.length == 0) {
            return -1;
        }
        int left = 0;
        int right = nums.length - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] == target) {
                left =  mid + 1 ;
            } else if (nums[mid] > target) {
                right = mid - 1;
            } else if (nums[mid] < target) {
                left = mid + 1;
            }
        }
        if (right <0 || nums[right] != target) {
            return -1;
        }
        return right;
    }