代码随想录算法训练营第二天| 977.有序数组的平方、 209.长度最小的子数组、 209.长度最小的子数组

977. 有序数组的平方

参考文档：代码随想录
参考视频：双指针法经典题目 | LeetCode：977.有序数组的平方_哔哩哔哩_bilibili

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

思路：双指针思想，数组为非递减顺序，故数组元素取平方后，最大值只可能存在左右最外侧，所已可以设置两个指针，分别指向左右两侧，创建一个新数组，对左右指针所指向的元素平方后做比较，将大的元素放在新数组最右端，left <= right为循环终止条件。

完整代码(java)

package leetcode2;

import java.util.Arrays;

/**
 * @description:
 * @author: lxc
 * @date: 2023/7/5 0:10
 */
public class Question977 {

    public static void main(String[] args) {

        int[] nums = new int[]{-7,-3,2,3,11};
        int[] result = sortedSquares2(nums);
        System.out.println(Arrays.toString(result));
    }

    // 暴力解法
    public static int[] sortedSquares(int[] nums){

        for (int i = 0; i < nums.length; i++) {
            nums[i] *= nums[i];
        }
        Arrays.sort(nums);
        return nums;
    }

    // 双指针法
    public static int[] sortedSquares2(int[] nums){

        int[] result = new int[nums.length];
        int left = 0;
        int right = result.length - 1;
        int index = nums.length - 1;

        while (left <= right){

            if (nums[left] * nums[left] > nums[right] * nums[right]){
                result[index] = nums[left] * nums[left];
                left++;
                index--;
            }else {
                result[index] = nums[right] * nums[right];
                right--;
                index--;
            }
        }
        return result;
    }
}

209. 长度最小的子数组

参考文档：代码随想录
参考视频：拿下滑动窗口！ | LeetCode 209 长度最小的子数组_哔哩哔哩_bilibili

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

提示：

1 <= target <= 109
1 <= nums.length <= 105
1 <= nums[i] <= 105

思路: 暴力解法时间复杂度为O(n^2)，可以使用滑动窗口，其本质仍是双指针法，通过使用两个指针来达到使用一个for循环得出结果的目的，for循环用来表示中的指针用来表示滑动窗口的结束位置，窗口内是满足里面和>= target的最小长度数组，当窗口里面和< target时，右指针往右移，直到窗口内数组和>= target，进入while循环，左指针向前移，直至窗口里面和< target时，跳出while循环，while循环中，比较length大小，获取最小的那个length，如此移动，最终获取到结果。时间复杂度为O(n)

完整代码(java) 

package leetcode2;

/**
 * @description:
 * @author: lxc
 * @date: 2023/7/5 23:17
 */
public class Question209 {

    public static void main(String[] args) {

        int[] nums = new int[]{2,3,1,2,4,3};
        int val = 7;
        int result = minSubArrayLen(val,nums);

        System.out.println(result);
    }

     // 滑动窗口
    private static int minSubArrayLen(int s, int[] nums) {

        int result = Integer.MAX_VALUE;
        int sum = 0;
        int j = 0;
        int length = 0;

        for (int i = 0; i < nums.length; i++) {

            sum += nums[i];

            while (sum >= s){
                length = i - j + 1;
                result = result < length ? result : length;
                sum -= nums[j++];
            }
        }

        return result == Integer.MAX_VALUE ? 0 : result;
    }
}

 59. 螺旋矩阵 II

参考文档：代码随想录
参考视频：一入循环深似海 | LeetCode：59.螺旋矩阵II_哔哩哔哩_bilibili

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

思路：画四条边的时候统一用左闭右开或者右闭左开。画的圈数和n的大小有关，n / 2获取的值即为需画的圈数，故以loop++ < n /2 为循环结束条件。顺时针画矩阵，用start表示每一圈的起始位置，根据左闭右开或者右闭左开原则画每一条边，如果n为奇数，则中间这个点特殊处理。

完整代码(java)

package leetcode2;

import java.util.Arrays;

/**
 * @description:
 * @author: lxc
 * @date: 2023/7/8 10:58
 */
public class Question59 {

    public static void main(String[] args) {

        int n  = 4;
        int[][] ints = generateMatrix(n);
        System.out.println(Arrays.deepToString(ints));
    }

    // 螺旋矩阵
    private static int[][] generateMatrix(int n){

        int[][] result = new int[n][n];
        int loop = 0;
        int start = 0;
        int count = 1;
        int i;
        int j;

        // 采用左闭右开原则，循环结束的边界条件为 loop < n / 2
        while (loop++ < n / 2){

            // 上侧从左到右赋值(左闭右开)
            for(j = start; j < n - loop; j++){
                result[start][j] = count++;
            }
            // 右侧从上到下赋值(左闭右开)
            for (i = start; i < n - loop ; i++) {
                result[i][j] = count++;
            }
            // 下侧从右到左(左闭右开)
            for (; j >= loop; j--){
                result[i][j] = count++;
            }
            // 左侧从下到上(左闭右开)
            for (; i >= loop; i--){
                result[i][j] = count++;
            }

            start++;
        }

        if (n % 2 != 0){
            result[start][start] = count;
        }

        return result;
    }
}