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

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

这一题理解起来还是比较简单的，就是找到某个数字在数组中的最开始和最后的位置。

关键思路：两次 二分法。

1. 初步想法

我自己在做的时候，就想得很简单。首先题目要log(n)的时间复杂度，那么很容易想到二分法。所以我的思路是，先用二分法找到target的位置，然后分别向前和向后查找，就可以找到第一和最后的位置。

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int low = 0, high = nums.size() - 1, mid;
        int b = -1, e = -1;
        while (low <= high) {
            mid = (low + high) / 2;
            if(nums[mid] == target) {
                b = e = mid;
                int j = mid - 1, k = mid + 1;
                while ( j >= 0) {
                    if(nums[j] == nums[mid]) {
                        b--;
                    }
                    else{
                        break;
                    }
                    j--;
                }
                while ( k < nums.size()) {
                    if(nums[k] == nums[mid]) {
                        e++;
                    }
                    else {
                        break;
                    }
                    k++;
                }
                break;
            }
            else if (nums[mid] < target) {
                low = mid + 1;
            }
            else if (nums[mid] > target) {
                high = mid - 1;
            }
        }

        return {b, e};

    }
};

这样很容易想到，但是如果重复的元素很多的话，那么效果就不好。因此，需要重新设计。

2. 两次二分法

由于是要找开始和结束的位置，因此可以想到用两个二分法来分别找（一开始我也是没想到），看了解析以后觉得还是蛮简单，遂自己写了一个。

class Solution { 
public:
    int FirstPosition(vector<int>& nums, int target) {      // 用来找最左边的位置
        int left = 0, right = nums.size() - 1, mid;
        while(left <= right) {
            mid = (left + right) / 2;
            if (nums[mid] == target) {        // 跟普通二分查找法的关键区别，在找到之后，继续调整位置，找它左边的，以便找到最左边的
                right = mid - 1;
            }
            else if (nums[mid] < target) {
                left = mid + 1;
            }
            else {
                right = mid - 1;
            }
        }
        // 如果找到了，就返回找到的位置。如果没找到就返回-1
        if (left < nums.size() && nums[left] == target) {  // left有可能越界，所以需要加上lef<nums.size()的约束条件
            return left;
        }
        else {
            return -1;
        }
        
    }

    int LastPosition(vector<int>& nums, int target) {
        int left = 0, right = nums.size() - 1, mid;
        while(left <= right) {
            mid = (left + right) / 2;
            if (nums[mid] == target) {        // 跟普通二分查找法的关键区别，在找到之后，继续调整位置，找它右边的，以便找到最右边的
                left = mid + 1;
            }
            else if (nums[mid] < target) {      
                left = mid + 1;
            }
            else {
                right = mid - 1;
            }
        }

        if (right > -1 && nums[right] == target) {// 同样的，right也有可能越界，所以需要加上约束条件
            return right;
        }
        else {
            return -1;
        }

        return right;
    }


    vector<int> searchRange(vector<int>& nums, int target) {
        if (nums.size() == 0) {     // 特殊情况
            return {-1, -1};
        }
        if (nums.size() == 1) {
            if (nums[0] == target) {        // 特殊情况
                return {0, 0};
            }
            else {
                return {-1, -1};
            }
        }
        // 分别获取最左边和最右边的位置
        int first = FirstPosition(nums, target);
        int last = LastPosition(nums, target);
        return {first, last};
    }
};

想法不难，但是要注意一些边界条件的控制和一些细节。

总结

这题的关键是用两次二分法来分别找起始和结束的位置；其中关键是，每个二分法中，当找到target的时候，不是break，而是相应的调整left和right的位置。