代码随想录算法训练营第二天 |LeetCode977 有序数组的平方、LeetCode209 长度最小的子数组、LeetCode59 螺旋矩阵Ⅱ

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

思路：首先想到的是qsort快排，但是为了练习双指针... ...，既然递增数组，存在正负分界线，那么平方后的最大值只能在两侧。

暴力解法-快排：

int cmp(const void *a, const void *b) {
    return *(int*)a - *(int*)b;       //从小到大排序
}
int* sortedSquares(int* nums, int numsSize, int* returnSize){
//所有数组平方后，进行排序
for(int i = 0; i < numsSize; i++) {
    nums[i] = nums[i] * nums[i];
}
qsort(nums, numsSize, sizeof(int), cmp);
*returnSize = numsSize;
return nums;
}

双指针法：

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* sortedSquares(int* nums, int numsSize, int* returnSize){
//两边大中间小，从两边向中间靠拢得到一个从多大到小的数组
//更新数组，下标从大到小进行更新，比较左右两指针所指向元素绝对值大小
//step1：定义一个新数组
int* retnums = (int*)malloc(sizeof(int)*numsSize);
if(retnums == NULL) {
    return NULL;
}
//step2：定义新数组索引下标k,新数组从大到小进行更新
int k = numsSize - 1;
//step3：定义左/右双指针
for(int left = 0, right = numsSize - 1; left <= right; ){  //注意循环终止：i <= j,如果i<j,i=j的元素丢失
//step4：判断left++ or right--条件
    if(abs(nums[left]) >= abs(nums[right])) {
        retnums[k--] = nums[left]*nums[left];
        left++;
    } else {
        retnums[k--] = nums[right]*nums[right];
        right--;
    }
}
//step5: 返回新数组
*returnSize = numsSize;
return retnums;
}

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

思路：滑动窗口、不断调节子序列的起始位置和终止位置

//滑动窗口：不断的调节子序列的起始位置和终止位置
int minSubArrayLen(int target, int* nums, int numsSize){
//step1:定义双指针
int SumNum = 0;
int minLen = numsSize + 1;
//step2:循环结构
for(int fast = 0, slow = 0; fast < numsSize; fast++) {
    SumNum += nums[fast];
    while(SumNum >= target) {
    minLen = ((fast - slow + 1) >= minLen) ? minLen : fast - slow + 1;
    SumNum -= nums[slow++];
    }
}
return minLen == numsSize + 1 ? 0 : minLen;
}

题目链接：59. 螺旋矩阵 II - 力扣（LeetCode）

思路：定义好螺旋矩阵的循环条件

/**
 * 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;
//step1:申请二维数组
*returnColumnSizes = (int*)malloc(sizeof(int)*n);
if(returnColumnSizes == NULL) {
    return NULL;
}
int** resultAns = (int**)malloc(sizeof(int*)*n);
for(int i = 0; i < n; i++) {
resultAns[i] = (int*)malloc(sizeof(int)*n);
(*returnColumnSizes)[i] = n;
memset(resultAns[i], 0, sizeof(int)*n);
}
//step2:定义循环条件
int up = 0;
int down = n - 1;
int left = 0;
int right = n - 1;
int k = 1;                           //k <= n
int i = 0;
while((up <= down)&&(left <= right)) {
//step3：up固定，i从left到right i++, up+1;
for(i = left; i <= right; i++) {
    resultAns[up][i] = k++;
}
up++;
//step4: right固定，i从up到down i++, right-1;
for(i = up; i <= down; i++) {
    resultAns[i][right] = k++;
}
right--;
//step5: down固定，i从right到left i--，down-1;
for(i = right; i >= left; i--) {
    resultAns[down][i] = k++;
}
down--;
//step6: left固定，i从down到up i--，left+1;
for(i = down; i >= up; i--) {
    resultAns[i][left] = k++; 
}
left++;
}
return resultAns;
}