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

题目链接 ：[977.有序数组的平方](%E9%A2%98%E7%9B%AE%E9%93%BE%E6%8E%A5%EF%BC%9Ahttps://leetcode.cn/problems/squares-of-a-sorted-array/)

暴力排序代码

思路：首选创建一个新数组按顺序存储平方后的值，再将新数组排序

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */

int* sortedSquares(int* nums, int numsSize, int* returnSize){
    int* newarry=(int*)malloc(numsSize*sizeof(int));
    int temp;
    *returnSize=numsSize;//这句话别漏了
    for(int i=0;i<numsSize;i++)//新数组赋值
        {
            newarry[i]=nums[i]*nums[i];
        }
    //冒泡排序
    for(int j=0;j<numsSize-1;j++)//跟自己不要比较，所以要numSize-1
    {
        for(int k=0;k<numsSize-j-1;k++)//每比较完一轮就确定一个数位置就下一轮少比较一次
                                             //numsSize-j-1
        {
            if(newarry[k]>newarry[k+1])
                {
                    temp=newarry[k];
                    newarry[k]=newarry[k+1];
                    newarry[k+1]=temp;
                }
        }
    }
    return newarry;
}

双指针法代码

思路：因为该数组是非递减数组，所以平方后数组元素值大小是从两端向中间非递增的，即两端大中间小，所以用两个数组下标指向数组两端比较两端值大小，将更大的值依次按顺序存储到新数组中（从后往前存储）

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */

int* sortedSquares(int* nums, int numsSize, int* returnSize){
    int* newarry=(int*)malloc(numsSize*sizeof(int));
    int k，j,m;
    k=0;
    j=numsSize-1;
    m=numsSize-1;
    *returnSize=numsSize;//这句话别漏了
    for(int i=0;i<numsSize;i++)//原先数组元素依次平方
        {
            nums[i]=nums[i]*nums[i];
        }
    //双指针法
    while(k<=j)
    //注意是k<=j,如果是k<j则当都指向最中间元素时会退出，	最中间元素就没进行比较存储到新数组了
    {
        if(nums[k]>nums[j])
            newarry[m--]=nums[k++];
        else
            newarry[m--]=nums[j--];    
    }
    
    return newarry;
}

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

暴力解法代码

思路：两个for循环遍历，一个设置为起点，一个设置为终点

int minSubArrayLen(int target, int* nums, int numsSize){
    int result=INT_MAX;//指int类型（整型）变量所能取的最大值。是一个宏，由编译器定义
    int s_sum=0;//子列数组和
    int  s_len=0;//子列数组元素长度
    for(int i=0; i<numsSize;i++){//设置子序列起点为i
        s_sum=0;
        for(int j=i;j<numsSize;j++)//设置子序列终点为j
        {
            s_sum+=nums[j];//子序列和
            if(s_sum>=target)//判断和是否大于等于target
            {
                s_len=j-i+1;//一旦大于则说明该长度是符合要求的要记录下来
                result=result<s_len ? result : s_len;//result存储符合限制条件的最小子列数组长度
                break;//找符合条件的最短序列，找到符合的就立马返回
            }
        }
    }
    //判断result有没有被重新赋值，如果有则说明有符合条件的最短子序列
   return result==INT_MAX?0:result;
}
    

滑动窗口

思路：同过确定终止位置，不断变化起点位置找符合条件的最短子列数组。动态调剂窗口的起始位置。
·滑动窗口内是满足条件的子列数组
·终点位置下标是不断断往前遍历的，
·每找到满足条件的子列数组，s_sum(子列数组和)-num[i++],就减去当前子列数组位置的起点元素，起点位置往前移动一位，即缩小窗口

int minSubArrayLen(int target, int* nums, int numsSize){
    int result=INT_MAX;//指int类型（整型）变量所能取的最大值。是一个宏，由编译器定义
    int s_sum=0;//子列数组和
    int s_len=0;//子列数组元素长度
    int i=0;//标记起点位置
    for(int j=0; j<numsSize;j++){//设置子序列终止位置为i
        s_sum+=nums[j];
        //滑动窗口的核心代码
        while(s_sum>=target)//判断和是否大于等于target
            {
                s_len=j-i+1;//一旦大于则说明该长度是符合要求的要记录下来
                result=result<s_len ? result : s_len;//result存储符合限制条件的最小子列数组长度
                s_sum-=nums[i++];//变更起点位置，往前移动找下一个满足条件的长度
            }
        }
    
    //判断result有没有被重新赋值，如果有则说明有符合条件的最短子序列
   return result==INT_MAX?0:result;
}

题目链接

思路：按边写，每条边左闭右开区间，模拟顺时针画矩阵的过程:
·最上面的边从左往右写
·最右边的边从上往下写
·最下面的边从右往左写
·最左边的边从下往上写

代码：

/**
 * 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 startx=0;//起始行
    int starty=0;//起始列
    int count=1;
    int offset=1;//偏移量
    int loop=n/2;//圈数
    int mid=n/2;
    int **matrix=(int **)malloc(n*sizeof(int*));//申请指针数组
    *returnSize=n;
    *returnColumnSizes=(int*)malloc(n*sizeof(int));
    for(int m=0;m<n;m++){
        matrix[m]=(int*)malloc(n*sizeof(int));//申请内存空间
        memset(matrix[m],0,sizeof(int)*n);//新申请的内存进行初始化工作
        (*returnColumnSizes)[i]=n;
    }
    int i,j;
    while(loop--)
    {  
        for( j=starty;j<n-offset;j++)
            matrix[startx][j]=count++;
        for( i=startx;i<n-offset;i++)
            matrix[i][j]=count++;
        for(;j>starty;j--)
            matrix[i][j]=count++;
        for(;i>startx;i--)
            matrix[i][j]=count++;
        startx++;
        starty++;
        offset+=1;
    }
    if(n%2==1)//n是奇数得时候最中间得数要额外赋值
        matrix[mid][mid]=count;
    return matrix;
}

自我反馈：

1.第一题我还是没想到双指针法，只知道暴力解
2.第二题不会，暴力解都没弄出来
3.模拟不出来，不会
4.最后都懂了