干tm的算法5:在排序数组中查找元素的第一个和最后一个位置

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

老哥的代码:

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int [] result = new int[2];
       
        if(nums.length == 0){
            result[0] = -1;
            result[1] = -1;
            return  result;
        } 
        result[0] = findFirst(nums, nums.length, target);
        result[1] = findLast(nums, nums.length, target);
       return result;
    }
    
    public int findFirst(int [] a, int len, int key)
    {
    if (len < 1)
        return - 1;
    int low = 0;
    int high = len - 1;
    while(low <= high)
    {
        int mid = (low + high)/2;
        if (a[mid] == key && (mid - 1 < 0 || a[mid - 1] != key))
        {
            return mid;
        }
        else if (a[mid] >= key)
        {
            high = mid - 1;
        }
        else
        {
            low = mid + 1;
        }
    }
        return -1;
}
    public int findLast(int [] a, int len, int key)
    {
    if (len < 1)
        return - 1;
    int low = 0;
    int high = len - 1;
    while(low <= high)
    {
        int mid = (low + high)/2;
        if (a[mid] == key && (mid + 1 >= len || a[mid + 1] != key))
        {
            return mid;
        }
        else if (a[mid] <= key)
        {
            low = mid + 1;
        }
        else
        {
            high = mid - 1;
        }
    }
        return -1;
}
}

接下去 来我们的思考:

class Solution {
    public int[] searchRange(int[] nums, int target) {
        /** 对应首尾的话,可以明确对应值是二个数，所以定义int [2] */
        int [] result = new int[2];
       
       /** 处理问题通常会优先判断某些特殊的边界情况,比如这里的数量都是为数据都不存在，那么匹配必然是匹配不到的。所以这里是 不存在返回必然是 [-1][-1] */
        if(nums.length == 0){
            result[0] = -1;
            result[1] = -1;
            return  result;
        } 
        /** 前面一个是前面的，后面一个是后面的。所以分二条路的二分法 接下去分析对应数据 */
        result[0] = findFirst(nums, nums.length, target);
        result[1] = findLast(nums, nums.length, target);
       return result;
    }
    
    /** 前一个值可以转换题目,获取某个值在数组中出现的第一次 */
    public int findFirst(int [] a, int len, int key)
    {
        /** 如果该数组小于1，那么说明该数组是空数组，所以自然是没有找到该值，返回-1 */
    if (len < 1)
        return - 1;

        /** 从首尾开始从头到尾开始二分法寻找 */
    int low = 0;
    int high = len - 1;
    while(low <= high)
    {
        /** 因为从前找后,所以处理数据 min是首尾相加/2,对应取商，不会有小数点。 如果中间值满足大于给的对比值，那么就从最小值-中间值，对应满足的中间值就取代对应上限值，继续进行二分处理,直到该值是满足题目给的对比值，但是这个值如果有前一位的话，该前一位不等于题目给的对比值。那么这个值就是我们要找的匹配第一个索引;
        如果是中间值小于给的对比值，那么最小值重新定义为中间值，继续比较，比较内容如上
        */
        int mid = (low + high)/2;
        if (a[mid] == key && (mid - 1 < 0 || a[mid - 1] != key))
        {
            return mid;
        }
        else if (a[mid] >= key)
        {
            high = mid - 1;
        }
        else
        {
            low = mid + 1;
        }
    }
        return -1;
}

  /** 因为从前找后,所以处理数据 min是首尾相加/2,对应取商，不会有小数点。 如果中间值满足大于给的对比值，那么就从最小值-中间值，对应满足的中间值就取代对应上限值，继续进行二分处理,直到该值是满足题目给的对比值，但是这个值如果有后一位的话，该后一位不等于题目给的对比值。那么这个值就是我们要找的匹配最后一个索引;
        如果是中间值小于给的对比值，那么最小值重新定义为中间值，继续比较，比较内容如上
        */
    public int findLast(int [] a, int len, int key)
    {
    if (len < 1)
        return - 1;
    int low = 0;
    int high = len - 1;
    while(low <= high)
    {
        int mid = (low + high)/2;
        if (a[mid] == key && (mid + 1 >= len || a[mid + 1] != key))
        {
            return mid;
        }
        else if (a[mid] <= key)
        {
            low = mid + 1;
        }
        else
        {
            high = mid - 1;
        }
    }
        return -1;
}
}

我的解题感触是什么。你可以把算法理解成优化。当你需要从某个已知按顺序排序区间内获取到某个值(题意要求你只需要获取一个值即可，或者是某个最优值)，那么你的处理可以是二分法。定位到你想定位的。该题我有设想过，如果循环比较，应该是最简单能想到的，我for去做对比，或者我一开始二分法，回去到一个坐标，然后这个坐标进行前推跟后推来获取对应的数据。
上面提交的效率是

首先进行二分法找到某个值，然后按照这个值开始向前向后进行检索，来处理数据，直接就是超出时间限制。可行应该是可行，但是效率差非常多。算法提示的东西就很稳健。

官方解题

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int leftIdx = binarySearch(nums, target, true);
        int rightIdx = binarySearch(nums, target, false) - 1;
        if (leftIdx <= rightIdx && rightIdx < nums.length && nums[leftIdx] == target && nums[rightIdx] == target) {
            return new int[]{leftIdx, rightIdx};
        } 
        return new int[]{-1, -1};
    }

    public int binarySearch(int[] nums, int target, boolean lower) {
        int left = 0, right = nums.length - 1, ans = nums.length;
        while (left <= right) {
            int mid = (left + right) / 2;
            if (nums[mid] > target || (lower && nums[mid] >= target)) {
                right = mid - 1;
                ans = mid;
            } else {
                left = mid + 1;
            }
        }
        return ans;
    }
}

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/solution/zai-pai-xu-shu-zu-zhong-cha-zhao-yuan-su-de-di-3-4/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

复杂度分析

时间复杂度： O(\log n)O(logn) ，其中 nn 为数组的长度。二分查找的时间复杂度为 O(\log n)O(logn)，一共会执行两次，因此总时间复杂度为 O(\log n)O(logn)。

空间复杂度：O(1)O(1) 。只需要常数空间存放若干变量。

对二分法的使用，加深了一点。

---

漫漫长路，一个小周跟他一个小陈朋友一起努力奔跑。

---