算法训练（leetcode）第二天 | 977. 有序数组的平方、209. 长度最小的子数组、59. 螺旋矩阵 II

977. 有序数组的平方

leetcode题目地址

解法一

将数组求平方后再排序

时间复杂度 $O(nlogn)$
空间复杂度 $O(1)$

// c++ 平方后排序
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)$
空间复杂度 $O(n)$

// c++ 双指针
class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int left = 0, right = nums.size()-1, idx=right;
        vector<int> result(nums.size(), 0);
        while(left <= right && idx>=0){
            if(fabs(nums[left]) < fabs(nums[right])){
                result[idx--] = nums[right]*nums[right];
                right--;
            }else{
                result[idx--] = nums[left]*nums[left];
                left++;
            }
        }
        return result;
    }
};

209. 长度最小的子数组

leetcode题目地址

视频讲解

双指针（滑动窗口）。使用两个指针，初始同时指向数组头部。移动右指针并将右指针元素加入结果中，当结果值大于target，则移动左指针并从结果中移除左指针元素。

时间复杂度 $O(n)$
空间复杂度 $O(1)$

// c++
class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int left=0, right=0;
        int res=0, cnt=0, mincnt=nums.size();
        for(; right<nums.size(); right++){
            res += nums[right];
            while(res >= target){
                res -= nums[left];
                cnt = right - left + 1;
                mincnt = cnt < mincnt ? cnt : mincnt;
                left++;
            }
        }
        return cnt == 0 ? 0 : mincnt;
    }
};

虽然使用了双层循环，但每个元素只访问两次（进、出），所以时间复杂度为O(2n)。

59. 螺旋矩阵 II

leetcode题目地址

题解地址

旋转出来一个完整的螺旋矩阵可能看起来比较复杂，那就把问题拆分成最小单元：只转一圈。

下边以矩阵最外层的一圈来举例。（用i、j分别代表行列指针）

• 第一步：从左向右走。那就是行指针（i）不动，列指针（j）向后移动，即j++。
• 第二步：从上向下走。（在第一步指针移动的基础上继续移动指针）行指针（i）向下移动，列指针（j）不动，即i++。
• 第三步：从右向左走。（在第二步指针移动的基础上继续移动指针）行指针（i）不动，列指针（j）向前移动，即j–。
• 第四步：从下向上走。（在第三步指针移动的基础上继续移动指针）行指针（i）向上移动，列指针（j）不动，即i–。

注： 每一步结束之后需要修正指针。

时间复杂度 $O(n^2)$
空间复杂度 $O(1)$

// c++
class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        int i=0, j=0, res=1;
        vector<vector<int>> result(n, vector<int>(n, 0));
        while(res<=n*n){
        	// 左->右
            while(j<n && result[i][j]==0){
                result[i][j++] = res++;
            }
            i++;
            j--;
            // 上->下
            while(i<n && result[i][j]==0){
                result[i++][j] = res++;
            }
            i--;
            j--;
            // 右->左
            while(j>=0 && result[i][j]==0){
                result[i][j--] = res++;
            }
            j++;
            i--;
            // 下->上
            while(i>=0 && result[i][j]==0){
                result[i--][j] = res++;
            }
            i++;
            j++;
        }
        return result;
    }
};