代码随想录算法训练营day02 # 有序数组的平方#长度最小的子数组#螺旋矩阵

977. 有序数组的平方

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

示例 1：输入：nums = [-4,-1,0,3,10] 输出：[0,1,9,16,100]

解释：平方后，数组变为 [16,1,0,9,100] 排序后，数组变为 [0,1,9,16,100]

示例 2：输入：nums = [-7,-3,2,3,11] 输出：[4,9,9,49,121]

int* sortedSquares(int* nums, int numsSize, int* returnSize) {
    *returnSize=numsSize;
    int left=0;
    int right=numsSize-1;
    int index;
    int* arr=(int*)malloc(sizeof(int )*numsSize);
    for(index=numsSize-1;index >=0; index--){
        if(nums[left]*nums[left]>nums[right]*nums[right]){
            arr[index]=nums[left]*nums[left];
            left++;
        }
        else{
            arr[index]=nums[right]*nums[right];
            right--;
        }
    }
    return arr;
}

209. 长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其总和大于等于 target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

示例 1：输入：target = 7, nums = [2,3,1,2,4,3] 输出：2

              解释：子数组 [4,3] 是该条件下的长度最小的子数组。

示例 2：输入：target = 4, nums = [1,4,4] 输出：1

示例 3：输入：target = 11, nums = [1,1,1,1,1,1,1,1] 输出：0

        在暴力解法中，是一个for循环滑动窗口的起始位置，一个for循环为滑动窗口的终止位置，用两个for循环 完成了一个不断搜索区间的过程。

        那么滑动窗口如何用一个for循环来完成这个操作呢。

首先要思考 如果用一个for循环，那么应该表示 滑动窗口的起始位置，还是终止位置。

如果只用一个for循环来表示 滑动窗口的起始位置，那么如何遍历剩下的终止位置？

此时难免再次陷入 暴力解法的怪圈。

所以 只用一个for循环，那么这个循环的索引，一定是表示 滑动窗口的终止位置。

那么问题来了， 滑动窗口的起始位置如何移动呢？

这里还是以题目中的示例来举例，s=7， 数组是 2，3，1，2，4，3，来看一下查找的过程：

C语言暴力解法//超出时间限制

int minSubArrayLen(int target, int* nums, int numsSize) {
    int left, right,sum;
    int minlength=INT_MAX;//初始长度应当>numsSize;
    int sublength;
    for(left = 0;left < numsSize;left ++){
        //每次遍历后清零，计算长度
        sum = 0;
        for(right = left; right < numsSize; right++){
            sum =sum + nums[right];
            if(sum >= target){
                sublength=right-left+1;//字串长度
                minlength = minlength < sublength ? minlength : sublength;
            }
        }
    }
    return minlength == INT_MAX ? 0 : minlength;
}

滑动窗口

int minSubArrayLen(int target, int* nums, int numsSize) {
    int left=0, right=0, sum=0;
    int sublength, minlength = INT_MAX;
    for(right = 0; right < numsSize; right++){
        sum += nums[right];
        while (sum >= target){
            sublength = right - left + 1;
            minlength = minlength < sublength ? minlength : sublength;
            sum-=nums[left++];
        }
    }
    return minlength == INT_MAX ? 0 : minlength;
}

螺旋矩阵

给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。

示例 1：

输入：n = 3
输出：[[1,2,3],[8,9,4],[7,6,5]]

示例 2：

输入：n = 1
输出：[[1]]

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;
    //设置二维数组的中间值，若n为奇数。需要最后在中间填入数字
    int mid = n / 2;
    //循环圈数
    int loop = n / 2;
    //偏移数
    int offset = 1;
    //当前要添加的元素
    int count = 1;

    while(loop) {
        int i = startX;
        int j = startY;
        //模拟上侧从左到右
        for(; j < startY + n - offset; j++) {
            ans[startX][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++;
        }
        //偏移值每次加2
        offset+=2;
        //遍历起始位置每次+1
        startX++;
        startY++;
        loop--;
    }
    //若n为奇数需要单独给矩阵中间赋值
    if(n%2)
        ans[mid][mid] = count;

    return ans;
}

初始化二维数组

 

数组
创建一维数组：

int *ans=(int*)malloc(sizeof(int)*numsSize)

创建二维数组

// 第一步 分配内存给二维数组
int** ans=(int**)malloc(sizeof(int*)*n);

// 第二步 分配内存给一维数组
for(int i=0;i<n;i++){
    ans[i]=(int*)malloc(sizeof(int)*n);
}