LeetCode:#### 977. 有序数组的平方

1.思路

暴力解法！！！

双指针法+创建新数组，原数组上操作容易出问题

2.代码实现

// 暴力解法
class Solution {
    public int[] sortedSquares(int[] nums) {
        for (int i = 0; i < nums.length; i++) {
            nums[i] = nums[i] * nums[i];
        }
        Arrays.sort(nums);
        return nums;
    }
}
// 双指针法
class Solution {
    public int[] sortedSquares(int[] nums) {
        int left = 0;
        int right = nums.length - 1;
        int[] result = new int[nums.length];
        int index = result.length - 1;
        while (left <= right) {
            if (nums[right] * nums[right] >= nums[left] * nums[left]) {
                result[index--] = nums[right] * nums[right];
                right--;
            } else {    
                result[index--] = nums[left] * nums[left];
                left++;
            }
        }
        return result;
    }
}

3.复杂度分析

时间复杂度：O(n).

空间复杂度：O(n).

LeetCode:#### 209. 长度最小的子数组

1.思路

滑动窗口：定左移右，根据target调整区间，while循环是关键

2.代码实现

// 滑动窗口
class Solution {
    public int minSubArrayLen(int target, 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 (sum >= target) {
                result = Math.min(result, right - left + 1);
                sum -= nums[left];
                left++;
            }
        }
        // if (result == Integer.MAX_VALUE) {
        //     return 0;
        // } else {
        //     return result;
        // }
        return result == Integer.MAX_VALUE ? 0 : result;
    }
}

3.复杂度分析

时间复杂度：O(n)

空间复杂度：O(1)

LeetCode:#### [59. 螺旋矩阵 II]

(leetcode.cn/problems/sp…)

1.思路

循环模拟，处理区间，边界，循环次数，下一圈循环起点++，n为奇数时的独数赋值

2.代码实现

class Solution {
    public int[][] generateMatrix(int n) {
        int loop = 0;
        int start = 0;
        int[][] result = new int[n][n];
        int count = 1;
        int i, j;
        while (loop++ < n / 2) {
            // 上侧：从左向右
            for (j = start; j < n - loop; j++) {
                result[start][j] = count++;
            }

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

            // 下侧：从右向左
            for (; j >= loop; j--) {
                result[i][j] = count++;
            }

            // 左侧：从下向上
            for (; i >= loop; i--) {
                result[i][j] = count++;
            }
            start++; // 更新下一圈起点
        }
        if (n % 2 == 1) {
            result[start][start] = count;
        }
        return result;
    }
}

3.复杂度分析

时间复杂度：O(n^2).

空间复杂度：O(1).