算法---数组专题（一）

35.搜索插入位置

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
你可以假设数组中无重复元素。
示例 1:

输入: [1,3,5,6], 5
输出: 2

示例2:

输入: [1,3,5,6], 2
输出: 1

示例3:

输入: [1,3,5,6], 7
输出: 4

示例4:

输入: [1,3,5,6], 0
输出: 0

解法： (均采用Javascript求解)
一、暴力求解:

var searchInsert = function(nums, target) {
    for (let i = 0; i < nums.length; i++) {
        if (nums[i] >= target) {
            return i;
        }
    }
    return nums.length
};
// 算法时间复杂度：O(n)

二、二分法求解:

var searchInsert = function(nums, target) {
    var n = nums.length
    var left = 0
    var right = n - 1 // 左右都为闭区间
    while (left <= right) { // 此时[left,right]是有效的
        let middle = Math.floor((left + right) / 2) // js 向下取整
        if (nums[middle] > target) {
            right = middle - 1
        } else if (nums[middle] < target) {
            left = middle + 1
        } else {
            return middle
        }
    }
    // 当target比有序数组最后一个数还大时的情况，返回数组长度
    return right + 1
};
// 算法时间复杂度计算：
// n * (1/2)^x = 1  === >  x = logn
// 所以算法时间复杂度为O(logn)

27. 移除元素

题目描述：
给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

示例：

输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2]
解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。

解法1： 反向遍历数组，当找到与目标值相等的元素时，使用JS中的splice(index,howmany,item1,…,itemX) 进行删除, 此时不需要考虑元素删除后，数组中元素位置变化产生的影响，这点读者可以自行举例理解，js代码如下：

var removeElement = function(nums, val) {
    var len = nums.length
    for (let i = len - 1; i >=0; i--) {
        if (nums[i] === val) {
            nums.splice(i, 1)
        }
    }
    return nums.length
};

解法2： 双指针法(快慢指针法), 由于本题不需要考虑超出新数组长度后面的元素，故我们可以采取此方法

var removeElement = function(nums, val) {
    var slowIndex = 0;
    for (let fastIndex = 0; fastIndex < nums.length; fastIndex++) {
        if (nums[fastIndex] !== val) {
            nums[slowIndex++] = nums[fastIndex]
        }
    }
    return slowIndex
};

对于解法2，如果说，我们想取到最新的数组，我们可以这么写：

return nums.slice(0, slowIndex)
// arr.slice(n,m)代表取到数组arr的[n,m)区间上的元素

209.长度最小的子数组

题目描述：
给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, …, numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。
示例 1：

输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。

解决思路: 可采用滑动窗口方式求解(类似双指针法), JS代码：

var minSubArrayLen = function(target, nums) {
    var i = 0;
    var result = Number.MAX_VALUE
    var sum = 0
    var len = 0
    for (let j = 0; j < nums.length; j++) {
        sum += nums[j]
        // 找到j使得sum>=target时，j相当于静止，形成窗口
        // 在while循环中，通过改变i来使窗口移动
        // 用result来保存满足条件的最小子数组长度
        while(sum >= target) {
            len = j - i + 1
            // result 保存最小长度
            result = result < len ? result : len
            sum -= nums[i++]
        }
    }
    return result === Number.MAX_VALUE ? 0 : result
};

算法时间复杂度为O(n),如果需要暴力求解的话，需要有两层for循环，此时算法时间复杂度为O(n^2)