滑动窗口问题和模拟螺旋矩阵

1.相比暴力法利用两层循环来遍历寻找满足条件的元素来说，时间复杂度会相对于小很多。

下面利用该例题来讲解一下两者的差距

int minSubArrayLen(int target, int* nums, int numsSize) {
    int sum=0;int i=0,res;
    int min=INT_MAX;//INT_MAX：2^31-1
    for(int j=0;j<numsSize;j++)//来移动结束指针先将满足大于目标的子数组找到
    {
        sum+=nums[j];//对其求和
        while(sum>=target)//每次与目标进行比较
        {
            res=j-i+1;//终点位置-起始位置+1：所找到的子数组的数量
            if(res<min)//将数量最小的保留下来
            min=res;
            sum-=nums[i];//起始下标移动的时候就将该下标元素减去
            i++;//再移动起始下标
        }
    }
    if(min==INT_MAX) return 0;//如果最后的min依旧是INT_MAX,说明没有进入while循环里面，所有元素和小于目标
    return min;
}

滑动窗口的时间复杂度：O(n) 

int minSubArrayLen(int s, int* nums, int numsSize) {
    if (numsSize == 0) {
        return 0;
    }
    int ans = INT_MAX;
    for (int i = 0; i < numsSize; i++) {
        int sum = 0;
        for (int j = i; j < numsSize; j++) {
            sum += nums[j];
            if (sum >= s) {
                ans = fmin(ans, j - i + 1);
                break;
            }
        }
    }
    return ans == INT_MAX ? 0 : ans;
}

模拟

int** generateMatrix(int n, int* returnSize, int** returnColumnSizes){
    *returnSize = n;
//这行代码是将指针 returnSize 指向的内存位置设置为 n。通常情况下，returnSize 是一个指向整数的指针，用于存储数组的大小。*/
    *returnColumnSizes = (int*)malloc(sizeof(int) * n);
/*这行代码是为 returnColumnSizes 分配内存空间，以存储每一行的列数。returnColumnSizes 是一个指向整数数组的指针，每个元素代表相应行的列数。malloc 函数用于分配内存空间，sizeof(int) * n 表示分配的内存空间大小为 n 个整数的大小。*/   
    int** ans = (int**)malloc(sizeof(int*) * n);
/**这行代码是为指针数组 ans 分配内存空间，每个指针指向一个整数数组，形成一个二维数组。ans 是一个指向指针的指针，用于存储指向每一行数组的指针。malloc 函数同样用于分配内存空间，sizeof(int*) * n 表示分配的内存空间大小为 n 个指针的大小。*/
    int i;
    for(i = 0; i < n; i++) {
        ans[i] = (int*)malloc(sizeof(int) * n);
        (*returnColumnSizes)[i] = n;
/*这段代码使用循环为二维数组中的每一行分配内存空间，并将列数设置为 n。循环中的每一步，ans[i] 被设置为指向一个由 n 个整数组成的数组的指针。同时，(*returnColumnSizes)[i] 被设置为 n，表示第 i 行有 n 列。
这段代码的作用是创建一个 n * 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;
}

一定要注意循环的区间开闭情况，要保证每一个循环都是一样的遍历规则。这与前面写的二分法的区间类似。不明白可以看一下。