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

还是潦草的写一下，先写个自己版本的，之后再回来完善，先对自己负责，没有静下心来完全理解掌握。

第一题：leetcode，977.有序数组的平方 

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

int* sortedSquares(int* nums, int numsSize, int* returnSize) {
    //一开始不会，看到提示双指针就有一点灵感，有个鬼，不会
    //稍微看了答案后,还是有很多细节不会
    int* a = malloc(numsSize * sizeof(int)); // 动态分配数组
    //在C语言中，函数不能直接返回静态局部数组，
    //因为静态局部数组的生命周期仅限于函数的执行期间。
    //一旦函数执行完毕，静态局部数组就会被销毁
    int k=numsSize-1,i=0,j=numsSize-1;
    while(i<=j){
        if((nums[i]*nums[i])>=(nums[j]*nums[j])){
            a[k--]=(nums[i]*nums[i]);
            i++;
        }else {
            a[k--]=(nums[j]*nums[j]);
            j--;
        }
    }
    *returnSize = numsSize; // 设置返回数组的大小
    return a;
}

第一题：leetcode，209.长度最小的子数组209.长度最小的子数组

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

int minSubArrayLen(int target, int* nums, int numsSize) {
    //看了讲解视频，试着写一下
    //还是不会。。。
    int sum=0,length=INT_MAX,i=0;
    for(int j=0;j<numsSize;j++){
        //j是结束位置
        //判断前面的元素之和有没有超过target
        //看了文档后发现这种只能检测前后连续的子数组,不是我想的回溯法，当然也写不出
        sum+=nums[j];
        while(sum>=target){
            length=length<(j-i+1)?length:(j-i+1);
            sum-=nums[i++];
        }
    }
    //临界条件：[1,2,3,4,5]，不会
    //重要的INT_MAX
    return length==INT_MAX?0:length;
}

第三题：leetcode，59.螺旋矩阵II

题目链接：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) {
    int **martix=(int **)malloc(n*sizeof(int *));
    for(int i=0;i<n;i++){
        martix[i]=(int *)malloc(n*sizeof(int));
    }
    int m=n/2;
    int start_x=0;int start_y=0;
    int length=0;int count=1;
    while(m){
        int j=start_y;
        for(;j<n-length-1;j++){
            martix[start_x][j]=count++;
        }
        int i=start_x;
        for(;i<n-length-1;i++){
            martix[i][j]=count++;
        }
        for(;j>start_y;j--){
            martix[i][j]=count++;
        }
        for(;i>start_x;i--){
            martix[i][j]=count++;
        }
        start_x++;
        start_y++;
        length++;
        m--;
    }
    if(n%2 != 0){
        martix[start_x][start_y]=count;
    }
// 分配和填充二维数组...

// 设置 returnSize 为矩阵的行数
*returnSize = n;

// 分配 returnColumnSizes 数组，并设置每列的大小为 n
*returnColumnSizes = (int*)malloc(n * sizeof(int));
for (int i = 0; i < n; i++) {
    (*returnColumnSizes)[i] = n;
}

    return martix;
}

看看我这效率，我都看着有点假。