代码随想录算法跟练 | Day2 | 数组Part2

个人博客主页：http://myblog.nxx.nx.cn
代码GitHub地址：https://github.com/nx-xn2002/Data_Structure.git

Day2

双指针

977. 有序数组的平方

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

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

思路：
本题很容易想到第一种解法，暴力解法：即将数组所有元素依次平方之后进行排序。但是这样做的时间复杂度较高，因为多了一步排序操作，并且忽略了题目给出的有序数组的条件。
仔细观察题目，我们可以想到，一个数的平方就是一个数的绝对值的平方，一个数的绝对值越大，它的平方也就越大。再考虑到数组中可能存在负数，我们可以知道，有序数组内数组首尾的元素的平方相对来说应该大于数组中段元素的平方。
因此有如下实现思路：维护两个指针标记当前数组还未进行计算的部分的首尾，然后计算这两个指针指向元素的平方值，将得到的较大的值头插到新的数组序列中（可以对新的数组维护一个从后往前移动的指针），保证题目要求的非递减顺序排序，接下来将已加入到新数组中的元素的指针向中间移动（左加右减）

暴力解法

/**
 * 暴力解法
 */
public int[] sortedSquares(int[] nums) {
    for (int i = 0; i < nums.length; i++) {
        nums[i] *= nums[i];
    }
    Arrays.sort(nums);
    return nums;
}

• 时间复杂度:O(NlogN)
• 空间复杂度:O(1)

双指针

/**
 * 双指针
 */
public int[] sortedSquares(int[] nums) {
    int left = 0, right = nums.length - 1;
    int[] res = new int[nums.length];
    int index = nums.length - 1;
    while (left <= right) {
        int a = nums[left] * nums[left];
        int b = nums[right] * nums[right];
        if (a >= b) {
            res[index--] = a;
            left++;
        } else {
            res[index--] = b;
            right--;
        }
    }
    return res;
}

• 时间复杂度:O(N)
• 空间复杂度:O(N)

重点

注意读题排序顺序，以及循环中的 if 相关逻辑，刚用双指针法做的时候就因为没注意导致结果特别乱

滑动窗口

209. 长度最小的子数组

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

题目描述：
给定一个含有 n 个正整数的数组和一个正整数 target 。
找出该数组中满足其总和大于等于 target 的长度最小的连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

思路：
首先能够想到的解法是暴力解法，外层循环确定子数组起始点，然后在内层循环中从起始点开始对数组元素进行累加，然后判断是否为合适的子数组，但是这种方法的时间复杂度是 O(N^2) ，在力扣上直接超时了。
我们可以发现，在暴力解法里，每次更新起始点后的累加计算里，其实出现了较多的重复计算，我们可以考虑是否有办法避免这种情况。再考虑题目所求的子数组的特点：是原数组的一个连续区间，我们可以想到，用两个指针来标记区间的首尾，然后维护一个变量来表示这个区间所有元素的总和，这就是滑动区间法。
我们只需要不断滑动区间的首尾指针来标记合适的区间范围，就可以通过单次遍历操作来达成题目的需求。

暴力解法

/**
 * 暴力法
 * 结果超时
 */
public int minSubArrayLen(int target, int[] nums) {
    int minLen = Integer.MAX_VALUE;
    for (int i = 0; i < nums.length; i++) {
        int sum = 0;
        for (int j = i; j < nums.length; j++) {
            sum += nums[j];
            if (sum >= target) {
                minLen = Math.min(j - i + 1, minLen);
                break;
            }
        }
    }
    return minLen == Integer.MAX_VALUE ? 0 : minLen;
}

• 时间复杂度:O(N^2)
• 空间复杂度:O(1)

滑动窗口

/**
 * 滑动窗口
 */
public int minSubArrayLen(int target, int[] nums) {
    int min = Integer.MAX_VALUE;
    int begin = 0, end = 0, sum = 0;
    while (end < nums.length) {
        sum += nums[end];
        end++;
        while (sum >= target) {
            min = Math.min(min, end - begin);
            sum -= nums[begin];
            begin++;
        }
    }
    if (min == Integer.MAX_VALUE) {
        return 0;
    }
    return min;
}

• 时间复杂度:O(N)
• 空间复杂度:O(1)

思考：
维护一段区间内元素的总和除了使用某一个变量，似乎还可以使用前缀和的方式。但是在当前场景和需求下，使用前缀和可能会导致溢出的问题。算法的使用要因地制宜，根据实际需求来选用合适的算法。

矩阵

59. 螺旋矩阵 II

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

题目描述：
给你一个正整数 n ，生成一个包含 1 到 n^2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵matrix

思路：
本题相对来说没有什么复杂的算法，主要是转圈过程里的各种边界条件，一次转圈可以分为从左上到右上，从右上到右下，从右下到左下，从左下到右上四个步骤

public int[][] generateMatrix(int n) {
    int[][] res = new int[n][n];
    int counter = 1;
    int i = 0, j = 0;
    int round = 1;
    while (round <= n / 2) {
        while (j < n - round) {
            res[i][j++] = counter++;
        }
        while (i < n - round) {
            res[i++][j] = counter++;
        }
        while (j >= round) {
            res[i][j--] = counter++;
        }
        while (i >= round) {
            res[i--][j] = counter++;
        }
        i++;
        j++;
        round++;
    }
    if (n % 2 != 0 && counter == n * n) {
        res[i][j] = counter;
    }
    return res;
}