算法学习Day2 | Chapter1数组

1.4 有序数组的平方

链接：文章；视频；977.有序数组的平方

1. 暴力法：先遍历并全部平方，再进行排序

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

• 时间复杂度：O(n + nlogn)

2. 双指针法：比较左右两个指针所指向元素的平方值，将数值大的结果从右边依次存入新数组

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int k = nums.size() - 1;
        vector<int> result(nums.size(), 0);
        int i = 0;
        int j = k;
        while (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--;
            }
        }
        return result;
    }
};

• 时间复杂度：O(n)

1.5 长度最小的子数组

链接：文章；视频；209.长度最小的子数组

1. 暴力法：两个for循环分别更新指针的起始位置和终止位置，直至寻找符合条件的子序列

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

• 时间复杂度：O(n^2)（测试会超时）

• 空间复杂度：O(1)

2. 滑动窗口：不断的调节子序列的起始位置和终止位置，关键在于动态调节滑动窗口的起始位置

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int sum = 0;
        int result = INT32_MAX; //nums.size() + 1貌似也行
        int len;
        int j = 0;
        for (int i = 0; i < nums.size(); i++) {
            sum += nums[i];
            while (sum >= target) {
                len = i - j + 1;
                result = result > len ? len : result;
                sum -= nums[j++];
            }
        }
        return result == INT32_MAX ? 0 : result;
    }
};

• 时间复杂度：O(n)

• 空间复杂度：O(1)

1.6 螺旋矩阵II

链接：文章；视频；59.螺旋矩阵II

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> matrix(n ,vector<int>(n, 0));
        int i, j;
        int startx, starty = 0; //每一圈的左上角起始位置
        int loop = n / 2; //循环圈数
        int count = 1;
        int offset = 1; //控制循环长度，始终遵循左闭右开原则
        int mid = n / 2; //如果n是奇数，则需要单独填充最中间的元素
        while (loop--) {
            for (j = starty; j < n - offset; j++) { //上
                matrix[startx][j] = count++;
            }
            for (i = startx; i < n - offset; i++) { //右
                matrix[i][j] = count++;
            }
            for ( ; j > starty; j--) { //下
                matrix[i][j] = count++;
            }
            for ( ; i > startx; i--) { //左
                matrix[i][j] = count++;
            }
            startx++;
            starty++;
            offset++;
        }
        
        if (n % 2) {
            matrix[mid][mid] = count;
        }

        return matrix;
    }
};

• 坚持循环不变量原则，循环原则始终左闭右开