代码随想录算法训练营第二天|977.有序数组的平方 ，209.长度最小的子数组 ，59.螺旋矩阵II

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

拿到这道题，我第一时间想到了暴力法，逻辑很简单，就是先逐个求出数组中元素的平方值，并给数组中原始元素重新赋值为求出的平方值，再进行排序，即可得到一个时间复杂度为O（n²）的解法。

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;
    }
};

后来我尝试着用C语言来写，并采用了双指针的思路，得到一个时间复杂度为O(n)的解法。

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
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 lsquare=nums[left]*nums[left];
        int rsquare=nums[right]*nums[right];
        if(lsquare>rsquare)
        {
            ans[index]=lsquare;
            left++;
        }
        else
        {
            ans[index]=rsquare;
            right--;
        }
        
    }
    return ans;
}

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

这道题，采用滑动窗口，可以得到一个时间复杂度为O(n)的解法

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

题目链接：59.螺旋矩阵II

这道题一开始没有头绪，看了讲解之后，豁然开朗，算法不算很难，制定好一个统一的边界条件（如：左闭右开），模拟顺时针画矩阵的过程即可顺利作答。

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
int** generateMatrix(int n, int* returnSize, int** returnColumnSizes){
    *returnSize=n;
    *returnColumnSizes=(int*)malloc(sizeof(int)*n);
    int** res=(int**)malloc(sizeof(int*)*n);
    int i;
    for(i=0;i<n;i++)
    {
        res[i]=(int*)malloc(sizeof(int)*n);
        (*returnColumnSizes)[i]=n;
    }
    
    int startx=0,starty=0;
    int loop=n/2,mid=n/2,offfset=1,count=1;
    
    while(loop--)
    {
       int i=startx;
       int j=starty;
        for(;j<n-offfset+starty;j++)
        {
            res[i][j]=count++;
        }

        for(;i<n-offfset+startx;i++)
        {
            res[i][j]=count++;
        }

        for(;j>starty;j--)
        {
            res[i][j]=count++;
        }

        for(;i>starty;i--)
        {
            res[i][j]=count++;
        }
        startx++;
        starty++;
        offfset+=2;
    }
    if(n%2)
    res[mid][mid]=n*n;
    return res;
    
}