有序数组的平方

题目

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

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

暴力排序

class Solution {
　　public int[] sortedSquares(int[] nums) {
　　　　int[] ans = new int[nums.length];
　　　　for (int i = 0; i < nums.length; ++i) {
　　　　　　ans[i] = nums[i] * nums[i];
　　　　}
　　　　Arrays.sort(ans);
　　　　return ans;
　　}
}

• 时间复杂度：O(nlogn)，其中 n 是数组 nums 的长度。
• 空间复杂度：O(logn)。除了存储答案的数组以外，我们需要 O(logn) 的栈空间进行排序。

双指针法

数组平方的最大值就在数组的两端，不是最左边就是最右边，不可能是中间。所以两个指针指向数组两端，根据他们平方和的大小依次将值由后到前赋给新数组，然后返回新数组。

class Solution {
    public int[] sortedSquares(int[] nums) {
        int right = nums.length - 1;
        int left = 0;
        int[] result = new int[nums.length];
        int index = result.length - 1;
        while (left <= right) {
            if (nums[left] * nums[left] > nums[right] * nums[right]) {
                // 正数的相对位置是不变的， 需要调整的是负数平方后的相对位置
                result[index--] = nums[left] * nums[left];
                ++left;
            } else {
                result[index--] = nums[right] * nums[right];
                --right;
            }
        }
        return result;
    }
}

• 时间复杂度：O(n)，其中 nn 是数组 nums 的长度。
• 空间复杂度：O(1)。除了存储答案的数组以外，我们只需要维护常量空间。

长度最小的子数组

题目

给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

示例：
输入：s = 7, nums = [2,3,1,2,4,3] 输出：2 解释：子数组 [4,3] 是该条件下的长度最小的子数组。

暴力解法

class Solution {
    public int minSubArrayLen(int s, int[] nums) {
        int n = nums.length;
        if (n == 0) {
            return 0;
        }
        int ans = Integer.MAX_VALUE;
        for (int i = 0; i < n; i++) {
            int sum = 0;
            for (int j = i; j < n; j++) {
                sum += nums[j];
                if (sum >= s) {
                    ans = Math.min(ans, j - i + 1);
                    break;
                }
            }
        }
        return ans == Integer.MAX_VALUE ? 0 : ans;
    }
}

• 时间复杂度：O(n^2)
• 空间复杂度：O(1)

滑动窗口法

滑动窗口，就是不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。
若其实索引选择窗口的起始位置，则需要另一个循环来遍历它的终止位置，因此其实索引选择窗口的终止位置。
首先不断增加终止索引（right）直到总会大于目标值，然后再将启示索引右移移缩小窗口。

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 (sum >= s) {
                result = Math.min(result, right - left + 1);
                sum -= nums[left++];
            }
        }
        return result == Integer.MAX_VALUE ? 0 : result;
    }
}

while循环中，每个元素只是一进一出，没有其他操作，所以操作次数永远是2，故总的时间复杂度为2n。

• 时间复杂度：O(n)
• 空间复杂度：O(1)

螺旋矩阵II

题目

示例: 输入: 3 输出: [ [ 1, 2, 3 ], [ 8, 9, 4 ], [ 7, 6, 5 ] ]

思路

本题考查对边界条件的把握，需要坚持循环不变量原则，此处可以选择每条边都是左闭右开的情况即每行（或列）最后一个元素为下一条线的起始点。

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开始。n每增加2循环增加一圈
            // 模拟上侧从左到右
            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) {//对于n为奇数的情况需要填充中间点
            res[start][start] = count;
        }

        return res;
    }
}

数组总结