代码随想录训练Day2_将n种不停的草随机种在二维平面上,给定二维数组points表示第0天所有草的初始

Leetcode977有序数组的平方

有序数组的平方使用双指针法，由于输入数组有正负且单调不减，所以可以设定双指针从两头向中间移动。

将选定的数放入新的数组中时间复杂度为O(n)

int* sortedSquares(int* nums, int numsSize, int* returnSize){}

nums是一个数组的起始地址

所以创建新的数组时应该使用malloc函数，用法如下：

int* a = (int*)malloc(sizeof(int) * numsSize);

分配可以放得下numsSize个整数的内存空间,并且把a指向该空间所在位置。

有序数组的平方代码如下：

int* sortedSquares(int* nums, int numsSize, int* returnSize){
     *returnSize = numsSize;
     int* a = (int*)malloc(sizeof(int) * numsSize);
    int i,j,k;
    i=0;
    j=numsSize-1;
    k=numsSize;
    for(k = numsSize - 1; k >= 0; k--){
        if(nums[i]*nums[i]>nums[j]*nums[j]){
            a[k]=nums[i]*nums[i];
            i++;
        }else{
            a[k]=nums[j]*nums[j];
            j--;
        }
    }
    return a;
}

Leetcode209长度最小的子数组

暴力解法：

进行量for循环，找到以数组中每一个元素开头的所有符合条件的结果，记录最短长度min。最后判断target是否大于数组的和，若大于则没有符合条件的最短数组返回0，反之返回min。

int minSubArrayLen(int target, int* nums, int numsSize){
    int i,j,sum=0,min=numsSize;
    for(i=0;i<numsSize;i++){    //两层循环找出最短长度
        int temp=0;
        for(j=i;j<numsSize;j++){    
            temp=temp+nums[j];
            if(temp>=target){
                if(j-i+1<min){
                    min=j-i+1;
                }                
            }
        }
        sum=sum+nums[i];        //记录整个数组的和
    }
    if(target>sum){     //如果target大于数组的和则没有符合条件的最短数组，返回0
        return 0;
    }else{
        return min;
    }
}

滑动窗口解法：

1. 滑动窗口初始位置为i，终止位置为j，初始化最小长度min为最大值（比数字长度大即可）

2. 将滑动窗口终点向后移动，统计滑动窗口中的和sum，当sum满足大于等于target时，计算当前窗口大小作为满足条件的子数组。

3. 然后更新最短长度，并将滑动窗口起点向后移动更新sum的值，当sum小于target时起点停止移动。

4. 重复2、3步骤，知道终点移动到数组末端。

5. 最后判断小长度min是否改变，若改变则使用新的最小值，若没改变，则说明没有满足条件的最小长度，则返回0。

int minSubArrayLen(int target, int* nums, int numsSize){
    //滑动窗口初始为i，终止位置为j，初始化最小长度为最大值（比数字长度大即可）
    int i=0,j,sum=0,min=numsSize+1;
    //操作滑动窗口向后移动
    for(j=0;j<numsSize;j++){
        //滑动窗口nums[i]到nums[j]中的元素和
        sum+=nums[j];
        //当滑动窗口中的sum大于等于target，便找到了满足条件的最小长度
        while(sum>=target){
            min=j-i+1<min?j-i+1:min;
            sum-=nums[i];
            i++;
        }
    }
    //判断小长度min是否改变
    return min==numsSize+1?0:min;
}

Leetcode59螺旋矩阵Ⅱ

注释：

/**
 * 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().
 */

谷歌翻译如下：

1. 返回大小为 *returnSize 的数组的数组。

2. 数组的大小作为 *returnColumnSizes 数组返回。

3. 注意：返回的数组和 *columnSizes 数组都必须被 malloced，假设调用者调用 free()。

说明:

1. 数组里面的元素是数组，其实就是二维数组。returnSize是二维数组的地址， *returnSize 就代表返回的值

2. *returnColumnSizes代表数组中数组的大小，即数组的列数。

3. 返回的数组和*columnSizes 数组都必须被 malloced，是指用mallloc函数创建一个数组，自然就会得到一个返回的数组和指向数组的一阶指针。

二维数组的创建：首先创建二维数组，然后再对二维数组的每一个元素位置中创建一个一维数组，便得到了一个二维数组

//初始化返回结果数组a
    int** a = (int**)malloc(sizeof(int*) * n);
    int i;
    for(i = 0; i < n; i++) {
        a[i] = (int*)malloc(sizeof(int) * n);//每一行都是长度为n的数组
        (*returnColumnSizes)[i] = n;//二维矩阵的列为n
    }

循环不变量：一圈一圈地进行循环，不变量是指对每条边的处理规则（左闭右开、左闭右闭）。

按照左开右闭的原则，对矩阵进行顺时针赋值。

**注意边界条件，循环条件，绕圈的次数等。

示意图如下所示：

螺旋矩阵Ⅱ代码如下：

/**
 * 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);
    //初始化返回结果数组a
    int** a = (int**)malloc(sizeof(int*) * n);
    int i,j;
    for(i = 0; i < n; i++) {
        a[i] = (int*)malloc(sizeof(int) * n);//每一行都是长度为n的数组
        (*returnColumnSizes)[i] = n;//二维矩阵的列为n
    }
    //satrtx,starty为每一圈循环开始的元素位置
    //reduce为每一圈循环缩小的量
    //loop为循环的圈数
    int startx=0,starty=0,reduce=1,count=1;
    int loop=n/2;
    while(loop){
        for(j=starty;j<n-reduce;j++){
            a[startx][j]=count++;
        }
        for(i=startx;i<n-reduce;i++){
            a[i][n-reduce]=count++;
        }
        for(j=n-reduce;j>starty;j--){
            a[n-reduce][j]=count++;
        }
        for(i=n-reduce;i>startx;i--){
            a[i][starty]=count++;
        }
        startx++;
        starty++;
        reduce++;
        loop--;
    }
    //如果n为基数，则最后为矩阵中心赋值
    if(n%2==1){
        a[n/2][n/2]=count++;
    }
    return a;
}