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

有序数组的平方题目链接

一开始的想法是先平方再快排，

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
 void BubbleSort(int *arr, int size)  
{  
    int i, j, tmp;  
    for (i = 0; i < size - 1; i++) {  
        for (j = 0; j < size - i - 1; j++) {  
            if (arr[j] > arr[j+1]) {  
                tmp = arr[j];  
                arr[j] = arr[j+1];  
                arr[j+1] = tmp;  
            }  
        }  
    }  
} 

int* sortedSquares(int* nums, int numsSize, int* returnSize) {
    int *ans = malloc(sizeof(int)*numsSize);
    *returnSize = numsSize;
    for(int i=0 ; i<numsSize ; i++)
    {
        ans[i]= nums[i]*nums[i];
    }
    BubbleSort(ans,numsSize);
    return ans;
}

能过 ，但时间挺慢的，接下来试试双指针

因为最大只会轮流出现在头和尾，所以用一个index 记录每次更新后的数组  通过left和 right指针轮流比较，即可降低原先暴力方法所使用的时间

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

最小子数组

https://leetcode.cn/problems/minimum-size-subarray-sum/

这题之前做过 暴力就不展示了，直接展示滑动窗口的方法，因为子数组必须的连续的 所以可以用滑动窗口的方式处理

#include <math.h>
int minSubArrayLen(int target, int* nums, int numsSize) {
    int sum=0;
    int result= INT_MAX;
    int sub = 0;
    int i=0;
    for(int j=0;j<numsSize;j++)
    {
        sum +=nums[j];
        while(sum>=target)
        {
            sub = j-i+1;
            result = fmin(sub,result);
            sum -= nums[i++];
        }
    }
    return result==INT_MAX?0:result;    
}

螺旋矩阵

https://leetcode.cn/problems/spiral-matrix-ii/description/

主要还是考察代码的掌握能力， 之前有练习过 ，所以不多赘述

注意 边界问题 以及 遇到拐角如何处理

/**
 * 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);
    //初始化返回结果数组ans
    int** ans = (int**)malloc(sizeof(int*) * n);
    int i;
    for(i = 0; i < n; i++) {
        ans[i] = (int*)malloc(sizeof(int) * n);
        (*returnColumnSizes)[i] = n;
    }
   
    int StartX = 0;
    int StartY = 0;
    int Mid = n/2;
    int Loop = n/2;
    int Count = 1;
    int Offset = 1;
    
    while(Loop)
    {
        int i=StartX;
        int j=StartY;
        for(;j<StartY+n-Offset;j++)
        {
            ans[i][j] = Count++;
        }
        for(;i<StartX+n-Offset;i++)
        {
            ans[i][j] = Count++;
        }
        for(;j>StartY;j--)
        {
            ans[i][j] = Count++;
        }
        for(;i>StartX;i--)
        {
            ans[i][j] = Count++;
        }
        Offset += 2;
        StartX += 1;
        StartY += 1;
        Loop--;
    }
    if(n%2)
    {
        ans[Mid][Mid] = Count;
    }
    return ans;
}