代码随想录算法训练营 Day 2，977.有序数组的平方 ，209.长度最小的子数组 ，59.螺旋矩阵II

目录

977.有序数组的平方

---

977.有序数组的平方

题目链接：. - 力扣（LeetCode）

文章讲解：代码随想录

视频讲解： 双指针法经典题目 | LeetCode：977.有序数组的平方_哔哩哔哩_bilibili

暴力解法

每个数平方之后，排序

class Solution {
    public int[] sortedSquares(int[] nums) {
        int right = nums.length - 1;
        int left = 0;
        int[] result = new int[nums.length];
        int index = result.length - 1;
        while(left <= right) {
            if (nums[left] * nums[left] > nums[right] * nums[right]){
                result[index--] = nums[left] *nums[left];
                   //将此平方分配给result数组中的当前index位置，然后递减index
                ++left;
            }
            else {
                result[index--] = nums[right] * nums[right];
                --right;
            }
        }
        return result;
    }
}

双指针法

class Solution {
    public int[] sortedSquares(int[] nums) {
        int l = 0;
        int r = nums.length - 1;
        int[] result = new int[nums.length];
        int j = nums.length - 1; // 初始化结果数组的索引 j 为最后一个位置
        while(l <= r){
            if(nums[l] * nums[l] > nums[r] * nums[r]){
                result[j--] = nums[l] * nums[l];
                l++;
            }
            else{
                result[j--] = nums[r] * nums[r];
                r--;
            }
        }
        return result;
    }
}

数组平方的最大值在数组的两端，使用双指针法，l指向起始位置，r指向终止位置。

定义一个新数组result，和nums数组一样的大小，让j指向result数组终止位置。

如果A[l] * A[l] > A[r] * A[r] 那么result[j--] = A[l] * A[l]; 

如果A[l] * A[l] <= A[r] * A[r] 那么result[j--] = A[r] * A[r]; 

209.长度最小的子数组

题目链接：. - 力扣（LeetCode）

文章讲解：代码随想录

视频讲解：拿下滑动窗口！ | LeetCode 209 长度最小的子数组_哔哩哔哩_bilibili

双指针法 

class Solution {

    // 滑动窗口
    public int minSubArrayLen(int s, int[] nums) {
        int left = 0;
        int sum = 0;
        int result = Integer.MAX_VALUE;
            // 初始化结果 result 为正无穷大，用于记录满足条件的最小子数组长度
        for(int right = 0; right < nums.length; right++) {
            sum += nums[right];
            while (sum >= s) {
                result = Math.min(result, right - left + 1);
                    // 更新 result 为当前子数组长度 (right - left + 1) 和 result 中的较小值
                sum -= nums[left++];
                    // 将左指针位置的元素值从 sum 中减去，并将左指针右移一位
            }
        }
        return result == Integer.MAX_VALUE ? 0 : result;
            // 如果 result 仍为初始值，返回 0；否则返回 result，表示最小子数组长度
    }
}

59.螺旋矩阵II

题目链接：. - 力扣（LeetCode）

文章讲解：代码随想录

视频讲解：一入循环深似海 | LeetCode：59.螺旋矩阵II_哔哩哔哩_bilibili

class Solution {
    public int[][] generateMatrix(int n) {
        
        int[][] nums = new int[n][n];
        // 创建一个 n x n 的二维数组 nums
        
        int startX = 0, startY = 0;
        // 初始化每一圈的起始点 startX 和 startY 为 (0, 0)
        
        int offset = 1;
        // 用于控制每一圈的偏移量，初始为 1
        
        int count = 1;
        // 需要填写到矩阵中的数字，初始为 1
        
        int loop = 1;
        // 记录当前的圈数，初始为 1
        
        int i, j;
        // 定义变量 i 和 j，用于控制行和列的索引

        while (loop <= n / 2) {
            // 循环控制圈数，最多处理 n/2 圈

            // 顶部
            // 从左到右填充，左闭右开，循环结束时 j 不能等于 n - offset
            for (j = startY; j < n - offset; j++) {
                nums[startX][j] = count++;
            }

            // 右列
            // 从上到下填充，左闭右开，循环结束时 i 不能等于 n - offset
            for (i = startX; i < n - offset; i++) {
                nums[i][j] = count++;
            }

            // 底部
            // 从右到左填充，左闭右开，循环结束时 j 不能等于 startY
            for (; j > startY; j--) {
                nums[i][j] = count++;
            }

            // 左列
            // 从下到上填充，左闭右开，循环结束时 i 不能等于 startX
            for (; i > startX; i--) {
                nums[i][j] = count++;
            }

            // 更新起始点，进入下一圈
            startX++;
            startY++;
            // 更新偏移量
            offset++;
            // 更新圈数
            loop++;
        }

        if (n % 2 == 1) {
            // 如果 n 为奇数，单独处理矩阵中心的值
            nums[startX][startY] = count;
        }

        return nums;
    }
}