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

题目

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

如果数组中不存在目标值 target，返回 [-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]

示例 3：

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

思路一：

采用两次二分查找策略，第一次查找目标值首次出现的位置，第二次查找目标值最后一次出现的位置。

1. 初始化：
   • 设定左右边界left和right，分别指向数组的首尾。
   • 把first和last初始化为 -1，用于存储目标值首次和最后一次出现的位置。
2. 查找首次出现的位置：
   • 当left小于等于right时，持续进行二分查找。
   • 算出中间位置middle。
   • 若nums[middle]等于目标值，将first更新为middle，并把右边界right更新为middle - 1，继续向左查找，以找到首次出现的位置。
   • 若nums[middle]大于目标值，将右边界right更新为middle - 1。
   • 若nums[middle]小于目标值，将左边界left更新为middle + 1。
3. 查找最后一次出现的位置：
   • 重置左右边界left和right。
   • 当left小于等于right时，继续二分查找。
   • 计算中间位置middle。
   • 若nums[middle]等于目标值，将last更新为middle，并把左边界left更新为middle + 1，继续向右查找，以找到最后一次出现的位置。
   • 若nums[middle]大于目标值，将右边界right更新为middle - 1。
   • 若nums[middle]小于目标值，将左边界left更新为middle + 1。
4. 返回结果：返回包含first和last的数组。

class Solution {public int[] searchRange(int[] nums, int target) {int left = 0;// 初始化变量 left 为 0，它表示当前搜索范围的左边界。int right = nums.length - 1;// 初始化变量 right 为数组 nums 的最后一个元素的索引，它表示当前搜索范围的右边界。int first = -1;// 初始化变量 first 为 -1，用于存储目标值 target 第一次出现的索引。如果未找到 target，则保持为 -1。int last = -1;// 初始化变量 last 为 -1，用于存储目标值 target 最后一次出现的索引。如果未找到 target，则保持为 -1。while (left <= right) {// 开始第一个二分查找循环，目的是找到目标值 target 第一次出现的位置。// 只要左边界小于等于右边界，就继续循环。int m = (left + right) / 2;// 计算当前搜索范围的中间位置 m。if (nums[m] == target) {// 如果中间位置的元素等于目标值 target。first = m;// 更新 first 为当前中间位置 m，因为找到了一个目标值。right = m - 1;// 缩小搜索范围到左半部分，继续向左查找，以找到 target 第一次出现的位置。} else if (nums[m] > target) {// 如果中间位置的元素大于目标值 target。right = m - 1;// 缩小搜索范围到左半部分，因为目标值只可能在左半部分。} else {// 如果中间位置的元素小于目标值 target。left = m + 1;// 缩小搜索范围到右半部分，因为目标值只可能在右半部分。}}left = 0;// 重置左边界为 0，准备进行第二次二分查找。right = nums.length - 1;// 重置右边界为数组 nums 的最后一个元素的索引，准备进行第二次二分查找。while (left <= right) {// 开始第二个二分查找循环，目的是找到目标值 target 最后一次出现的位置。// 只要左边界小于等于右边界，就继续循环。int m = (left + right) / 2;// 计算当前搜索范围的中间位置 m。if (nums[m] == target) {// 如果中间位置的元素等于目标值 target。last = m;// 更新 last 为当前中间位置 m，因为找到了一个目标值。left = m + 1;// 缩小搜索范围到右半部分，继续向右查找，以找到 target 最后一次出现的位置。} else if (nums[m] > target) {// 如果中间位置的元素大于目标值 target。right = m - 1;// 缩小搜索范围到左半部分，因为目标值只可能在左半部分。} else {// 如果中间位置的元素小于目标值 target。left = m + 1;// 缩小搜索范围到右半部分，因为目标值只可能在右半部分。}}return new int[]{first, last};// 返回一个包含 first 和 last 的整数数组，即目标值 target 第一次和最后一次出现的索引。}
}

 思路二：

此代码通过二分查找在有序数组中找出目标值首次和最后一次出现的位置。整体分为主方法和两个辅助方法，主方法先做边界检查，再调用辅助方法分别查找首尾位置。

1. 主方法 searchRange

   • 若数组长度为 0，直接返回 [-1, -1]。
   • 调用 findFirstPosition 找目标值首次出现位置，若未找到（返回 -1），则直接返回 [-1, -1]。
   • 调用 findLastPosition 找目标值最后一次出现位置。
   • 返回包含首次和最后出现位置的数组。

2. 辅助方法 findFirstPosition

   • 初始化左右边界 left 和 right 分别指向数组首尾。
   • 当 left <= right 时进行二分查找：
     • 计算中间位置 m。
     • 若 nums[m] < target，更新 left = m + 1。
     • 若 nums[m] == target，更新 right = m，继续向左查找。
     • 若 nums[m] > target，更新 right = m - 1。
   • 循环结束后，若 nums[left] == target，返回 left，否则返回 -1。

3. 辅助方法 findLastPosition

   • 初始化左右边界 left 和 right 分别指向数组首尾。
   • 当 left <= right 时进行二分查找：
     • 计算中间位置 m，此处中间值向上取整。
     • 若 nums[m] < target，更新 left = m + 1。
     • 若 nums[m] == target，更新 left = m，继续向右查找。
     • 若 nums[m] > target，更新 right = m - 1。
   • 循环结束后，返回 left。

class Solution {public int[] searchRange(int[] nums, int target) {int len = nums.length;if(len == 0){return new int[]{-1,-1};}int firstPosition = findFirstPosition(nums,target);if(firstPosition ==-1){return new int[]{-1,-1};}int lastPosition = findLastPosition(nums,target);return new int[]{firstPosition,lastPosition};}private int findFirstPosition(int[] nums,int target){int left = 0;int right = nums.length-1;while(left <= right){int m = (left +right) >>>1;if(nums[m] < target){//下一轮搜索区间是：[m+1,right]left = m+1;}else if(nums[m] == target){//下一轮搜索区间是：[left,m]right = m;}else{//下一轮搜索区间是：[left,m-1]right = m-1;}}if(nums[left] == target){return left;}return -1;}private int findLastPosition(int[] nums,int target){int left = 0;int right = nums.length-1;while(left <= right){//中间值要向上取整int m = (left +right+1) >>>1;if(nums[m] < target){//下一轮搜索区间是：[m+1,right]left = m+1;}else if(nums[m] == target){//下一轮搜索区间是：[m，right]left = m;}else{//下一轮搜索区间是：[left,m-1]right = m-1;}}return left;}
}

思路三：

利用二分查找在有序数组中找到目标值首次和最后一次出现的位置。通过定义一个带布尔参数的二分查找函数，根据参数不同分别查找第一个大于等于目标值的位置和第一个大于目标值的位置，进而确定目标值的出现范围。

1. 主方法 searchRange

   • 调用 binarySearch 并传入 true，得到目标值首次出现的位置 leftIdx。
   • 调用 binarySearch 并传入 false，得到目标值最后一次出现位置的下一个位置，减 1 后得到 rightIdx。
   • 检查 leftIdx 和 rightIdx 是否合理（leftIdx 小于等于 rightIdx，rightIdx 在数组范围内，且对应值为目标值），若合理则返回 [leftIdx, rightIdx]，否则返回 [-1, -1]。

2. 辅助方法 binarySearch

   • 初始化左右边界 left 和 right 以及结果变量 ans 为数组长度。
   • 当 left 小于等于 right 时进行二分查找：
     • 计算中间位置 mid。
     • 若 nums[mid] 大于目标值，或 lower 为 true 且 nums[mid] 大于等于目标值，更新右边界 right = mid - 1，并将 ans 更新为 mid。
     • 否则，更新左边界 left = mid + 1。
   • 循环结束后返回 ans。

class Solution {public int[] searchRange(int[] nums, int target) {int leftIdx = binarySearch(nums, target, true);// 调用 binarySearch 方法来查找目标值首次出现的位置// 传入 true 表示要找首次出现的位置int rightIdx = binarySearch(nums, target, false) - 1;// 调用 binarySearch 方法来查找目标值最后一次出现位置的下一个位置// 传入 false 表示要找最后一次出现位置的下一个位置// 最后减去 1 得到最后一次出现的位置if (leftIdx <= rightIdx && rightIdx < nums.length && nums[leftIdx] == target && nums[rightIdx] == target) {// 检查得到的首次和最后一次出现的位置是否合理// 条件包括：首次位置小于等于最后位置，最后位置在数组范围内，且这两个位置对应的值都是目标值return new int[]{leftIdx, rightIdx};// 如果条件满足，返回包含首次和最后一次出现位置的数组} return new int[]{-1, -1};// 如果条件不满足，说明目标值不在数组中，返回 [-1, -1]}public int binarySearch(int[] nums, int target, boolean lower) {int left = 0, right = nums.length - 1, ans = nums.length;// 初始化 ans 为数组长度，它会记录最终结果while (left <= right) { int mid = (left + right) / 2;if (nums[mid] > target || (lower && nums[mid] >= target)) {// 如果中间位置的值大于目标值，或者 lower 为 true 且中间位置的值大于等于目标值right = mid - 1;// 缩小右边界到 mid - 1，继续在左半部分查找ans = mid;// 更新 ans 为 mid，因为可能找到了更合适的位置} else {left = mid + 1;// 否则，说明目标值在右半部分，将左边界更新为 mid + 1}}return ans;// 循环结束后，返回记录的结果 ans}
}