day02 数组 | 977、有序数组的平方 209、长度最小的子数组 59、螺旋矩阵II

news2024/11/16 13:32:50

1、题目

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]

解法一：使用数组sort方法排序

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

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

解法二：使用

class Solution {
    public int[] sortedSquares(int[] nums) {
        // 1、定义指针
        int left = 0;
        int right = nums.length - 1;
        // 2、定义数组，数组长度等同于原数组，定义新数组下标
        int[] result = new int[nums.length];
        int index = nums.length -1;
        // 3、循环条件
        while(left <= right) {
            if(nums[left] * nums[left] < nums[right] * nums[right]) {
                // nums[right]平方值大,存放到result数组的index下标位置，index减1，同时将right前移
                result[index--] = nums[right] * nums[right];
                right--;
            }else {
            	// nums[left]平方值大,存放到result数组的index下标位置，index减1，同时将left后移 
                result[index--] = nums[left] * nums[left];
                left++;
            }
        }
        // 4、返回结果
        return result;
    }
}

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

209、长度最小的子数组

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

示例：

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

滑动窗口

滑动窗口可以理解为双指针法的一种。

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

滑动窗口的重点：确定窗口大小、更新窗口
left 和 right 确定窗口起始位置和结束位置

确定窗口大小：窗口起始位置 left 不变，窗口结束位置 right 向右移动，根据条件确认窗口的结束边界，确定窗口长度。
更新窗口：在确认窗口大小的基础上，窗口结束位置 right 不变，窗口开始位置 left 向右移动，再次确认窗口是否符合条件，记录最小的窗口长度。
同理，如果不符合条件，right 右移，再次判断是否符合条件。
总结：不满足条件 right 右移，满足条件 left 右移，记录符合条件的最小的窗口长度。

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        // 1、定义left记录左指针位置，sum记录总和，len记录符合条件的长度
        int left = 0, sum = 0;
        int len = 0;
        // 2、定义right记录右指针位置，以nums.length作为结束条件
        for(int right = 0; right < nums.length; right++) {
            // sum记录总和
            sum += nums[right];
            // 3、符合条件则进行判断
            while(sum >= target) {
                // 如果len为0，则直接赋值right - left + 1作为数组长度，否则返回len与当前right - left + 1小的值赋值给新的len
                len = (len == 0) ? right - left + 1 : Math.min(len, right - left + 1);
                // 计算除去left位置sum是否依然符合条件目标值，同时将left右移
                sum -= nums[left++];
            }
        }
        // 5、返回len，如果数组相加没有大于目标值，则len依然为0，反之记录符合条件的连续子数组的长度
        return len;
    }
}

59、螺旋矩阵II

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

示例:

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

本题目难点在于确认边界，需要有规律的边界

模拟顺时针画矩阵的过程：
填充上行从左到右
填充右列从上到下
填充下行从右到左
填充左列从下到上

在这里插入图片描述
选择左闭右开

class Solution {
    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;
    }
}