算法训练营day02 有序数组的平方+长度最小的子数组+螺旋矩阵II

算法训练营day02 有序数组的平方+长度最小的子数组+螺旋矩阵II

---

LeetCode977 有序数组的平方

题目链接：LeetCode977：有序数组的平方

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

---

双指针法

思路：
由于给定的数组是有序的，但是负数的平方可以更大，所以最大值不是在最左边就是在最右边，此时便可以使用双指针法，一个指向最左边，另一个指向最右边
代码如下（示例）：

int* sortedSquares(int* nums, int numsSize, int* returnSize) {
    *returnSize = numsSize;
    int left = 0;                                    // 指向最左边的数值
    int right = numsSize - 1;                        // 指向最右边的数值
    int* ans = (int*)malloc(sizeof(int) * numsSize); // 动态分配内存
    int index;
    for (index = numsSize - 1; index >= 0; index--) {
        // 计算两边的平方
        int leSqrt = nums[left] * nums[left];
        int riSqrt = nums[right] * nums[right];
        // 判断大小
        if (leSqrt > riSqrt) {
            // 左边大于右边
            ans[index] = leSqrt;
            left++;
        } else {
            // 右边大于左边
            ans[index] = riSqrt;
            right--;
        }
    }

    return ans;
}

---

LeetCode209 长度最小的子数组

题目链接：LeetCode209：长度最小的子数组

给定一个含有 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

---

暴力解法

思路：使用嵌套循环，将每个数都加一遍判断是否大于等于目标值，如果满足条件则记录数组长度并返回

代码如下（示例）：

int minSubArrayLen(int target, int* nums, int numsSize) {
    int result = INT_MAX;
    int sum = 0;
    int sublen = 0;
    for (int i = 0; i < numsSize; i++) {
        sum = 0;
        for (int j = i; j < numsSize; j++) {
            sum += nums[j];
            if (sum >= target) {
                sublen = j - i + 1;
                result = result < sublen ? result : sublen;
                break;
            }
        }
    }
    return result == INT_MAX ? 0 : result;
}

---

滑动窗口解法

思路：定义左右边界，先使右边界移动到终点位置（在和第一次大于等于目标值的时候）
然后记录数组长度，收缩左边界，不断调节子序列的起始位置，使其找到长度最小的子数组

代码如下（示例）：

int minSubArrayLen(int target, int* nums, int numsSize) {
    int right = 0;        // 定义右边界
    int left = 0;         // 定义左边界
    int result = INT_MAX; // 定义最小长度
    int length = 0;
    int sum = 0;
    for (right = 0; right < numsSize; right++) {
        sum += nums[right]; // 将右边界移动到终点处
        // 当和大于等于目标值,开始收缩左边界
        while (sum >= target) {
            length = right - left + 1;
            result = result < length ? result : length;
            sum -= nums[left];
            left++;
        }
    }
    return result == INT_MAX ? 0 : result;
}

---

LeetCode59 螺旋矩阵II

题目链接：LeetCode59：螺旋矩阵II

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

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

示例 2：
输入：n = 1
输出：[[1]]

---

解法

思路：
模拟顺时针画矩阵的过程:
填充上行从左到右
填充右列从上到下
填充下行从右到左
填充左列从下到上
由外向内一圈一圈这么画下去。
过程中最需要注意的是左闭右闭或左闭右开的边界问题

代码如下（示例）：

int** generateMatrix(int n, int* returnSize, int** returnColumnSizes) {
    //初始化返回值大小
    *returnSize = n;
    *returnColumnSizes = (int*)malloc(sizeof(int) * n);
    //初始化返回数组大小
    int** ans = (int**)malloc(sizeof(int*) * n);
    for (int i = 0; i < n; i++) {
        //初始化二维数组每一个子元素数组的大小
        ans[i] = (int*)malloc(sizeof(int) * n);
        //用来标识结果数组的大小
        (*returnColumnSizes)[i] = n;
    }

    //设置每次循环的起始位置
    int startX = 0;
    int startY = 0;
    //设置循环圈数
    int loop = n / 2;
    //设置二维数组的中间值，若n为奇数，则需要在中间填上数字
    int mid = n / 2;
    //偏移数
    int offset = 1;
    //当前要添加的元素
    int count = 1;

    while (loop) {
        int i = startX;
        int j = startY;
        //模拟上侧从左到右
        for (; j < startY + n - offset; j++) {
            ans[startX][j] = count++;
        }
        //模拟右侧从上到下
        for (; i < startX + n - offset; i++) {
            ans[i][j] = count++;
        }
        //模拟下侧从右到左
        for (; j > startY; j--) {
            ans[i][j] = count++;
        }
        //模拟左侧从下到上
        for (; i > startX; i--) {
            ans[i][j] = count++;
        }
        //偏移值每次加2
        offset += 1;
        //遍历起始位置每次+1
        startX++;
        startY++;
        loop--;
    }
    //若n为奇数需要单独给矩阵中间赋值
    if (n % 2)
        ans[mid][mid] = count;

    return ans;

}

---

总结

前两题巩固了双指针法的使用和扩展，对于螺旋矩阵的写法还是觉得比较绕，希望在接下来的学习中能够将其掌握