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

1.977 有序数组的平方

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

双指针法

C代码如下：

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

            }


return ans;

}

 总结：

首先该题说了是个有序数组，所以数组平方的最大值不是在最左边就是在最右边，这种情况就可以考虑双指针法，需要定义两个下标，然后将两者的平方进行比较进行排序。

209.长度最小的子数组

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

 窗口滑动方法：

C++代码如下：

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
         int result = INT32_MAX;
         int sum = 0;
         int i = 0;
         int subLength = 0;
          for(int j= 0; j < nums.size(); j++) {
                sum += nums[j];
        
            while (sum >= s) {
                   subLength =(j - i + 1);
                   result = result < subLength ? result : subLength;
                   sum -= nums[i++];
                }
             }
              return result == INT32_MAX ? 0 : result;
         
    }
};

总结：

本题主要运用到滑动窗口方法，通过不断的调节子序列的起始位置和终止位置，窗口就是数的总和>=s 的长度最小的连续子序列，之后当窗口总和大于s时，就说明此时该缩小窗口长度，这样可以简化运算过程，精髓就是不断调节子序列的起始位置。 

   

59.螺旋矩阵II

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

 C代码如下：

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;
     
      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;
}