算法学习笔记 2 | 977. 有序数组的平方、209. 长度最小的子数组、59.螺旋矩阵II | 代码随想录

977. 有序数组的平方

题目链接：977. 有序数组的平方
给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

思路：用双指针思想。最两边的数的平方一定大于中间数的平方，所以依次对比左右两个指针所指向的数的平方，并由大到小从后往前赋值给新数组。

此时的时间复杂度为O(n)。

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

209.长度最小的子数组

题目链接：209. 长度最小的子数组
给定一个含有 n 个正整数的数组和一个正整数 target 。
找出该数组中满足其总和大于等于 target 的长度最小的 连续子数组 [numsl, numsl+1, …, numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

思路：
利用滑动窗口以及双指针思想。

首先设置返回值为最大数组长度，即原数组的长度。快指针用来遍历数组同时更新sum值。当找到总和大于target的子数组时，用一个while将慢指针前移，直到找到最小长度的子数组。
最后用一个布尔值判断是否找到该子数组，否则返回0。

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

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int slow = 0;
        int fast = 0;
        int subLen;
        int result = nums.size();
        int sum = 0;
        bool isFound = false;
        for (;fast<nums.size();fast++)
        {
            sum+=nums[fast];
            while (sum>=target)
            {
                isFound = true;
                subLen = fast - slow + 1;
                result = (result > subLen) ? subLen : result;
                sum-=nums[slow];
                slow++;
            }
        }
        if (isFound)
        {
            return result;
        }
        else
        {
            return 0;
        }
    }
};

59.螺旋矩阵II

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

思路：
每一个for循环都是绕一圈，需要绕n/2圈，每圈都要重新设置起始位置。每一圈包含了四条边，边的长度和offset有关，每转一圈offset要加一。
最后判断如果边长为奇数，要另外对中间值进行赋值。

时间复杂度 O(n^2): 模拟遍历二维矩阵的时间
空间复杂度 O(1)

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        int offset = 1;
        int startX = 0;
        int startY = 0;//定义每循环一个圈的起始位置
        int x = startX;
        int y = startY;
        int count = 1;
        vector<vector<int>> arr(n,vector<int>(n,0));
        for (int i=0; i<n/2 ; i++)//圈数
        {
            x = startX;
            y = startY;
            for (;y<n-offset;y++)
            {
                arr[x][y] = count;
                count++;
            }
            for (;x<n-offset;x++)
            {
                arr[x][y] = count;
                count++;
            }
            for (;y>startY;y--)
            {
                arr[x][y] = count;
                count++;
            }
            for (;x>startX;x--)
            {
                arr[x][y] = count;
                count++;
            }
            offset++;
            startX++;
            startY++;
        }
        if (n%2==1)
        {
            arr[n/2][n/2] = n*n;
        }
        return arr;
    }
};