代码随想录算法训练营第二天丨数组part 02

977.有序数组的平方

题目如下：

给你一个按 非递减顺序 排序的整数数组 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]

提示：

• 1 <= nums.length <= 104
• -104 <= nums[i] <= 104
• nums 已按 非递减顺序 排序

leetcode题目链接：977.有序数组的平方

思路

暴力解法

这个地方排序没有直接用API，而是使用了冒泡排序，主要是为了更直观看出它的时间复杂度O(n²)

代码如下：

class Solution {
    public int[] sortedSquares(int[] nums) {
        for (int i = 0; i < nums.length; i++) {
            nums[i] *= nums[i];
        }
        return bubbleSort(nums);
    }

    // 冒泡排序
    private int[] bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        return arr;
    }
}

双指针法

nums 已按 非递减顺序 排序，表明数组平方的最大值就在数组的两端，不是最左边就是最右边，不可能是中间。

那为什么还要起始位置平方做比较呢？因为负数的平方可能就是最大值。

所以定义了两个指针：

• left：指向起始位置
• right：指向终止位置

代码如下：

class Solution {
    public int[] sortedSquares(int[] nums) {
        int left = 0; // 指向起始位置
        int right = nums.length - 1; // 指向终止位置
        int[] result = new int[nums.length]; // 定义一个新数组result，和nums一样的大小
        int k = nums.length - 1; // 让k指向result数组终止位置
        while(left <= right) { // 注意这里要i <= j，因为最后要处理两个元素
             if (nums[left] * nums[left] < nums[right] * nums[right]) {
                result[k--] = nums[right] * nums[right];
                right--;
            } else {
                result[k--] = nums[left] * nums[left];
                left++;
            }
        }
        return result;
    }
}

执行过程

时间复杂度为：O(n)

209.长度最小的子数组

题目如下：

给定一个含有 n 个正整数的数组和一个正整数 target 。

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

示例 1：

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

示例 2：

输入：target = 4, nums = [1,4,4]
输出：1

示例 3：

输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0

leetcode题目链接：209.长度最小的子数组

思路

暴力解法

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int result = Integer.MAX_VALUE; // 最终的结果
        for (int i = 0; i < nums.length; i++) { // 设置子序列起点为i
            int sum = 0; // 子序列的数值之和
            for (int j = i; j < nums.length; j++) { // 设置子序列终止位置为j
                sum += nums[j];
                if (sum >= target) { // 一旦发现子序列和超过了s，更新result
                    result = Math.min(result, j - i + 1);
                    break; // 因为我们是找符合条件最短的子序列，所以一旦符合条件就break
                }
            }
        }
        // 如果result没有被赋值的话，就返回0，说明没有符合条件的子序列
        return result == Integer.MAX_VALUE ? 0 : result;
    }
}

但是这个算法在leetcode上会超时。
时间复杂度：O(n²)
空间复杂度：O(1)

滑动窗口

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

在暴力解法中，是一个for循环滑动窗口的起始位置，一个for循环为滑动窗口的终止位置，用两个for循环 完成了一个不断搜索区间的过程。

滑动窗口则只用一个for循环，表示 滑动窗口的终止位置。

如图所示：
窗口：满足其和 ≥ target 的长度最小的连续子数组。

窗口的起始位置如何移动：如果当前窗口的值大于s了，窗口就要向前移动了（也就是该缩小了）。

窗口的结束位置如何移动：窗口的结束位置就是遍历数组的指针，也就是for循环里的索引。

我们通过不断更新窗口的长度得到子序列。

代码如下：

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int left = 0; // 滑动窗口的起始位置
        int sum = 0;
        int result = Integer.MAX_VALUE; // 首先把长度取最大
        for (int right = 0; right < nums.length; right++) {// 滑动窗口的终止位置
            sum += nums[right];
            while(sum >= target) {// 注意这里使用while，每次更新 i（起始位置），并不断比较子序列是否符合条件
                result = Math.min(result, right - left + 1);
                sum -= nums[left++];// 这里体现出滑动窗口的精髓之处，不断变更i（子序列的起始位置）
            }
        }
        // 如果result没有被赋值的话，就返回0，说明没有符合条件的子序列
        return result == Integer.MAX_VALUE ? 0 : result;
    }
}

• 时间复杂度：O(n)
• 空间复杂度：O(1)

59.螺旋矩阵II

题目如下：

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

示例 1：

输入：n = 3
输出：[[1,2,3],[8,9,4],[7,6,5]]

示例 2：

输入：n = 1
输出：[[1]]

提示：

• 1 <= n <= 20

leetcode题目链接：59.螺旋矩阵II

思路

这一道题我从来没有见过，一点思路都没有。
看了题解才明白是想要考察模拟过程。

模拟顺时针画矩阵的过程:
填充上行从左到右
填充右列从上到下
填充下行从右到左
填充左列从下到上
由外向内一圈一圈这么画下去。

难点在于对每条边坚持左闭右开的原则。

千万不要画每一条边的时候，一会左开右闭，一会左闭右闭，一会又来左闭右开…

代码如下：

class Solution {
    public int[][] generateMatrix(int n) {
        int loop = 0; // 控制循环次数,需要控制每一条边遍历的长度，每次循环右边界收缩一位
        int count = 1; // 定义填充数字
        int res[][] = new int[n][n];
        int start = 0; // 每次循环的开始点(start, start)
        int i,j;
        while(loop++ < n/2) {// 判断边界后，loop从1开始
            // 从左到右
            for (j = start; j < n - loop; j++ ) {
                res[start][j] = count++;
            }

            // 从上到下
            for (i = start; i < n - loop; i++) {
                res[i][j] = count++;
            }

            // 从右到左
            for (; j >= loop; j--) { 
                res[i][j] = count++; // 执行完j为0
            }

            // 从下到上
            for (; i >= loop; i--) {
                res[i][j] = count++; // 执行完i为1
            }

            start++;
        }

        if (n % 2 == 1) {// 矩阵中间的位置，例如：n为3， 中间的位置就是(1，1)，n为5，中间位置为(2, 2)
            res[start][start] = count;
        }

        return res;
    }
}

• 时间复杂度为： O(n²):
• 空间复杂度为： O(1)

补充：

i++：先将i赋值于表达式，然后i执行++运算。
++i：先i执行++运算，然后将i赋值于表达式。
两个的区别在于，前一个表达式值是i，后一个表达式值是i+1，对于i来说，执行后，i都+1。

I–与 --i同理