代码随想录寒假打卡Day02_有序数组的平方、长度最小的子数组、螺旋矩阵Ⅱ、数组总结

今日学习文章及视频链接

代码随想录_有序数组的平方视频课

代码随想录_长度最小的子数组视频课

代码随想录_螺旋数组Ⅱ视频课

代码随想录_数组总结篇

有序数组的平方

例题

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

大概思路

暴力排序解法

代码实现：通过循环遍历数组，将每个元素进行平方操作，之后使用sort函数（快速排序）对平方后的数组进行排序，最后返回排序后的数组。

时间复杂度：对数组所有元素进行平方操作时间复杂度为O(n) ，排序操作时间复杂度为O(nlogn) ，整体时间复杂度记为O(n + nlogn) ，近似为 O(nlogn)。

学习完代码随想录后，认识到解决这类题型的方法大致分为-暴力排序-和-双指针法-

双指针解法

解题思路：

        由于原数组有序，负数平方后可能成为最大数，所以数组平方后的最大值在数组两端。使用双指针，i指向起始位置，j指向终止位置，定义与原数组大小相同的新数组result，k指向result数组的终止位置。比较A[i] * A[i]与A[j] * A[j]的大小，将较大的平方值放入result[k]，并移动相应指针。

代码实现：

       初始化k为数组A的大小减 1，创建大小与A相同且初始值为 0 的数组result。

       通过for循环，在i <= j的条件下进行比较和赋值操作。

       若A[i] * A[i] < A[j] * A[j]，将A[j] * A[j]赋值给result[k]，并将j和k指针减 1；

       否则，将A[i] * A[i]赋值给result[k]，并将i和k指针进行相应移动。

       循环结束后，返回result数组。

时间复杂度：仅需遍历一次数组，时间复杂度为 ，相较于暴力排序解法有显著提升。

两种方法的具体代码实现：

import java.util.Arrays;

public class SortedSquares {
    // 暴力排序法
    public static int[] sortedSquaresByBruteForce(int[] nums) {
        for (int i = 0; i < nums.length; i++) {
            nums[i] = nums[i] * nums[i];
        }
        Arrays.sort(nums);
        return nums;
    }

    // 双指针法
    public static int[] sortedSquaresByTwoPointers(int[] nums) {
        int[] result = new int[nums.length];
        int i = 0;
        int j = nums.length - 1;
        int k = nums.length - 1;
        while (i <= j) {
            if (Math.abs(nums[i]) < Math.abs(nums[j])) {
                result[k--] = nums[j] * nums[j];
                j--;
            } else {
                result[k--] = nums[i] * nums[i];
                i++;
            }
        }
        return result;
    }

    public static void main(String[] args) {
        int[] nums = {-4, -1, 0, 3, 10};
        int[] result1 = sortedSquaresByBruteForce(nums.clone());
        int[] result2 = sortedSquaresByTwoPointers(nums);
        System.out.println("暴力排序法结果: " + Arrays.toString(result1));
        System.out.println("双指针法结果: " + Arrays.toString(result2));
    }
}

可能遇到的困难

暴力排序解法中，对基本数据类型数组排序可能会混淆排序方法，所以排序时，确保使用正确的排序方法，如Arrays.sort

双指针解法中，指针移动逻辑可能会出错，如i、j、k指针更新条件和顺序错误；在比较元素平方大小时，绝对值计算错误。所以，需要注意仔细检查指针移动的条件和顺序，可通过调试或添加注释辅助理解；计算绝对值时，可以使用Math.abs方法确保正确。

长度最小的子数组

例题

给定一个含有 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循环，外层循环控制子数组起始位置，内层循环控制终止位置。在内层循环中计算子数组的和，一旦和大于等于给定值s，就更新最小子数组长度，并停止内层循环继续寻找下一个起始位置的符合条件子数组。时间复杂度为O(n的平方)，空间复杂度为O(1)。

学习完代码随想录后，认识到解决这类题型的方法大致分为-暴力解法-和-滑动窗口解法-

滑动窗口解法

原理：

滑动窗口通过调节子序列的起始和终止位置得出结果，可视为双指针法的一种。使用一个for循环表示窗口的终止位置，通过while循环根据窗口内元素和与s的大小关系调整窗口起始位置。

实现要点：

确定窗口内是满足和大于等于s的连续子数组；

当窗口内元素和大于等于s时，窗口起始位置向前移动（缩小窗口）；

窗口结束位置由for循环的索引控制，即遍历数组的指针；

通过不断调节窗口起始位置，将时间复杂度从暴力解法的O(n的平方)降为O(n)，空间复杂度为O(1)

滑动窗口的“接地气”解释

想象一下，有一个很长的数字队伍（数组）。滑动窗口就像是一个可以移动的小框框，这个框框可以框住队伍里的一部分数字（连续的子数组）。

我们的目标是找到和大于等于s的长度最小的子数组。首先，我们让这个小框框（滑动窗口）的左边（起始位置）在队伍（数组）的最开始。

然后，我们慢慢把小框框的右边（终止位置）往队伍后面移。每移动一次，我们就计算一下小框框里数字的总和。

当这个总和大于等于s的时候，我们就看看这个小框框（子数组）的长度。如果这个长度比之前找到的符合条件的小框框长度都要小，那我们就记住这个长度。

但是，我们还不能停。因为可能还有更短的小框框也满足条件。这时候，我们就试着把小框框的左边（起始位置）往队伍后面移一点，看看总和还满不满足大于等于s。如果满足，我们就又得到一个可能更短的小框框，再比较一下长度。

我们就这样一直移动小框框的右边（终止位置），当总和小于s的时候，就继续往后移；当总和大于等于s的时候，就试着移动小框框的左边（起始位置），一直到小框框的右边（终止位置）移到队伍的最后。这样，我们就能找到长度最小的那个满足条件的小框框啦。

具体代码实现示例：

public class MinimumSizeSubarraySum {
    // 暴力解法
    public static int minSubArrayLenBruteForce(int s, int[] nums) {
        int minLen = Integer.MAX_VALUE;
        for (int i = 0; i < nums.length; i++) {
            int sum = 0;
            for (int j = i; j < nums.length; j++) {
                sum += nums[j];
                if (sum >= s) {
                    minLen = Math.min(minLen, j - i + 1);
                    break;
                }
            }
        }
        return minLen == Integer.MAX_VALUE ? 0 : minLen;
    }

    // 滑动窗口解法
    public static int minSubArrayLenSlidingWindow(int s, int[] nums) {
        int left = 0;
        int right = 0;
        int sum = 0;
        int minLen = Integer.MAX_VALUE;
        while (right < nums.length) {
            sum += nums[right];
            while (sum >= s) {
                minLen = Math.min(minLen, right - left + 1);
                sum -= nums[left];
                left++;
            }
            right++;
        }
        return minLen == Integer.MAX_VALUE ? 0 : minLen;
    }

    public static void main(String[] args) {
        int[] nums = {2, 3, 1, 2, 4, 3};
        int s = 7;
        int bruteForceResult = minSubArrayLenBruteForce(s, nums);
        int slidingWindowResult = minSubArrayLenSlidingWindow(s, nums);
        System.out.println("暴力解法结果: " + bruteForceResult);
        System.out.println("滑动窗口解法结果: " + slidingWindowResult);
    }
}

螺旋矩阵Ⅱ

例题

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

示例:

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

大概思路

 要画一个正方形的图案，这个图案里的数字从1开始，一直到n乘以n那么多，而且这些数字得像螺旋一样一圈一圈地排。就像给这个正方形一圈一圈地“包边”。

先从最外圈开始，分四步来画这一圈的四条边。（以“左闭右开”为例）

第一步，从左边往右边画上面那条边。这时候，咱们要记住一个小规则，就是左边这个点要算进去，右边那个点不算，这就是“左闭右开”，就好像左边的门关上了，右边的门开着。沿着这条边，一个一个地把数字填进去。

第二步，从上边往下边画右边那条边，同样遵循“左闭右开”，把数字顺着往下填。

第三步，从右边往左边画下面那条边，还是按照这个规则，把数字填好。

第四步，从下边往上面画左边那条边，把这一圈剩下的数字填完。

画完一圈后，咱们就往里面再画一圈，还是按照这四步的方法，每次都从左上角开始，再一圈一圈地画。

但是这里面有个小细节，如果n是奇数的话，最后中间会剩下一个小格子，咱们得单独给这个小格子填上数字。

具体代码实现示例

public class SpiralMatrixII {
    // 生成螺旋矩阵的方法
    public static int[][] generateMatrix(int n) {
        int[][] result = new int[n][n];
        int startRow = 0;
        int startCol = 0;
        int endRow = n - 1;
        int endCol = n - 1;
        int num = 1;

        while (startRow <= endRow && startCol <= endCol) {
            // 从左到右填充上面一行
            for (int i = startCol; i <= endCol; i++) {
                result[startRow][i] = num++;
            }
            startRow++;

            // 从上到下填充右边一列
            for (int i = startRow; i <= endRow; i++) {
                result[i][endCol] = num++;
            }
            endCol--;

            // 从右到左填充下面一行
            if (startRow <= endRow) {
                for (int i = endCol; i >= startCol; i--) {
                    result[endRow][i] = num++;
                }
                endRow--;
            }

            // 从下到上填充左边一列
            if (startCol <= endCol) {
                for (int i = endRow; i >= startRow; i--) {
                    result[i][startCol] = num++;
                }
                startCol++;
            }
        }
        return result;
    }

    public static void main(String[] args) {
        int n = 3;
        int[][] matrix = generateMatrix(n);
        for (int[] row : matrix) {
            for (int num : row) {
                System.out.print(num + " ");
            }
            System.out.println();
        }
    }
}

学习完代码随想录后，认识到解决这类题型的方法是模拟螺旋绘制矩阵的过程。具体绘制过程是由外向内一圈圈进行，每圈绘制四条边，分别为从左到右填充上行、从上到下填充右列、从右到左填充下行、从下到上填充左列 。

难点

为保证代码逻辑清晰，需遵循循环不变量原则。在绘制每条边时，坚持左闭右开的规则，确保绘制过程的一致性，防止因边界处理规则混乱导致代码出错。

数组总结

 1. 数组理论基础

数组是存储在连续内存空间的相同类型数据集合，通过下标索引访问元素，下标从0开始。因其内存连续，增删元素需移动其他元素。C++中vector与array不同，vector是容器，底层基于array实现 。以Java二维数组为例，如int[][] rating = new int[3][4]，其内存并非3×4的连续空间，而是由四条连续地址空间构成。

2. 数组经典题目及解法

二分法：

以相关题目为例，可采用暴力解法，时间复杂度为O(n)，更优解是二分法，时间复杂度为O(logn)，解题时需遵循循环不变量原则，该方法是算法面试常考内容。

双指针法（快慢指针法）：

在移除元素题目中应用，暴力解法时间复杂度为O(n的平方），双指针法可将其降为O(n)。该方法通过一个快指针和慢指针在一个for循环内完成原本两个for循环的工作，在数组和链表操作中应用广泛。

滑动窗口：

在特定题目中，暴力解法时间复杂度为O(n的平方)，滑动窗口法为O(n)。该方法根据子序列和的情况调节起始位置，动态更新窗口大小，以获取符合条件的最小长度。

模拟行为（包括但不限于螺旋矩阵）：

这类题目不涉及特定算法，主要考验代码掌控能力。解题时需遵循循环不变量原则，避免边界判断混乱，使代码简洁且有原则。

今日收获

~脑袋怎么嗡嗡的？~

~糟糕~

~是知识的回响！~

时长记录：耗时将近120分钟完成学习和博客内容

希望有所帮助~