代码随想录第2天 有序数组的平方，长度最小的子数组，螺旋矩阵

力扣977，209，59

写在前面：

昨日疑问可解，随想录说了，这里还是说一下，大家不必太在意leetcode上执行用时，打败多少多少用户，这个就是一个玩具，非常不准确。

哈哈哈哈，懂了，有道理，看来分析复杂度还是王道！！！

一、有序数组的平方

学习文章链接：代码随想录 (programmercarl.com)

力扣链接：977. 有序数组的平方 - 力扣（LeetCode）

题目内容：

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

例1：

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]

 1.第一想法：

先暴力，依次保存i^2到原数组，接着排序就好，用快排，这样时间复杂度o(nlgn)

---

2.随想录后的思考与收获：

有道理，其实两边的绝对值是最大的，因此可以设置两个指针，一头一尾，比大小放入结果数组里！！！

---

3.自己实现过程中的困难：

发现还是细节上没把握好，比如开辟空间的，笔试直接定义，现在必须开辟空间，方法不能忘记。

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

其实这个也常用，只是这个写法要更加适应才行！！！

---

4.代码

4.1 暴力（测了，也还行）

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* sortedSquares(int* nums, int numsSize, int* returnSize){
*returnSize=numsSize;
int* answer = (int*)malloc(sizeof(int) * numsSize);
for(int i=0;i<numsSize;i++){
    answer[i]=nums[i]*nums[i];
}
quicksort(answer,0,numsSize-1);
return answer;
}
void quicksort(int *a,int left,int right)
{
    if(left>right)
    {
        return ;
    }
    int i=left;
    int j=right;
    int key=a[left];
    while(i!=j)
    {
        while(a[j]>=a[left]&&i<j)
        {
            j--;
        }
        while(a[i]<=a[left]&&i<j)
        {
            i++;
        }
        int s;
        s=a[i];
        a[i]=a[j];
        a[j]=s;
    }
    a[left]=a[i];
    a[i]=key;
    quicksort(a,left,i-1);
    quicksort(a,i+1,right);
}

4.2 双指针

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* sortedSquares(int* nums, int numsSize, int* returnSize){
*returnSize=numsSize;
int low=0,high=numsSize-1;
int l2,r2;
int* answer = (int*)malloc(sizeof(int) * numsSize);
for(int i=numsSize-1;i>=0;i--){
    l2=nums[low]*nums[low];
    r2=nums[high]*nums[high];//平方比大小，谁大谁先进目标数组
    if(l2>r2){
        answer[i]=l2;
        low++;
    }
    else{
        answer[i]=r2;
        high--;
    }
}
return answer;
}

5.结果：

暴力大法的：

 双指针的：

---

二、长度最小的子数组

随想录链接：代码随想录 (programmercarl.com)

力扣链接：209. 长度最小的子数组 - 力扣（LeetCode）

题目内容：

给定一个含有 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

 1.第一想法

子数组问题让我想起来动态规划，但是二维数组感觉有点浪费，不会了，看看录吧！学！

我最初有个想法有点傻，就是说先找到比target小的书中最大的数，然后往前或者往后找，但好像不是很好写，算了，继续学滑动窗口。

2.随想录笔记

哦哦哦哦哦，看懂了看懂了，就是让窗口末尾作为循环的序列；

另外一个指针就用来定上界，滑动序列号求和，如果和小于等于target，则继续后移，长度加一；如果添加后大于target，则长度不加1，将前指针往后移，并减掉该数。如此循环一圈。

3.代码：

尝试根据上述思路码出如下：

int minSubArrayLen(int target, int* nums, int numsSize){
int sum=0,min=numsSize;
int length=0,sumi=0;
sum+=nums[0];
for(int i=0;i<numsSize;i++)
    sumi+=nums[i];
if(sumi<target)return 0;
for(int high=1,low=0;(high<numsSize);){//(high-low>0)
    if(sum<=target){length++;sum+=nums[++high];}
    else{
        length--;
        sum-=nums[low++];
        //high--;//达到high不动的程度
    }
    if(length<min)min=length;
}
return min;
}

所以，好像有点问题，之后再看看，那就先用这个吧：

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

4.结果：

5.思考：

求最大值初始化用INT_MIN,求最小值初始化用INT_MAX

还是想说，卡尔的动画真的很棒哈哈哈，可以帮你模拟，算法一目了然！！！

三、螺旋矩阵

59. 螺旋矩阵 II - 力扣（LeetCode）

随想录：代码随想录 (programmercarl.com)

这个好像在剑指offer里也有看到，题目如下：

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

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

1.第一

额，是道模拟的题，但是其实不熟练，如何转圈圈填充是一个问题！！

2.第二

看了看卡尔，唔！哦！没全看明白，可能因为不是很清醒，看不懂了，先模拟一下吧！插个眼，回来学！！

3.代码：

这个模拟不简单，建议看看视频！！！（俺就一下写不出来。。。）

/**
 * 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);
    //初始化返回结果数组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;
}

 4.结果：

 5.总结

放上卡尔的视频，这个需要好好揣摩的，虽然只是简单的模拟，但是不容易的！

一入循环深似海 | LeetCode：59.螺旋矩阵II_哔哩哔哩_bilibili

---

笑死，太笨了，飞太慢了！加油加油加油！！！