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

34. 在排序数组中查找元素的第一个和最后一个位置

   

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

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

你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

示例 1：

输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]

示例 2：

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

示例 3：

输入：nums = [], target = 0
输出：[-1,-1]

提示：

• 0 <= nums.length <= 105
• -109 <= nums[i] <= 109
• nums 是一个非递减数组
• -109 <= target <= 109

思路：

• 方法1 双指针法：不推荐，时间复杂度较高，没有利用到二分查找特性
• 方法2 二分查找 + 左右滑动指针：不推荐，最坏情况下如果数组中的所有元素都一样，那最坏时间复杂度为O(n)
• 方法3 利用 leftOrRight 标识位 进行两次二分查找，分别确定左边界和右边界：推荐，时间复杂度为O(logn)

时间复杂度：双指针法 O(n)，二分查找O(logn)

空间复杂度：均为O(1)

// 方法1 双指针：不推荐
// 时间复杂度：O(n)
func searchRange(nums []int, target int) []int {
    // if len(nums) == 0 {
    //     return []int{-1, -1}
    // }

    left, right := 0, 0

    // 注意：要避免left和right越界
    for ; left < len(nums) && nums[left] != target; left++ {
    }

    // 如果在nums中没找到target，则直接返回-1
    if left >= len(nums) {
        return []int{-1, -1}
    }

    // 注意：要避免left和right越界
    for right = left; right < len(nums) && nums[right] == target; right++ {
    }

    right-- // 因为最后right多加了一次，所以减回去

    return []int{left, right}
}

// 方法2 二分法 + 左右滑动指针：不推荐
// 思路：如果在nums中找到了一个target，则继续在此基础上，通过左右滑动指针，来找到符合题意的区间
// 平均时间复杂度：O(logn)，最坏情况下如果数组中的所有元素都一样，那最坏时间复杂度为O(n) 
func searchRange(nums []int, target int) []int {
   left, right := 0, len(nums) - 1
   for left <= right {
       mid := left + (right - left) / 2

       if nums[mid] == target {
            // 找到target位置后，分别 向左/向右 寻找左右边界
            pre, end := mid, mid
            for pre >= 0 && nums[pre] == target {
                pre--
            }

            for end < len(nums) && nums[end] == target {
                end++
            }

            return []int{pre + 1, end - 1} // l在循环中多减了一次，要加回来；r在循环中多加了一次，要减回去
       } else if nums[mid] < target {
           left = mid + 1
       } else {
           right = mid - 1
       }
   }

   return []int{-1, -1}
}

// 方法3 二分法：推荐
// 思路：如果在nums中找到了一个target，则继续在此基础上用二分法分别查找左右边界，而不是用左右滑动指针来逐个遍历
func searchRange(nums []int, target int) []int {
    return []int{ binarySearch(nums, target, true), binarySearch(nums, target, false) }
}

// leftOrRight为true找左边界，leftOrRight为false找右边界
func binarySearch(nums []int, target int, leftOrRight bool) int {
    left, right, res := 0, len(nums) - 1, -1

    for left <= right {
        mid := left + (right - left) / 2
        
        if target == nums[mid] {
            res = mid // 保存上一轮循环中target == nums[mid]时，对应的mid值
            // leftOrRight = true，继续寻找target的左边界，所以要缩小当前的右边界，right需要往左移
            if leftOrRight {
                right = mid - 1

            // leftOrRight = false，继续寻找target的右边界，所以要增大当前的右边界，left需要往右移
            } else {
                left = mid + 1
            }
        } else if target > nums[mid] {
            left = mid + 1
        } else { // target < nums[mid]
            right = mid - 1
        }
    }

    return res
}