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

LeetCode 977.有序数组的平方

题目链接：https://leetcode.cn/problems/squares-of-a-sorted-array/

思路：设计左右指针分别指向数组首位，由于输出数值由小到大排列的数组，开辟一个新的数组空间，从尾部开始存放数据。当查询到原数组right对应位置数值的平方小于left对应位置数值的平方时，将left对应位置数值元素的平方存入新数组内，同时left向后移动；否则将right对应位置数值元素的平方存入新数组内，同时right向前移动。

代码：

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

LeetCode 209.长度最小的子数组

题目链接：https://leetcode.cn/problems/minimum-size-subarray-sum/

思路1：暴力法实现。新开辟长度数组空间array存放原数组下标start对应满足条件的子数组的长度，枚举数组 nums中的每个下标作为子数组的开始下标start，对于每个开始下标start，需要找到大于或等于start的最小结束下标end，使得从 nums[start]到 nums[end]的元素和大于或等于 target，若end越过nums空间，则未找到满足条件的子数组，并将array对应start位置赋0,；否则找到满足条件的子数组，并将该子数组的最小长度（end−start+1）存放在新开辟的长度数组空间array内；最后遍历该数组找到最小结果。

代码1：

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int windowLen = 0;
        int end=0;
        int sum=0;
        int result;
        int[] array = new int[nums.length];
        int array_zero =1;         
        for(int start = 0; start <= nums.length-1; start++){
            sum = nums[start];
            end = start;
            while(sum < target && end < nums.length-1){
                end++;
                sum = sum + nums[end];
            }
            if(sum >= target){
                windowLen = end - start + 1;
                array[start] = windowLen;
            }
            else{
                windowLen = 0;
                array[start] = 0;
            }
        }

        for(int i = 0; i<= array.length-1; i++)
            if(array[i]!=0)
                array_zero = 0;
                
        if(array_zero ==1)
            result = 0;
        else{
            result = array.length;
            for(int i =0; i<= array.length-1; i++){
                System.out.print(array[i]);
                if(result > array[i] && array[i] != 0)
                    result = array[i];
            }

        }
        return result;
    }
}

思路2：利用滑动窗口思想实现，时间复杂度O(n)，空间复杂度O(1)。

代码2：

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int left = 0;
        int right = 0;
        int sum = 0;
        int res = Integer.MAX_VALUE;
        while(right < nums.length) {
            int num1 = nums[right];
            right++;
            sum += num1;
            // 代码的关键就在这里，如何判定什么时候窗口左指针需要收缩
            // 仅当窗口内的和大于等于target时
            while(sum>=target) {
                int num2 = nums[left];
                sum -= num2;
                // 先将最小res求出来
                res = Math.min(res, right - left);
                // 再更新左指针
                left++;
            }
        }
        // 此处防止没有结果的可能
        return res == Integer.MAX_VALUE ? 0 : res;
    }
}

LeetCode 59.螺旋矩阵II

题目链接：https://leetcode.cn/problems/spiral-matrix-ii/

思路：模拟顺时针画矩阵：1）定义right指针，实现从左到右填充；2）定义down指针，实现从上到下填充；3）定义left指针，实现从右到左填充；4）定义up指针，实现从下到上填充。在填充过程中遵循“左闭右开”原则，即：

另需注意，若n为偶数，矩阵不存在中间单独位置，需做n/2次填充循环；相反，若n为奇数，矩阵存在中间单独位置，需给该位置单独赋值，同时做n/2次填充循环。

代码：

class Solution {
    public int[][] generateMatrix(int n) {
        int[][] matrix = new int[n][n];
        int loop = 0;
        int up = n-1;
        int down = 0;
        int left = n-1;
        int right =0;
        int num = 1;
        loop = n%2!=0 ? n/2+1 : n/2;
        for(int i = 0; i < loop; i++){
            right = i;
            down = i;
            left = n-1-i;
            up = n-1-i;
            while(right < n-1-i && matrix[i][right]==0){
                matrix[i][right] = num;
                num++;
                right++;
            }
            while(down < n-1-i && matrix[down][right]==0){
                matrix[down][right] = num;
                num++;
                down++;
            }
            while(left > i && matrix[down][left]==0){
                matrix[down][left] = num;
                num++;
                left--;
            }
            while(up > i && matrix[up][left]==0){
                matrix[up][left] = num;
                num++;
                up--;
            }
        } 
        if(n%2 != 0)
            matrix[n/2][n/2]=num;
        return matrix;
    }
}