C++数据结构 第二天| 数组篇 ~ 有序数组的平方、 长度最小的子数组、螺旋矩阵II（代码随想录算法训练营）

今天分享数据结构-数组篇【有序数组的平方】【长度最小的子数组】【螺旋矩阵Ⅱ】

有序数组的平方

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

方法一：BF

最简单最直观的想法：每个数平方之后，在排个序

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        for (int i = 0; i < nums.size(); i++) {
            nums[i] *= nums[i];
        }
        sort(nums.begin(), nums.end()); // 快速排序
        return nums;
    }
};

• 暴力解法的时间复杂度是O(n + nlogn)，即为O(n)，为与下面双指针算法做区分，这里记为O(n + nlogn)。

方法二：双指针

因为初始时，数组元素是有序排列的

平方之后，可能负数会变成最大值

所以数组平方的最大值只能在两边，要么最左边，要么最右边，不可能在中间。

所以我们可以定义两个指针，初始位置分别位于起始位置和终止位置

int i = 0, j = nums.size()

定义一个跟 nums 长度一样的数组 result 和 记录从后往前录入最大平方数的 k

vector result (nums.size())

int k = nums.size() - 1

判定条件：

• 如果A【i】 * A【i】 < A【j】* A【j】
  • 则result【k–】 = A【j】 * A【j】
• 如果A【i】 * A【i】 > A【j】* A【j】
  • 则result【k–】 = A【i】 * A【i】

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int k = nums.size() - 1;
        vector<int> result(nums.size());
        for(int i = 0, j = k;i <= j;){
            if(nums[i] * nums[i] < nums[j] * nums[j]){
                result[k--] = nums[j] * nums[j];
                j--;
            }else{
                result[k--] = nums[i] * nums[i];
                i++;
            }
        }
        return result;
    }
};

• 双指针的时间复杂度是O(n)

---

---

---

长度最小的子数组

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

方法一：BF

这道题也有暴力解法，但效率不高，不是本篇重点，就不赘述

感兴趣可以自己尝试写一下

方法二：双指针-滑动窗口

本道题仍然用到双指针的思想

• 双指针的基本思想就是实现目标循环在一个for循环中实现

而双指针被应用在滑动窗口中

• 滑动窗口的基本思想就是它的左右边界值不断变化，直至实现达到目标
• 双指针分别是滑动窗口的左边界和右边界

如何应用一个for循环同时移动滑动窗口的初始位置和终止位置呢

在解决这个问题之前，我们先需要确定三点：

• 窗口内是什么？
• 什么时候移动窗口的起始位置？
• 什么时候移动窗口的终止位置？

1. 根据题意我们知道：窗口内是数组的一串子数组，并且满足子数组元素之和 大于等于 目标值Target
2. 当窗口内的子数组 大于 目标值Target时，我们需要缩短子数组，将初始位置向右移动一位
3. 当窗口内的子数组 小于 目标值Target时，我们需要扩大子数组，将终止位置向右移动一位

通过这个逻辑，我们就能把双指针和滑动窗口应用在同一个for循环语句中，实现如下

for(int j = 0;j < nums.size();j++){
    sum += nums[j];
    while(sum >= target){
        subLength = (j - i + 1);
        
        if(result > subLength){
            result = subLength;
        }else{
            result = result;
        }

        sum = sum - nums[i++];
    }
}

---

完整代码实现：

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int result = INT32_MAX;
        int sum = 0;
        int i = 0;
        int subLength = 0;
        for(int j = 0;j < nums.size();j++){
            sum += nums[j];
            while(sum >= target){
                subLength = (j - i + 1);
                
                if(result > subLength){
                    result = subLength;
                }else{
                    result = result;
                }

                sum = sum - nums[i++];
            }
        }
        if(result == INT32_MAX){
            return 0;
        }else{
            return result;
        }
    }
};

双指针-滑动窗口的时间复杂度是O(n)

---

---

---

旋转矩阵Ⅱ

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

关键

每一条边都需要用相同的固定的判断条件

如果不按照固定的规则来遍历，就会出现死循环

判断条件可以是左闭右开，或者左开右闭

本篇我们采用左闭右开的方法

左开右闭也是类似的，大家可以私下尝试写一下

模拟顺时针画矩阵的过程:

• 填充上行从左到右
• 填充右列从上到下
• 填充下行从右到左
• 填充左列从下到上

i = startx;
j = starty;

// 下面开始的四个for就是模拟转了一圈
// 模拟填充上行从左到右(左闭右开)
for (j; j < n - offset; j++) {
    res[i][j] = count++;
}
// 模拟填充右列从上到下(左闭右开)
for (i; i < n - offset; i++) {
    res[i][j] = count++;
}
// 模拟填充下行从右到左(左闭右开)
for (; j > starty; j--) {
    res[i][j] = count++;
}
// 模拟填充左列从下到上(左闭右开)
for (; i > startx; i--) {
    res[i][j] = count++;
}

// 第二圈开始的时候，起始位置要各自加1， 例如：第一圈起始位置是(0, 0)，第二圈起始位置是(1, 1)
startx++;
starty++;

// offset 控制每一圈里每一条边遍历的长度
offset += 1;

如果n为奇数，则矩阵最中间Matrix【n/2】【n/2】无法通过循环添数，则我们需要额外判定奇数矩阵，对应填数

if (n % 2) {
   res[mid][mid] = count;
}

完整代码

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> res(n, vector<int>(n, 0)); // 使用vector定义一个二维数组
        int startx = 0, starty = 0; // 定义每循环一个圈的起始位置
        int loop = n / 2; // 每个圈循环几次，例如n为奇数3，那么loop = 1 只是循环一圈，矩阵中间的值需要单独处理
        int mid = n / 2; // 矩阵中间的位置，例如：n为3， 中间的位置就是(1，1)，n为5，中间位置为(2, 2)
        int count = 1; // 用来给矩阵中每一个空格赋值
        int offset = 1; // 需要控制每一条边遍历的长度，每次循环右边界收缩一位
        int i,j;
        while (loop --) {
            i = startx;
            j = starty;

            // 下面开始的四个for就是模拟转了一圈
            // 模拟填充上行从左到右(左闭右开)
            for (j; j < n - offset; j++) {
                res[i][j] = count++;
            }
            // 模拟填充右列从上到下(左闭右开)
            for (i; i < n - offset; i++) {
                res[i][j] = count++;
            }
            // 模拟填充下行从右到左(左闭右开)
            for (; j > starty; j--) {
                res[i][j] = count++;
            }
            // 模拟填充左列从下到上(左闭右开)
            for (; i > startx; i--) {
                res[i][j] = count++;
            }

            // 第二圈开始的时候，起始位置要各自加1， 例如：第一圈起始位置是(0, 0)，第二圈起始位置是(1, 1)
            startx++;
            starty++;

            // offset 控制每一圈里每一条边遍历的长度
            offset += 1;
        }

        // 如果n为奇数的话，需要单独给矩阵最中间的位置赋值
        if (n % 2) {
            res[mid][mid] = count;
        }
        return res;
    }
};

旋转矩阵的时间复杂度O(n^2)

---

---

---

总结

Nothing worthwhile in life comes easy

4.18

SUN YAT-SEN UNIVERSITY