leetcode_34_在排序数组中查找元素的第一个和最后一个位置_leetcode_287_第一个错误的版本

总结

• 知识点

  • 二分法的变形，得到元素后并不会马上返回，而是进一步判断是否是要找的元素。
  • while里的边界，left ,right 的赋值。

• 在排序数组中查找元素，二分法。

  • 查找第一个，最后一个，查找到后，不会立即返回，而是继续二分查找第一个元素，最后一个元素。

• 查找第一个错误版本，也是，相当于true,false排序，

  • 为true，则二分向后，为false，则继续判断是不是到了临界点，即现在这个位置的元素不等于前面位置的元素。

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

给定一个按照升序排列的整数数组 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]

自己的错误代码

• 错误
  • while if else 的每一种情况都要移动指针，不然会卡死

class Solution {
    public int[] searchRange(int[] nums, int target) {
        // 有序数组，查找值，二分法
        // 确定左边index,  
        // 确定右边index,

        if(nums == null || nums.length == 0) return new int[]{-1, -1};

        int left = 0, right = nums.length - 1;


        int minIndex = nums.length;
        int maxIndex = 0;

        // 前提，二分法能找到所有的值
        while(left < right) {
            int mid = (left + right) / 2;
            if(nums[mid] < target) {
                left = mid + 1;
            }else if(nums[mid] > target) {
                right = mid - 1;
            }else {
                minIndex = Math.min(minIndex, mid);
                maxIndex = Math.max(maxIndex, mid);
                
            }
        }

        int[] res; 

        if(minIndex != nums.length && maxIndex != 0) {
            res = new int[]{minIndex, maxIndex};
        }
        else if(minIndex == nums.length && maxIndex == 0){
            res = new int[]{-1, -1};
        }
        else if(minIndex == nums.length) {
            res = new int[]{maxIndex};
        }
        else if(maxIndex == 0) {
            res = new int[]{minIndex};
        }
        else{
            res = new int[]{minIndex, maxIndex};
        }

        return res;
    }
}

思路

• 没想到的点：

  • 找到nums[mid] = target后，不是return，而是还可以继续用二分法查找最左边的target，或最右边的target。
  • 很巧妙，想不到：
  • 用boolean isFindFirst 来找第一个target。
  • 继续二分的条件是：mid不是数组最左边的数(如果target=nums[mid]是数组最左边的数，那target肯定就是数组的第一个target), && nums[mid] == nums[mid-1] , 说明target = nums[mid]还不是第一个target, 因为左边还有和他相等的呀。
    • && 也很容易出错，但反过来想，只要mid == 0 或 nums[mid] != nums[mid - 1]，那么nums[mid]肯定就是第一个target。
    • 转换成代码 if(mid > 0 && nums[mid] == nums[mid-1]) { right = mid - 1};
    • else {return mid}
  • 最后如果整个区间找遍了，都没找到target，那么就返回-1

• 二分法注意点：

  • while(left < right) 还是 while(left <= right)

    • 取决于最开始的是[left, right) 还是 [left, right]
    • [left, right) ：当left == right时，就跳出循环：例如 2 = 2 ， 此时[2, 2) 区间是空的，没有元素。
    • [left, right] : 当left > right时，就跳出循环：例如 3 > 2 , 此时[3, 2] 区间是空的，没有元素满足这个区间。

  • right = mid 还是right = mid - 1

    • 取决于最开始的是[left, right) 还是 [left, right], 区间是开还是闭合
    • [left, right) ：[left , mid), 不包含 mid ; [mid + 1, right) 不包含 mid
    • [left, right] : [left , mid - 1], 不包含 mid ; [mid + 1 , right] 不包含 mid
      
      
      
      

class Solution {
    public int[] searchRange(int[] nums, int target) {
        // 二分法找到target后，
        // 再继续向左找target，当nums[i-1] != nums[i],nums[i]就是第一个target
        // 继续向找target，当nums[i+1] != nums[i]，nums[i]就是最后一个target

        int[] res = new int[2];

        res[0] = find(true, nums, 0, nums.length -1, target);
        res[1] = find(false, nums, 0, nums.length -1, target);
    
        return res;
    }

    public int find(boolean findFirst, int[] nums, int left, int right, int target) {
        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(findFirst) {
                    if(mid > 0 && nums[mid] == nums[mid-1]) {
                        right = mid - 1;
                    }else {
                        return mid;
                    }
                }else {
                    if(mid < nums.length - 1 && nums[mid] == nums[mid+1]) {
                        left = mid + 1;
                    }else {
                        return mid;
                    }
                }
            } 
        }
        return -1;
    }
}

题目：278. 第一个错误的版本

你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。

假设你有 n 个版本 [1, 2, …, n]，你想找出导致之后所有版本出错的第一个错误的版本。

你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。

示例:

给定 n = 5，并且 version = 4 是第一个错误的版本。

调用 isBadVersion(3) -> false
调用 isBadVersion(5) -> true
调用 isBadVersion(4) -> true

所以，4 是第一个错误的版本。

思路

• 和上一道题一样，就是找到第一个target, 只不过这个的数组只有两种值 true 或 false

• 二分，如果mid是正确版本，则错误版本在后面，left = mid + 1, 继续向后找

• 如果mid是错误版本，且它的前一个是正确版本，则mid就是第一个错误版本

• 如果mid是错误版本，且它的前一个也是错误版本，right = mid - 1, 继续向前找

• 出错

  • isBadVersion(3) 返回false ，说明是合格产品，所以判断是合格产品if(!isBadVersion(mid))，前面要加上！
  • 每一种情况要么向前，向后，要么返回，要不然会卡死

注意：

• 这里没有判断mid > 0 的情况时默认一定会有正品。即mid一定不会出现在第一个位置

public class Solution extends VersionControl {
    public int firstBadVersion(int n) {
        // 如果是好的，则错的肯定在后面
        // 如果是错的，还要分析是不是第一个错的，
        // 如果不是，继续用二分法找到第一个错的

        int left = 1, right = n;

        
        while(left <= right) {
            int mid = left + (right - left) / 2;
            if(!isBadVersion(mid)) {
                left = mid + 1;
            }else if(isBadVersion(mid)){
                if(isBadVersion(mid) == isBadVersion(mid - 1)) {
                    right = mid - 1;
                }else {
                    return mid;
                }
            }
        }
        return -1;
    }
}