算法刷题-Day02

书接上回

有序数组的平方

. - 力扣（LeetCode）

给你一个按 非递减顺序 排序的整数数组 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]

提示：

• 1 <= nums.length <= 104
• -104 <= nums[i] <= 104
• nums 已按 非递减顺序 排序

此题的解题思路主要实现将数组的中数平方之后，重新按照非递减顺序排序生成一个新的数组返回。简单的方法是将平方后的数据通过sort重新排序。但是通过给定的数组元素我们可以清晰的得到，两边的元素较之于中间的元素，平方之后得到的数据会远大于中间的。所以可以使用双指针法来解决。分别用两个指针指向数组的两端，然后比较两端的数据大小，大的数据填充到新的数组最后一个元素，同时将指针进行移位操作。再次比较，插入数据，位移指针最后得到一个新的数组即是题解

    public static int[] sortedSquares(int[] nums) {
        int[] result = new int[nums.length];
        int k = result.length - 1;
        for (int i = 0, j = nums.length - 1; i <= j; ) {
            if ((nums[i] * nums[i]) > (nums[j] * nums[j])) {
                result[k] = nums[i] * nums[i];
                i++;
            } else {
                result[k] = nums[j] * nums[j];
                j--;
            }
            k--;
        }
        return result;
    }

这里需要注意的循环跳出的条件，是i <= j。原因很简单还是之前说到的，循环不变量。我们定义i和j的时候，i=0，j=nums.length-1。这个区间就是一个左闭右闭的区间。所以根据循环不变量原则，循环跳出的条件即为i <= j（忘记循环不变量原则的可以看上一篇文章）

长度最小的子数组

. - 力扣（LeetCode）

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其总和大于等于 target 的长度最小的 连续

子数组

 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

示例 1：

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

示例 2：

输入：target = 4, nums = [1,4,4]
输出：1

示例 3：

输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0

提示：

• 1 <= target <= 109
• 1 <= nums.length <= 105
• 1 <= nums[i] <= 105

主要的解题思路还是需要用到上一题所说的双指针，使用快慢指针来得到一个区间，快指针每次++完之后看区间的和是否大于等于target，如果大于，则将慢指针向右位移一位，看是否还是大于等于target。直到sum<target跳出循环。

public static int minSubArrayLen(int target, int[] nums) {
        int result = Integer.MAX_VALUE;
        int sum = 0;
        for (int i = 0, j = 0; i <= nums.length - 1; i++) {
            sum += nums[i];
            while (sum >= target) {
                result = Math.min(result, (i - j + 1));
                sum -= nums[j];
                j++;
            }

        }
        return result == Integer.MAX_VALUE ? 0 : result;
    }

螺旋矩阵

. - 力扣（LeetCode）

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

示例 1：

输入：n = 3
输出：[[1,2,3],[8,9,4],[7,6,5]]

示例 2：

输入：n = 1
输出：[[1]]

提示：

• 1 <= n <= 20

这题主要的解题思路还是依托之前的循环不变量原则，同时把握好什么时候进行x方向填充数据，什么时候y方向填充数据。先保证填充的顺序是

1.从左到右

2.从上到下

3.从右到左

4.从下到上

如此逆时针画矩形，同时按照循环不变量。保持边界为左闭右开的区间。所以设置的条件是n-1-offset和offset。如果是奇数的矩阵，则中间位置数据需要我们手动去填充。每次循环后将起始位置的偏移量+1.这样就可以得到我们需要的螺旋矩阵了

    public static int[][] generateMatrix(int n) {
        int[][] result = new int[n][n];
        //循环的圈数
        int loop = n / 2;
        //中心填充的数据
        int mid = n / 2;
        //x方向起点
        int startx = 0;
        //y方向起点
        int starty = 0;
        //待填充的数据
        int count = 1;
        //循环一圈的偏移量
        int offset = 0;

        while (loop != 0) {
            //从偏移位置开始重新赋值数据
            startx = offset;
            starty = offset;
            for (; starty < n - 1 - offset; starty++) {
                result[startx][starty] = count++;
            }
            for (; startx < n - 1 - offset; startx++) {
                result[startx][starty] = count++;
            }
            for (; starty > offset; starty--) {
                result[startx][starty] = count++;
            }
            for (; startx > offset; startx--) {
                result[startx][starty] = count++;
            }
            offset++;
            loop--;
        }
        //如果n是奇数，那么中心点的坐标为mid
        if (n % 2 != 0) {
            result[mid][mid] = count;
        }
        return result;
    }

以上就是数组的算法训练，可以看到重要的是理解循环不变量。