Leetcode:209.长度最小的子数组 && 977.有序数组的平方 && 59.螺旋矩阵ll

209.长度最小的子数组

题目

给定一个含有 n 个正整数的数组和一个正整数 target 。
找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, …, numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。
来源：力扣（LeetCode）
链接：长度最小的子数组

滑动窗口（队列相加）

• 数组元素进行入队操作
• 当入队的数组元素总和sum >= 设定值“target”时，进行最前头数组的出队操作
• 直到窗口（队列）中数组总和是最小的子数组，并且 >= 设定值“target”
  
• 时间复杂度：O(n)
• 空间复杂度：O(1)

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int left = 0;
        int sum = 0;
        int res = Integer.MAX_VALUE;
        // 遍历数组
        for(int right = 0; right < nums.length; right++){
            // 数组相加
            sum += nums[right];
            // 当数组累加的值 >= 目标值时，获取累加数值的个数
            while(sum >= target){
                res = Math.min(res, right - left + 1);
                // 减去最开始遍历的第一个元素，确保可以找到最小的连续子数组
                sum -= nums[left++];
            }
        }
        return res == Integer.MAX_VALUE ? 0 : res;
    }
}

977.有序数组的平方

题目

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

来源：力扣（LeetCode）
链接：有序数组的平方

直接排序（平方后再排序，简单直接）

• 时间复杂度：O(nlogn)
• 空间复杂度：O(logn)

class Solution {
    public int[] sortedSquares(int[] nums) {
        //创建新数组
        int[] ans = new int[nums.length];
        for(int i = 0; i < nums.length; i++){
            //将每个值进行平方
            ans[i] = nums[i] * nums[i];
        }
        //排序
        Arrays.sort(ans);
        return ans;
    }
}

双指针法（数组有负数的情况下，一分为二再排序，没有负数也能用）

思路

将nums数组一分为二，分为正负两组，两组之间相互按照判定方法排序

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

class Solution {
    public int[] sortedSquares(int[] nums) {
        //数组长度
        int n = nums.length;
        //数组1
        int first = -1;
        //循环，将nums数组中的负数值，分到first
        for(int i = 0; i < n; i++){
            if(nums[i] < 0){
                first = i;
            }else{
                break;
            }
        }

        //创建新的数组
        int[] ans = new int[n];
        //定义新数组的下标值
        int index = 0;
        //“i”为负数数组
        int i = first;
        //“j”为正数数组
        int j = first + 1;
        while(i >= 0 || j < n){
            if(i < 0){ //当i<0时，代表负数组已经全部输出完
                ans[index] = nums[j] * nums[j];
                ++j;
            }else if(j == n){ //当j==n时，代表正数组全部输出完
                ans[index] = nums[i] * nums[i];
                --i;
            }else if(nums[i] * nums[i] < nums[j] * nums[j]){//i与j进行判定，判定成功，输出平方值i
                ans[index] = nums[i] * nums[i];
                --i;
            }else{ //>=的情况下，输出平方值j
                ans[index] = nums[j] * nums[j];
                ++j;
            }
            //增加ans数组的下标值
            ++index;
        }
        return ans;
    }
}

首尾双指针法（首尾两头交替排序）

思路

在数组首尾两头添加指针，交替比大小排序，在新数组中通过逆序的方式添加平方后的值（个人感觉，比双指针法一更好理解）

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

class Solution {
    public int[] sortedSquares(int[] nums) {
        int left = 0;
        int right = nums.length - 1;
        int index = nums.length - 1;
        int[] res = new int[nums.length];
        while(left <= right){
            if(nums[left] * nums[left] > nums[right] * nums[right]){
                // 在res数组的末尾插入平方后的最大元素，并将下标位置+1
                res[index--] = nums[left] * nums[left++];
            }else{
                // 同上，right在数组末尾，所以-1
                res[index--] = nums[right] * nums[right--];
            }
        }
        return res;
    }
}

59.螺旋矩阵ll

题目

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

来源：力扣（LeetCode）
链接：螺旋矩阵ll

思路

• 从左到右填充行
• 从上到下填充列
• 从右到左填充行
• 从下到上填充列
  

解法

• 时间复杂度 O(n^2)
• 空间复杂度 O(1)

class Solution {
    public int[][] generateMatrix(int n) {
        // 循环次数
        int loop = 0;
        int[][] res = new int[n][n];
        // 填充数字
        int num = 1;
        // 每次循环的开始点
        int start = 0;
        int i, j;

        while(loop++ < n / 2){
            // 第1行的左 -> 右
            for(j = start; j < n - loop; j++){
                res[start][j] = num++;
            }
            // 第n列的上 -> 下
            for(i = start; i < n - loop; i++){
                res[i][j] = num++;
            }
            // 第n行的右 -> 左
            for(; j >= loop; j--){
                res[i][j] = num++;
            }
            // 第1列的下 -> 上
            for(; i >= loop; i--){
                res[i][j] = num++;
            }
            start++;
        }
        if(n % 2 == 1) res[start][start] = num;
        return res;
    }
}