【代码随想录训练营】Day2-数组

代码随想录 Day2

今日任务

977.有序数组的平方
209.长度最小的子数组
59.螺旋矩阵Ⅱ
语言：Java

977. 有序数组的平方

考点：双指针
链接：https://leetcode.cn/problems/squares-of-a-sorted-array/
注意事项：对于非递减排序的数组来说，平方后的最大值只能在两边取得，最小值在中间取得，在移动指针过程中left和right不要忘记调整

class Solution {
    public int[] sortedSquares(int[] nums) {
        int left = 0;
        int right = nums.length - 1;
        int[] result = new int[nums.length];
        for(int i = nums.length - 1; i>= 0;){
            if(nums[left] * nums[left] < nums[right] * nums[right]){
                result[i--] = nums[right] * nums[right];
                right--;
            }
            else if(nums[left] * nums[left] > nums[right] * nums[right]){
                result[i--] = nums[left] * nums[left];
                left++;
            }
            else{
                result[i--] = nums[left] * nums[left];
                left++;
                if(i >= 0){
                    result[i--] = nums[right] * nums[right];
                    right--;
                }
            }
        }
        return result;
    }
}

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

209. 长度最小的子数组

考点：滑动窗口
链接：https://leetcode.cn/problems/minimum-size-subarray-sum/
注意事项：right++的位置，我们在计算出每轮循环right所在位置的length之前，都不可以移动right

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int left = 0;
        int right = 0;
        int sum = 0;
        int length = 100001;
        while(right < nums.length){
            sum += nums[right];
            if(sum >= target){
                while(sum >= target){
                    length = Math.min(length, right - left + 1);
                    sum -= nums[left];
                    left++;
                }
            }
            right++;
        }
        if(length != 100001){
            return length;
        }
        else{
            return 0;
        }
    }
}

时间复杂度：O(N)
空间复杂度：O(1)

59. 螺旋矩阵Ⅱ

考点：矩阵模拟
链接：https://leetcode.cn/problems/spiral-matrix-ii/
注意事项：考虑清楚要循环几次，每次循环的时候左右边界和上下边界都定到哪里
改进：循环终止条件用循环次数判断更好

class Solution {
    public int[][] generateMatrix(int n) {
        int[][]result = new int[n][n];
        int left = 0;
        int right = n - 1;
        int up = 0;
        int down = n - 1;
        int count = 0;
        //int loop = 0;
        //while(loop++ < n / 2)
        //while不能用loop--判断，会出现语法错误（不能将int转为bool）
        while(left <= right){
            for(int j = left; j < right; j++){
                count++;
                result[up][j] = count;
            }
            for(int i = up; i < down; i++){
                count++;
                result[i][right] = count;
            }
            for(int j = right; j > left; j--){
                count++;
                result[down][j] = count;
            }
            for(int i = down; i > up; i--){
                count++;
                result[i][left] = count;
            }
            left++;
            right--;
            up++;
            down--;
        }
        if(n % 2 == 1){
            result[n / 2][n / 2] = n * n;
        }
        return result;
    }
}

时间复杂度：O(N^2)
空间复杂度：O(N^2)