代码随想录算法营Day02：双指针进阶：滑动窗口

代码随想录算法训练营第二天 | LeetCode 977. 有序数组的平方, 209. 长度最小的子数组, 59. 螺旋矩阵II

LeetCode 977. 有序数组的平方

分析

• 新数组：非原地
• 时间复杂度为 O(n)：不能直接用array.sort()，因为时间复杂度是O(n * log n)
• nums已按非递减顺序排序
• 返回一个数字的平方组成的数组：以[-9, -5, 0, 1, 3, 7]为例，这意味着元素的绝对值从两端向中间递减

JavaScript代码实现

let sortedSquares = nums => {
    let left = 0, right = nums.length - 1
    // 创建一个等长的新数组，默认值均为-1
    let res = new Array(nums.length).fill(-1)
    // 这里index指针指向的是len - 1所以下面就要用left <= right
    let i = res.length - 1
    while (left <= right) {
        // 也可以用平方值比较 等同于比较绝对值
        // if (nums[left] * nums[left] >= nums[right] * nums[right]) {
        if (Math.abs(nums[left]) >= Math.abs(nums[right])) {
            // 哪个大赋值哪个的平方码放到新数组里
            res[i--] = nums[left] * nums[left]
            left++
        } else {
            res[i--] = nums[right] * nums[right]
            right--
        }
    }
    return res
}
let arr = [-9, -5, 0, 1, 3, 7]
console.log(sortedSquares(arr))

错误

忘了在每次循环中更新左右指针，本方法需要用到3个指针。当指针太多时要检查是否都更新到。

LeetCode 209. 长度最小的子数组

法一: 暴力遍历(超时)

var minSubArrayLen = function(target, nums) {
    let len = nums.length
    let ans = len + 1
    for (let i = 0; i < len; i++) {
        for (let j = i; j < len; j++) {
            if (sum(nums, i, j) >= target) {
                ans = Math.min(ans, j - i + 1)
            }
        }
    }
    return ans === len + 1 ? 0 : ans
};


function sum (nums, i, j){
    let res = 0
    for (let k = i; k <= j; k++) {
        res += nums[k]
    }
    return res
}

错误与反思

虽然是暴力解，过程中还是有错误，比如求子数组元素和k <= j 没有加“=”。另外，三元运算符有时比if语句来得简单清楚多。

法二: 滑动窗口

思路

什么叫滑动窗口呢，这是一个左右双指针维护的区间窗口。开始时，两个指针都指向数组的第一个元素。然后，我们不断移动右端点end，并将新的元素加入窗口中，直到窗口内的元素和满足大于等于target的要求。此时，我们移动左端点start，并不断排除窗口中的元素，直到窗口内的元素不再满足要求。这个过程中，我们记录窗口大小的最小值，并在整个过程中保持更新。

JS代码实现

let minSubArrayLen = (target, nums) => {
    let start = 0, end = 0
    let sum = 0
    let len = nums.length
    let ans = len + 1

    // 边界也可以是 end < len
    while(end <= len - 1){
        sum += nums[end]            // 每次循环开始时，都加上新包含的子数组元素
        while (sum >= target) {
            // 比较之前ans和现在的子数组长度，哪个小就赋值更新ans
            ans = Math.min(ans, end - start + 1)
            sum -= nums[start++]    // 子数组排除最左的元素，start指针往右走
        }
        end++                       // 不要忘了更新右指针使其往右走
    }
    return ans === len + 1 ? 0 : ans
}

复杂度分析(易错)

时间复杂度不是O(n^2)! 不能看见俩循环嵌套就是O(n^2)。在这个滑动窗口模型中，左右指针一共都走了n次，即内外循环均为n次，所以时间复杂度是O(n)

59. 螺旋矩阵 II

let generateMatrix = function (n) {
    let dx = 0, dy = 1                  // 用来控制坐标
    let arr = Array.from({length: n}, () => new Array(n).fill(0)) // 建立n * n的二维数组填入 0
    // let arr = new Array(n).fill(new Array(n).fill(0))  // 这样会出错
    let x = 0, y = 0
    for (let i = 1; i <= n * n; i++) {
        arr[x][y] = i
        console.log(x, y)
        // 如果撞头就向右调转90度 先加n再对n取模这个操作能防止越界,
        // if ((dx === 0 && !arr[x][y + 1]) || (dy === 0 && !arr[x + 1]?.[y])) {
        if (arr[(x + dx + n) % n][(y + dy + n) % n] !== 0) {
            // 转弯
            let temp = dy
            dy = -dx
            dx = temp
        }
        // console.log(x, y, arr[x][y])
        // 往前走
        x += dx
        y += dy
        console.log(arr)
    }
    return arr
}

错误

若用
let arr = new Array(n).fill(new Array(n).fill(0))
矩阵的每一行都填充了对同一数组对象的引用，因此更新一行也会更新所有其他行，不能做到更新每个元素。

复杂度分析

时间：O(n^2)