day02 977. 有序数组的平方 ​ 209. 长度最小的子数组​ 59. 螺旋矩阵 II

文档讲解：代码随想录（代码随想录）

完成状态:  文档持续更新中，未能完善文档

977. 有序数组的平方

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

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]

思路：

        观察数据的规律 ，平方后最大的只会出现在数组两端，每一轮循环结束，仍然保有这个特性，最大值仍然出现在数组两端。

报错原因，这里应该是if else语句，只执行一条，而不是两个if。当输入的数组长度为1时，虽然不会执行第二个if语句，但是代码仍然会去判断if中的条件语句，此时left由于上面的if语句取值为1，此时报错数组越界。

严格代码逻辑书写。 

        while(left <= right){
            if(nums[left] * nums[left] >= nums[right] * nums[right]){
                result[i--] = nums[left] * nums[left];
                left++;
            }

            if(nums[left] * nums[left] < nums[right] * nums[right]){
                result[i--] = nums[right] * nums[right];
                right--;
            }

class Solution {
    public int[] sortedSquares(int[] nums) {
        int[] result = new int[nums.length];
        int i = nums.length - 1;

        int left = 0, right = nums.length - 1;

        //双向指针法 每次比较较大的那个数放入结果数组，且指向较大的元素的指针向中间移动
        while(left <= right){
            if(nums[left] * nums[left] >= nums[right] * nums[right]){
                result[i--] = nums[left] * nums[left];
                left++;
            }else{
                result[i--] = nums[right] * nums[right];
                right--;
            }
        }
        return result;
    }
}

 209. 长度最小的子数组

暴力求解法 

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int count = nums.length + 1;
        // 暴力解法
        for(int i = 0; i < nums.length; i++){
            int sum = 0;
            for(int j = i; j < nums.length; j++){
                sum = sum + nums[j];
                if(sum >= target){
                    int temp = j - i + 1;
                    if(temp < count){
                        count = temp;
                        break;
                    }
                }
            }
        }

        if(count == nums.length + 1){
            return 0;
        }else{
            return count;
        }
    }
}

滑动窗口法：

class Solution {

    // 滑动窗口
    public int minSubArrayLen(int s, int[] nums) {
        int left = 0;
        int sum = 0;
        int result = Integer.MAX_VALUE;
        for (int right = 0; right < nums.length; right++) {
            sum += nums[right];
            // 注意这里使用while，每次更新 i（起始位置），并不断比较子序列是否符合条件
            while (sum >= s) {
                result = Math.min(result, right - left + 1);
                // 这里体现出滑动窗口的精髓之处，不断变更i（子序列的起始位置）
                sum -= nums[left++];
            }
        }
        return result == Integer.MAX_VALUE ? 0 : result;
    }
}

59. 螺旋矩阵 II

对于旋转时候的边界掌握仍然差点火候。

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

        while (loop++ < n / 2) { // 判断边界后，loop从1开始
            // 模拟上侧从左到右
            for (j = start; j < n - loop; j++) {
                res[start][j] = count++;
            }

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

            // 模拟下侧从右到左
            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;
    }
}