训练营第二天

第一题

leetcode.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）
链接：https://leetcode.cn/problems/squares-of-a-sorted-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

源代码：

public int[] sortedSquares(int[] nums){
        int count = 0;//负数的计数器
        int len = nums.length - 1;
        //统计负数出现的次数
        for (int i = 0; i <= len; i++) {
            if (nums[i] < 0){
                count++;
            } else {
                break;
            }
        }
		//将数组进行平方处理
        for (int i = 0; i <= len; i++) {
            int tmep = nums[i];
            nums[i] = tmep * tmep;
        }

		//减少处理的次数，如果不存在负数，则直接原数组返回，否则创建新数组
        if (count > 0){
            int left = 0,right = len;
            int [] res = new int[len + 1];
            int i = len;
            //一左一右向中间遍历，进行比较，较大的值放入新的数组，并且移动
            while (left <= right){
                if (nums[left] > nums[right]){
                    res[i--] = nums[left];
                    left++;
                } else {
                    res[i--] = nums[right];
                    right--;
                }
            }
            return res;
        } else {
            return nums;
        }
    }

• 关键点在于，使用left和right向中间遍历，并且判断每次遍历到的值，然后放入新数组。

第二题

leetcode.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）
链接：https://leetcode.cn/problems/minimum-size-subarray-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

源代码：

 public int minSubArrayLen(int target, int[] nums) {
        int minSetp = Integer.MAX_VALUE;//定义一个起始值
        int len = nums.length - 1;//数组长度
        int sum = 0;//定义一个和
        int left, right;//左右边界
        //遍历数组，使用while也行
        for (right = 0, left = 0; right <= len; ) {
            sum += nums[right];//加上右边界
            //如果满足 >=的条件，则一直在范围内移动左边界，逼近右边界
            while (sum >= target) {
                 minSetp = Math.min(minSetp, right - left + 1);//计算此时左右边界内元素的个数
                sum -= nums[left];//边界移动，窗口内的值也需要对应缩小
                left++;//移动左边界
            }
            right++;//移动右边界
        }
        return minSetp == Integer.MAX_VALUE ? 0 : minSetp;//如果值没有变，说明不存在，则返回0.
    }

• 关键点在于窗口大小的变换，首先我们在sum的值一直小于target目标值的时候，一直扩大窗口的范围，当大于target目标值的时候，我们就缩小窗口的边界，左边界向右移动并且缩小窗口内的sum和，直到sum和小于target,这时候，又扩大窗口的范围，右边界向右移动，直到又出现大于目标值的场景，最后结束的条件就是右边界到数组边界了

第三题

leetcode.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）
链接：https://leetcode.cn/problems/spiral-matrix-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

public int[][] genrateMatrix(int n) {
        int[][] res = new int[n][n];
        int loop = 0;//循环控制次数
        int count = 1;//计数器
        int start = 0;//定义开始点
        int i, j;

        while (loop++ < n / 2) {
        
            //从左到右
            for (j = start;j < n - loop;j++){
                res[start][j] = count++;
            }

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

            //从右到左，起始就是按照前面的规律进行处理。i的位置就是前面处理过后的那个位置，不需要移动，只需要改变y就可以，移动的次数，从现有的j，到循环的圈数。
            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;
    }

• 关键点在于我们需要确认区间的边界值，保持一个规则，进行模拟处理，顺时针一圈一圈的处理。还有一种方案是定义四个变量，分别表示上下左右的四个边界值。仅供参考。