leetcode 34&35

1、快速解法：使用数组AP，思路清晰，核心是倒置数组来寻找结束的位置。、
时间复杂度不好说（API）
空间复杂度O1

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var searchRange = function(nums, target) {
    if(!nums.includes(target)) return [-1,-1];
    let first = nums.indexOf(target);
    let last = nums.length-1-(nums.reverse().indexOf(target));
    return [first,last]
};

2、二分法 ，标准答案
时间复杂度控制在Ologn
空间复杂度O1

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

var searchRange = function(nums, target) {
    let ans = [-1, -1];
    const leftIdx = binarySearch(nums, target, true);
    const rightIdx = binarySearch(nums, target, false) - 1;
    if (leftIdx <= rightIdx && rightIdx < nums.length && nums[leftIdx] === target && nums[rightIdx] === target) {
        ans = [leftIdx, rightIdx];
    } 
    return ans;
};

---

这个更简单一些，直接使用数组API过了

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number}
 */
var searchInsert = function(nums, target) {
    let hasIndex = nums.find((i)=>{
        return i==target;
    })
    if(hasIndex){
        return nums.indexOf(target);
    }else{
        nums.push(target);
        nums.sort((a,b)=>{
            return a-b;
        })
        return nums.indexOf(target)
    }
};

如果优化的话，还可以把判断逻辑再优化一下，可以使用findIndex（）。