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

977.有序数组的平方

• 1，因为是有序数组，所以会导致，两边大，中间小
  
• 2，又因为要排序所以可以仿照这个特点
  
• 3，从首尾两端，进行排序
  
• 　　代码：

• //平方之后，列顺序 从低到高
  vector<int> sortedSquares(vector<int>& nums) 
  {
      vector<int> result(nums.size());
      int resultId = nums.size() - 1;
  
      //因为有序数组，所以他是两边最大，中间最小，所以可以 从两边往里，找出来最大的数值
      //注意可以不加 l++ r --
      for (int l = 0, r = nums.size() - 1; l <= r;)
      {
          int l_sq = nums[l] * nums[l];
          int r_sq = nums[r] * nums[r];
          if (l_sq > r_sq)
          {
              result[resultId] = l_sq;
              l++;
          }
          else //如果等于的话，是社么情况
          {
              result[resultId] = r_sq;
              r--;
          }
          resultId--;
      }
  
      return result;
  }

长度最小的数组：

1，滑动窗口

注意：

1，起始位置，是要放到最外边

2，只对sum_ 进行while循环，而不是对起始位置，因为起始位置是要动的

3，minLen需要修改

 

 

int minSubArrayLen(int target, vector<int>& nums)
{
    vector<vector<int>> resultList;

    int minLen = INT32_MAX; // INTMax_max不是最大
    
    int sum_ = 0;
    //注意 起始位置 不是每次都是从0开始的
    int i = 0;
    for (int j = 0; j < nums.size(); j++)
    {
        sum_ += nums[j];

        while (sum_ >= target)
        {
            minLen = min(minLen, j - i + 1); // NOTE：需要在 I 之前
            sum_ -= nums[i];
            i++;
        }
    }

    //注意，没有的话，设置成0
    return minLen == INT32_MAX ? 0 : minLen;
}

 螺旋矩阵

难点：

　　1，想象怎么转圈

　　2，意识到转几次圈

　　3，边界值应该怎么选

代码：

vector<vector<int>> generateMatrix(int n)
{
    vector<vector<int>> result(n, vector<int>(n, 0));

    // 难点在于怎么转圈 
    // 以一圈为单位，进行统计
    int startX = 0, startY = 0, subNum = 1;
    int circleNum = 0;
    int val_ = 1;
    //注意奇数的情况
    while (circleNum < (n / 2))
    {
        // i = 0; J 0 -> n -subNum
        for (int j = startY; j < (n - subNum); j++)
        {
            result[startX][j] = val_++;
        }
        // J = n-subNum, I startX -> n-subNum
        for (int i = startX; i < (n - subNum); i++)
        {
            result[i][n - subNum] = val_++;
        }
        // I = n -SubNum; J n-subNum -> startY
        for (int j = n - subNum; j > startY; j--)
        {
            result[n - subNum][j] = val_++;
        }
        // J = startY I : n-subNum -> startX 
        for (int i = n - subNum; i > startX; i--)
        {
            result[i][startY] = val_++;
        }

        startX++;
        startY++;
        subNum++;
        circleNum++;
    }

    if (n % 2 != 0)
    {
        result[n / 2][n / 2] = n * n;
    }
    
    return result;
}