代码随想录day02| 977. 有序数组的平方、209. 长度最小的子数组、59. 螺旋矩阵 II

leetcode977. 有序数组的平方

注意：×

1. 不要自作聪明省空间，要创建新的数组往里面填即可
2. 不要省一个下标的变量，加个新的变量很省事也不出错

public int[] sortedSquares(int[] nums) {
        int left = 0;
        int right = nums.length - 1;
        int arr_index = nums.length - 1;//  用于暂时存储数组的元素
        int[] arr = new int[nums.length];

        while (left <= right) {
            if (Math.abs(nums[left]) > Math.abs(nums[right])){
                arr[arr_index] = nums[left]*nums[left];
                arr_index--;
                left++;
            }else {
                arr[arr_index] = nums[right]*nums[right];
                arr_index--;
                right--;
            }
        }

        return arr;
    }

leetcode209. 长度最小的子数组

注意：√

1. 注意增窗口和收窗口的条件，在这个题目中收窗口可以等于target
2. 注意while循环刚刚开始的时候total和right的处理操作
3. 再记忆一下模板

// 引用Labuladong的算法框架，欢迎大家去看哦，很棒的算法博主

/* 滑动窗口算法框架 */
void slidingWindow(String s) {
    // 用合适的数据结构记录窗口中的数据
    HashMap<Character, Integer> window = new HashMap<>();

    int left = 0, right = 0;
    while (right < s.length()) {
        // c 是将移入窗口的字符
        char c = s.charAt(right);
        window.put(c, window.getOrDefault(c, 0) + 1);
        // 增大窗口
        right++;
        // 进行窗口内数据的一系列更新
        ...

        /*** debug 输出的位置 ***/
        // 注意在最终的解法代码中不要 print
        // 因为 IO 操作很耗时，可能导致超时
        System.out.printf("window: [%d, %d)\n", left, right);
        /********************/

        // 判断左侧窗口是否要收缩
        while (left < right && window needs shrink) {
            // d 是将移出窗口的字符
            char d = s.charAt(left);
            window.put(d, window.get(d) - 1);
            // 缩小窗口
            left++;
            // 进行窗口内数据的一系列更新
            ...
        }
    }
}

public int minSubArrayLen(int target, int[] nums) {
        int left = 0;
        int right = 0;
        int total = 0; // 初始化为数组的最左边元素值
        int minLen = Integer.MAX_VALUE;

        while (right < nums.length) {
            // 开始搞事情
            total = total + nums[right];
            right++;

            // 开始收缩
            while (total >= target) {
                if (minLen > (right-left)){
                    minLen = right-left;
                }
                total = total - nums[left];
                left++;
            }

        }

        return minLen == Integer.MAX_VALUE?-1:minLen;
    }

Leetcode59. 螺旋矩阵 II

注意：×

1. 标准的解题思路型题目
2. 可以看一下链接Labuladong
3. 常看常新，复习差分数组等内容

    public int[][] generateMatrix(int n) {
    int[][] matrix = new int[n][n];
    int upper_bound = 0, lower_bound = n - 1;
    int left_bound = 0, right_bound = n - 1;
    // 需要填入矩阵的数字
    int num = 1;
    
    while (num <= n * n) {
        if (upper_bound <= lower_bound) {
            // 在顶部从左向右遍历
            for (int j = left_bound; j <= right_bound; j++) {
                matrix[upper_bound][j] = num++;
            }
            // 上边界下移
            upper_bound++;
        }
        
        if (left_bound <= right_bound) {
            // 在右侧从上向下遍历
            for (int i = upper_bound; i <= lower_bound; i++) {
                matrix[i][right_bound] = num++;
            }
            // 右边界左移
            right_bound--;
        }
        
        if (upper_bound <= lower_bound) {
            // 在底部从右向左遍历
            for (int j = right_bound; j >= left_bound; j--) {
                matrix[lower_bound][j] = num++;
            }
            // 下边界上移
            lower_bound--;
        }
        
        if (left_bound <= right_bound) {
            // 在左侧从下向上遍历
            for (int i = lower_bound; i >= upper_bound; i--) {
                matrix[i][left_bound] = num++;
            }
            // 左边界右移
            left_bound++;
        }
    }
    return matrix;
}