Day2 有序数组的平方、长度最小的子数组、螺旋矩阵Ⅱ

三分钟热度_z

已于 2024-07-14 23:27:16 修改

阅读量585

点赞数 18

文章标签：算法数据结构

于 2024-07-14 23:15:52 首次发布

本文链接：https://blog.csdn.net/weixin_45502666/article/details/140424949

版权

算法刷题专栏收录该内容

4 篇文章 0 订阅

订阅专栏

977.有序数组的平方

力扣题目链接(opens new window)

给你一个按非递减顺序排序的整数数组 nums，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。

示例 1：

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]，排序后，数组变为 [0,1,9,16,100]

示例 2：

输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]

有序数组 ——> 双指针法（左右指针）

/**
 * @param {number[]} nums
 * @return {number[]}
 */
// 时间复杂度O(n) 空间复杂度O(n)
// 平方后大数在两端，左右指针
// 返回每个数字的平方组成的新数组（长度和原数组一致），非递减顺序（大数在右端）
var sortedSquares = function (nums) {
    let left = 0, right = nums.length - 1;
    let squares = new Array(nums.length);
    let k = squares.length - 1;
    while (left <= right) {
        // 新数组从后往前（从大到小）赋值
        if (nums[left] * nums[left] <= nums[right] * nums[right]) {
            squares[k] = nums[right] * nums[right];
            k--; right--;
        }
        else {
            squares[k] = nums[left] * nums[left];
            k--; left++;
        }
    }
    return squares;
};
// res[k--] = right; k--后置递减运算符，先赋值后递减
// res[--k] = right; --k前置递减运算符，先递减后赋值

209.长度最小的子数组

力扣题目链接(opens new window)

给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的连续子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

示例：

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

提示：

1 <= target <= 10^9
1 <= nums.length <= 10^5
1 <= nums[i] <= 10^5

找某条件下长度最小/最大的子数组 ——> 滑动窗口（快慢指针）

所谓滑动窗口，就是不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。

只用一个for循环，循环的索引表示 滑动窗口的终止位置。根据当前子序列满足某条件的情况，不断调节子序列的起始位置。

/**
 * @param {number} target
 * @param {number[]} nums
 * @return {number}
 */
// 某条件下长度最小/最大的子数组 ——> 滑动窗口（快慢指针）
var minSubArrayLen = function (target, nums) {
    let result = Infinity;  // 声明子数组长度并赋值正无穷，Infinity（找最小，初始为Infinity）
    let sum = 0, subLength = 0;  // 用于记录总和和满足条件的数组的长度
    let slow = 0, fast = 0;  // 快慢指针用于滑动窗口
    while (fast < nums.length) {  // 窗口的结束位置（快指针）小于数组长度
        sum += nums[fast];  // 当前窗口中的总和
        while (sum >= target) {  // 总和大于等于target
            subLength = (fast - slow + 1);  // 记录窗口大小
            result = result < subLength ? result : subLength;  // 比较得到满足条件的长度最小的子数组
            sum -= nums[slow++];  // 总和减去窗口起始位置的值，并向后移动窗口的起始位置（慢指针）
        }  // 总和小于target时结束循环
        fast++;  // 向后移动窗口的结束位置
    }  // 窗口的结束位置滑到数组末尾后结束循环
    return result !== Infinity ? result : 0;  // 判断是否存在符合条件的子数组，存在返回其长度，不存在返回0
};

59.螺旋矩阵II

力扣题目链接(opens new window)

给定一个正整数 n，生成一个包含 1 到 n^2 所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。

示例:

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

方法一：坚持循环不变量原则（左开右闭），模拟顺时针画矩阵的过程：

填充上行从左到右
填充右列从上到下
填充下行从右到左
填充左列从下到上

/**
 * @param {number} n
 * @return {number[][]}
 */
var generateMatrix = function (n) {
    let loop = Math.floor(n / 2);  // 顺时针为1圈，需要转的圈数
    let mid = Math.floor(n / 2);  // 如果n为奇数，需要额外填入中心点
    let offset = 1;  // 四条边每条边控制一个左闭右开的区间，最后一个元素不填
    let x = 0, y = 0;  // 每一圈的起始点
    let matrix = new Array(n).fill(0).map(() => new Array(n).fill(0));  // n*n的二维数组，默认填充0
    let value = 1;  // 要填充的元素
    while (loop--) {
        let row = x, col = y;  // 每一圈的起始行和列
        for (; col < n - offset; col++) {  // 从左到右依次填充
            matrix[row][col] = value++;
        }
        for (; row < n - offset; row++) {  // 从上到下依次填充
            matrix[row][col] = value++;
        }
        for (; col > y; col--) {  // 从右到左依次填充
            matrix[row][col] = value++;
        }
        for (; row > x; row--) {  // 从下到上依次填充
            matrix[row][col] = value++;
        }
        x++; y++;  // 下一圈的起始点
        offset++;  // 更新偏移量
    }
    if (n % 2 !== 0) {  // 如果n为奇数
        matrix[mid][mid] = value;  // 填充中心元素
    }
    return matrix;
};

方法二：动态更新边界，在每个方向填充完成后检查边界是否交叉，一旦交叉立即退出循环（更通用）

/**
 * @param {number} n
 * @return {number[][]}
 */
// 动态更新边界top left bottom right
// 在每个方向填充完成后检查边界是否交叉，一旦交叉立即退出循环
// 无需特殊处理中心点
var generateMatrix = function (n) {
    let matrix = new Array(n).fill(0).map(() => new Array(n).fill(0));  // n*n的二维数组，默认填充0
    let value = 1;  // 要填充的元素
    let top = 0, left = 0;  // 矩阵上和左边界
    let bottom = n - 1, right = n - 1;  // 矩阵下和右边界
    while (true) {
        for (let i = left; i <= right; i++) {  // 从左到右依次填充
            matrix[top][i] = value++;
        }
        if (++top > bottom) break;  // 更新上边界，超出下边界时停止循环

        for (let i = top; i <= bottom; i++) {  // 从上到下依次填充
            matrix[i][right] = value++;
        }
        if (--right < left) break;  // 更新右边界，超出左边界时停止循环

        for (let i = right; i >= left; i--) {  // 从右到左依次填充
            matrix[bottom][i] = value++;
        }
        if (--bottom < top) break;  // 更新下边界，超出上边界时停止循环

        for (let i = bottom; i >= top; i--) {  // 从下到上依次填充
            matrix[i][left] = value++;
        }
        if (++left > right) break;  // 更新左边界，超出右边界时停止循环
    }
    return matrix;
};