leecode算法《34. 在排序数组中查找元素的第一个和最后一个位置》详解有注释，简单明了。

leecode算法《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]

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

审题：

这个题的难点在于题目中要求了时间复杂度必须O(log n) 级别。那么普通的for循环已经不能解决此问题了
于是我想到二分法

关于二分法我的博客中有一个算法《算法平方根》用到的也是二分法。大家可以参考
https://blog.csdn.net/qq_35971301/article/details/98945207

有方法了就需要实现，那么二分法的实现大体有两种
1 递归
2 while循环

while循环leecode官方有题解
我就写一个递归

递归思路

找左边界
1找到读取的数必须是8
2该数的左边的一个数必须不是8
》》》》》》1 左边没有数值了：8现在是数组的第一个位置
》》》》》》2左边的值小于8
找右边界
1找到读取的数必须是8
2该数的右边的一个数必须不是8
》》》》》》1 右边没有数值了：8现在是数组的最后一个位置
》》》》》》2右边的值小于8

代码：

public class MinStack {


    public static void main(String[] args) {
        int[] i = searchRange(new int[]{2, 2}, 2);
        System.out.println(i[0]+"=="+i[1]);

    }

    public static int[] searchRange(int[] nums, int target) {
        int[] result = new int[2];
        result[0] = erfen(nums, target, 0, nums.length - 1);
        result[1] = erfen2(nums, target, 0, nums.length - 1);
        return result;

    }
// 找左边界
    public static int erfen(int[] nums, int target, int low, int high) {
        // 如果左边界大于右边界了 ，返回-1
        if (low > high) {
            return -1;
        }
        // 求中间值
        int middle =(high +low) / 2;
        // 如果中间值等于目标值，并且 并且该值的索引为0或者该值的左边的一个值小于目标值返回middle
        if (nums[middle] == target && (middle == 0 || nums[middle - 1] < target)) {
            return middle;
        }
        // 如果目标值小于等于中间值
        if (target <= nums[middle]) {
            // 则上边界-1.
            return erfen(nums, target, low, middle - 1);
        } else {
            // 则下边界+1.
            return erfen(nums, target, middle + 1, high);
        }
    }
// 找右边界
    public static int erfen2(int[] nums, int target, int low, int high) {
        // 如果左边界大于右边界了 ，返回-1
        if (low > high) {
            return -1;
        }
        // 求中间值
        int middle =(high +low) / 2;
        // 如果中间值等于目标值，并且 并且该值的索引为length-1或者该值的右边的一个值小于目标值返回middle
        if (nums[middle] == target && (middle == nums.length-1 || nums[middle + 1] > target)) {
            return middle;
        }
        // 如果目标值小于等于中间值》》注意此时不能再加等于了
        if (target < nums[middle]) {
            // 则上边界-1.
            return erfen2(nums, target, low, middle - 1);
        } else {
            // 则下边界+1.
            return erfen2(nums, target, middle + 1, high);
        }
    }
}

while循环

代码

class Solution {
    // returns leftmost (or rightmost) index at which `target` should be
    // inserted in sorted array `nums` via binary search.
    private int extremeInsertionIndex(int[] nums, int target, boolean left) {
        int lo = 0;
        int hi = nums.length;

        while (lo < hi) {
            int mid = (lo + hi) / 2;
            if (nums[mid] > target || (left && target == nums[mid])) {
                hi = mid;
            }
            else {
                lo = mid+1;
            }
        }

        return lo;
    }

    public int[] searchRange(int[] nums, int target) {
        int[] targetRange = {-1, -1};

        int leftIdx = extremeInsertionIndex(nums, target, true);

        // assert that `leftIdx` is within the array bounds and that `target`
        // is actually in `nums`.
        if (leftIdx == nums.length || nums[leftIdx] != target) {
            return targetRange;
        }

        targetRange[0] = leftIdx;
        targetRange[1] = extremeInsertionIndex(nums, target, false)-1;

        return targetRange;
    }
}

作者：LeetCode
链接：https://leetcode-cn.com/problems/two-sum/solution/zai-pai-xu-shu-zu-zhong-cha-zhao-yuan-su-de-di-yi-/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。