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

最新推荐文章于 2024-07-20 09:51:47 发布

五十弦乐

最新推荐文章于 2024-07-20 09:51:47 发布

阅读量15

点赞数

文章标签：算法矩阵 java

本文链接：https://blog.csdn.net/ThouI/article/details/134760366

版权

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

今日收获：

复习了双指针的滑动使用以及强化了边界定义问题，在边界上应该先决定是左闭右开还是左闭右闭，决定后的程序编写过程就会更加清晰。

今日用时：1hour10min
今日一言：begin again

有序数组的平方（977,easy）

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

看见题目的想法：

前后双指针滑动、暴力分步

看完代码随想录的想法：

相同

自我实现

//时间复杂度：O(n)
//空间复杂度：O(n)
public int[] sortedSquares(int[] nums) {
        int point_left = 0;
        int point_right = nums.length-1;
        int[] squareNums = new int[nums.length];
        for (int i = 0; i < nums.length; i++) {
            int temp_LeftSquNum = nums[point_left]*nums[point_left];
            int temp_RightSquNum = nums[point_right]*nums[point_right];
            if (temp_LeftSquNum>temp_RightSquNum){
                squareNums[nums.length-1-i] = temp_LeftSquNum;
                point_left++;
            }else {
                squareNums[nums.length-1-i] = temp_RightSquNum;
                point_right--;
            }

        }
        return squareNums;
    }

长度最小的子数组（209,medium）

给定一个含有 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

看见题目的想法：

双指针滑动（快慢指针）,时间复杂度O(n)、空间复杂度O(1) ；暴力求解，时间复杂度O(n^2)、空间复杂度O(1)

看完代码随想录的想法：

需要注意！不要以为for里放一个while就以为是O(n^2)啊，主要是看每一个元素被操作的次数，每个元素在滑动窗后进来操作一次，出去操作一次，每个元素都是被操作两次，所以时间复杂度是 2 × n 也就是O(n)。

自我实现

//时间复杂度：O(n)
//空间复杂度：O(1)
public int minSubArrayLen(int target, int[] nums) {
            int point_slow = 0;
            int point_fast = 0;
            int tempSum = 0;
            int SumMinLen = Integer.MAX_VALUE;
            while (point_fast < nums.length) {
                tempSum += nums[point_fast];
                point_fast++;
                while (tempSum >= target) {
                    SumMinLen = SumMinLen < (point_fast - point_slow) ? SumMinLen : (point_fast - point_slow);
                    tempSum -= nums[point_slow];
                    point_slow = point_slow + 1;
                }

            }
            if (SumMinLen == Integer.MAX_VALUE){
                return 0;
            }
            return SumMinLen;
        }

螺旋矩阵II（59,xxx）

给你一个正整数 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

看见题目的想法：模拟移动，移动是规律的右下左上右…，控制边界掌握开闭定义清晰即可

看完代码随想录的想法：简单很多，但是一下想不到

自我实现

//时间复杂度：O(n^2)
//空间复杂度：O(n^2)
public int[][] generateMatrix(int n) {
            int[][] matrix = new int[n][n];
            int left_side = 0;
            int right_side = n - 1;
            int floor_side = n - 1;
            int ceiling_side = 0;
            int i = 0, j = 0;// i 纵向; j横向
            int movingState = 0;// 0右 1下 2左 3上
            for (int num = 1; num <= n * n; ) {
                //右->下
                if (movingState == 0) {
                    // 碰壁
                    if (j > right_side) {
                        movingState = 1;
                        ceiling_side += 1;
                        j--;
                        i++;
                        // 未碰壁
                    } else {
                        matrix[i][j] = num++;
                        j++;
                    }
                    continue;
                }

                //下->左
                if (movingState == 1) {
                    // 碰壁
                    if (i > floor_side) {

                        movingState = 2;
                        right_side -= 1;
                        i--;
                        j--;
                        // 未碰壁
                    } else {
                        matrix[i][j] = num++;
                        i++;
                    }
                    continue;
                }

                //左->上
                if (movingState == 2) {
                    // 碰壁
                    if (j < left_side) {
                        floor_side -= 1;
                        movingState = 3;
                        j++;
                        i--;
                        // 未碰壁
                    } else {
                        matrix[i][j] = num++;
                        j--;
                    }
                    continue;
                }

                //上->右
                if (movingState == 3) {
                    // 碰壁
                    if (i < ceiling_side) {
                        i++;
                        j++;
                        left_side += 1;
                        movingState = 0;
                        // 未碰壁
                    } else {
                        matrix[i][j] = num++;
                        i--;
                    }
                    continue;
                }
            }
            return matrix;
        }

(代码随想录实现)

public int[][] generateMatrix(int n) {
        int loop = 0;  // 控制循环次数
        int[][] res = new int[n][n];
        int start = 0;  // 每次循环的开始点(start, start)
        int count = 1;  // 定义填充数字
        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++;
            }

            // 模拟左侧从下到上
            for (; i >= loop; i--) {
                res[i][j] = count++;
            }
            start++;
        }

        if (n % 2 == 1) {
            res[start][start] = count;
        }

        return res;
    }

数组专题总结

数组是存放在连续内存空间上的相同类型数据的集合。

数组下标都是从0开始的。
数组内存空间的地址是连续的。

数组的元素是不能删的，只能覆盖

那么二维数组在内存的空间地址是连续的么？

例如： int[][] rating = new int[3][4]; ，这个二维数组在内存空间可不是一个 3*4 的连续地址空间

Java的二维数组在内存中不是 3*4 的连续地址空间，而是四条连续的地址空间组成！

都是从0开始的。**

数组内存空间的地址是连续的。

数组的元素是不能删的，只能覆盖

那么二维数组在内存的空间地址是连续的么？

例如： int[][] rating = new int[3][4]; ，这个二维数组在内存空间可不是一个 3*4 的连续地址空间

[外链图片转存中…(img-Q1fMWXwv-1701537438418)]

Java的二维数组在内存中不是 3*4 的连续地址空间，而是四条连续的地址空间组成！

[外链图片转存中…(img-HUmW5y7r-1701537438419)]

五十弦乐

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
代码随想录算法训练营第2天|977.有序数组的平方，209.长度最小的子数组，59.螺旋矩阵II| Java☕

数组是存放在连续内存空间上的相同类型数据的集合。数组下标都是从0开始的。数组内存空间的地址是连续的。数组的元素是不能删的，只能覆盖那么二维数组在内存的空间地址是连续的么？例如：，这个二维数组在内存空间可不是一个3*4的连续地址空间Java的二维数组在内存中不是3*4的连续地址空间，而是四条连续的地址空间组成！都是从0开始的。**数组内存空间的地址是连续的。数组的元素是不能删的，只能覆盖那么二维数组在内存的空间地址是连续的么？例如：，这个二维数组在内存空间可不是一个3*4的连续地址空间。
复制链接

扫一扫