代码随想录第二天 | 有序数组的平方_leetcode 长度最小的子数组_leetcode 螺旋矩阵II_leetcode

有序数组的平方

考虑到数组中元素存在负数的情况，数组元素平方之后，最大值存在于新数组的两边，这里采用“双指针法”可以满足时间复杂度为O(n)

若对数组中的元素平方之后再去排序，可以采用快速排序的方式，此时的时间复杂度为O(nlogn)

这里给出双指针的解法、

/**

 * @param {number[]} nums

 * @return {number[]}

 */

let sortedSquares = function(nums) {

    let n = nums.length;

    let newNums = new Array(n).fill(0);g    let i = 0, j = n - 1, k = n -1;

    while(i <= j) {

        let left = nums[i] * nums[i];

        let right = nums[j] * nums[j];

        if(left < right) {

        　　newNums[k--] = right;

        　　j--;

        } else {

        　　newNums[k--] = left;

        　　i++;

        }

    }

    return newNums;

};

长度最小的子数组

采用双指针的方法实现滑动窗口

O(n)

 

O(nlog(n))

/**

 * @param {number} target

 * @param {number[]} nums

 * @return {number}

 */

var minSubArrayLen = function(target, nums) {

    //滑动窗口方法

    //记录窗口大小的指针

    let start = 0;

    let end = 0;

    //窗口内的值

    let sum = 0;

    //窗口最短长度

    let len = Infinity;

    while(end < nums.length) {

        sum += nums[end];

        while(sum >= target) {

            len = Math.min(len, end - start + 1);

            sum -= nums[start];

            start++;

        }

            end++;

        }

        return len === Infinity ? 0 : len;

};

螺旋矩阵II

/**

 * @param {number} n

 * @return {number[][]}

 */

var generateMatrix = function(n) {

//遵循循环不变量原则

//前几遍错误是因为offset没有更新

let startX = startY = 0;   // 起始位置

    let loop = Math.floor(n/2);   // 旋转圈数

    let mid = Math.floor(n/2);    // 中间位置

    let offset = 1;    // 控制每一层填充元素个数

    let count = 1;     // 更新填充数字

    let res = new Array(n).fill(0).map(() => new Array(n).fill(0));

    while (loop--) {

        let row = startX, col = startY;

        // 上行从左到右（左闭右开）

        for (; col < startY + n - offset; col++) {

            res[row][col] = count++;

        }

        // 右列从上到下（左闭右开）

        for (; row < startX + n - offset; row++) {

            res[row][col] = count++;

        }

        // 下行从右到左（左闭右开）

        for (; col > startY; col--) {

            res[row][col] = count++;

        }

        // 左列做下到上（左闭右开）

        for (; row > startX; row--) {

            res[row][col] = count++;

        }

        // 更新起始位置

        startX++;

        startY++;

        // 更新offset

        offset += 2;

    }

    // 如果n为奇数的话，需要单独给矩阵最中间的位置赋值

    if (n % 2 === 1) {

        res[mid][mid] = count;

    }

    return res;

};