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

977. 有序数组的平方

题目来源：leetcode Problems 977. squares-of-a-sorted-array

思路

C语言题解要求

将nums数组里的数先平方，然后将平方后的数组排序返回。返回的数组长度一定与原数组的长度相等。因此题解要求调用malloc动态创建一个长度为numsSize的int类型数组，函数返回值为该数组的地址，同时通过给为入参中的指针int* returnSize指向的值赋值以告诉调用者数组的长度。

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* sortedSquares(int* nums, int numsSize, int* returnSize)

{

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

    *returnSize = numsSize；

    /* your code */

    return retPtr;

}

调库排序

         先平方，再排序。

        先全变为绝对值，再排序，再平方。

        用的C语言，不想调库，也不想写排序算法，不考虑了。而且变为绝对值，要么会通过指针将原来的数组的值给改了，要么得新开一个数组，怎么都不方便。

双指针写法

基本思路

        由于数组为非递减数组，且可能存在负数，因此该数组及子数组的元素的平方中的最大值一定对应的是数组的最小（left）或最大索引（right）。将该最小或最大索引的数组元素平方值记录后，left++或right--得到子数组，再取当前子数组的最小或最大索引的平方值作为下一个最大平方值。

循环条件

        while(left <= right)

判断是left索引还是right索引的平方值成为最大平方值

当num[left] + nums[right] < 0, 说明nums[left]一定为负数，

• 若nums[right]为负，由于数组非递减，nums[right]的绝对值不会大于nums[left]；
• 若nums[right]为正，由于nums[left] + nums[right] < 0, 说明nums[right]的绝对值小于nums[left]的绝对值；

因此当num[left] + nums[right] < 0时，取nums[left]为最大平方值；否则，取nums[right]为最大平方值。

代码

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* sortedSquares(int* nums, int numsSize, int* returnSize){
    int left = 0;
    int right = numsSize - 1;
    int retIndex = numsSize - 1;
    int* RetPtr;
    RetPtr = (int *)malloc( sizeof(int) * numsSize );
    while(left <= right)
    {
        if(nums[left] + nums[right] < 0)
        {
            RetPtr[retIndex --] = nums[left] * nums[left];
            left ++;
        }
        else
        {
            RetPtr[retIndex --] = nums[right] * nums[right];
            right --;
        }
    }
    *returnSize = numsSize;
    return RetPtr;
}

---

209.长度最小的子数组

题目来源：leetcode Problems 209. minimum-size-subarray-sum

 用双指针滑动窗口解法，思路略

需要注意的是，由于题目有以下规定

• 1 <= target <= 10^9
• 1 <= nums.length <= 10^5
• 1 <= nums[i] <= 10^5

因此我一开始设置的ret = 10^5 + 1, 对这个^符号不熟悉, 导致我WA了好多次，原来在C语言里^是亦或的意思!

题解

int minSubArrayLen(int target, int* nums, int numsSize){
    int left = 0;
    int right;
    int ret = 0x7FFFFFFF;
    int sum = 0;
    int temp = 0;
    for(right = 0;right < numsSize; right++)
    {
        sum += nums[right];
        while(sum >= target)
        {
            temp = right - left + 1;
            if(temp < ret)
            {
                ret = temp;
            }
            sum -= nums[left];
            left ++;
        }
    }
    if(ret == 0x7FFFFFFF)
    {
        ret = 0;
    }
    return ret;
}

---

59.螺旋矩阵II

题目来源：leetcode Problems 59. spiral-matrix-ii

C语言题解要求

返回二维数组信息

题目要求是返回一个二维数组，但返回的只能是二位数组的首地址指针，函数调用者需要知道这个二维数组是由多少个一维数组组成的，并且需要知道每一个一维数组的长度。

/**
 * 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* returnSize指向的变量不需要我们创建，我们只需要为*returnSize赋值，这样能告诉调用者二维数组由*returnSize数量个一维数组组成。

不要被int** returnColumnSize的两个指针符号吓到，我们只需要创建一个数组，该数组包含每一个一维数组的长度，该函数的首地址就是一级指针，我们只要再对该首地址取地址，就是题目需要的二级指针了。

/**
 * 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 i;
    /* 告诉调用者有多少个一维数组 */
    *returnSize = n;
    /* 创建了一个数组，该数组存储的是每一个一维数组的长度，sizeArray就是该数组的首地址 */
    int* sizeArray = (int*)malloc(sizeof(int) * n);
    /*  returnColumnSizes就是一个指向地址的指针，*returnColumnSizes就是指向的地址，就是长度数组的地址  */
    *returnColumnSizes = sizeArray;
    /* 还要给长度数组赋值 */
    for(i = 0; i < n; i++)
    {
        sizeArray[i] = n;   /* 每个一维数组的长度都是n */
    }
}

创建二维数组

首先创建长度为n的指针数组matrix，每个指针都指向一个一维数组，即matrix数组的每个元素都是数组的首地址。

int** matrix = (int**)malloc(sizeof(int*) * n);

 然后为matrix的每个元素赋值，赋的值为一个数组的首地址

int** matrix = (int**)malloc(sizeof(int*) * n);

for(i = 0; i < n; i++)

{

    matrix[i] = (int*)malloc(sizeof(int) * 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){
    int i, j;
    int x = 0, y = 0;
    int left = 0;
    int top = 0;
    int right = n - 1;
    int bottom = n - 1;
    int flag = 1;

    /* 创建长度为n的指针数组matrix，每个指针都指向一个一维数组，即matrix数组的每个元素都是数组的首地址 */
    int** matrix = (int**)malloc(sizeof(int*) * n);
    /* 创建了一个数组，该数组存储的是每一个一维数组的长度，sizeArray就是该数组的首地址 */
    int* sizeArray = (int*)malloc(sizeof(int) * n);

    /* 告诉调用者有多少个一维数组 */
    *returnSize = n;
    /*  returnColumnSizes就是一个指向地址的指针，*returnColumnSizes就是指向的地址，就是长度数组的地址  */
    *returnColumnSizes = sizeArray;

    for(i = 0; i < n; i++)
    {
        /* 还要给长度数组赋值 */
        sizeArray[i] = n;   /* 每个一维数组的长度都是n */
        /* 为matrix的每个元素赋值，赋的值为一个数组的首地址 */
        matrix[i] = (int*)malloc(sizeof(int) * n);
    }


    for(j=1; j <= n*n; j++){
        if(flag == 1){
            matrix[x][y++] = j;
            if(y == right){
                top ++;
                flag = 2;
            }
        }else if (flag == 2){
            matrix[x++][y] = j;
            if(x == bottom){
                right --;
                flag = 3;
            }
        }else if (flag == 3){
            matrix[x][y--] = j;
            if(y == left){
                bottom --;
                flag = 4;
            }
        }else{
            matrix[x--][y] = j;
            if(x == top){
                left ++;
                flag = 1;
            }
        }
    }
    return matrix;
}