DAY2 代码随想录跟刷Leetcode977有序数组的平方， Leetcode209长度最小的子数组，Leetcode59螺旋矩阵II

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

文章讲解：代码随想录

Leetcode977. 有序数组的平方

题目要求：给一个有序数组（包括负数），返回每个元素平方后的有序数组。（负的越大，平方之后的结果越大，需要调整位置）

题目的关键是怎么调整平方之后每个数的位置，原数组的元素平方之后最大值只会出现在原数组的两侧（最大的正数、最小的负数），所以我们只需要两个指针，分别指向原数组的收尾。每次判断两个指针指向的元素平方后的大小，更新到新数组的最后一位即可（同时更新指针状态）。

C++：

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int k = nums.size() - 1;
        vector<int> result(nums.size(), 0);
        for (int i = 0, j = nums.size() - 1; i <= j;) {
            if (nums[i] * nums[i] < nums[j] * nums[j]) {
                result[k--] = nums[j] * nums[j];
                j--;
            } else {
                result[k--] = nums[i] * nums[i];
                i++;
            }
        }
        return result;
    }
};

Python：

class Solution(object):
    def sortedSquares(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        i = 0
        j = k = len(nums) - 1
        reloading = list(range(k+1))
        while(i <= j):
            if(nums[i]**2 > nums[j]**2):
                reloading[k] = nums[i] ** 2
                k = k - 1
                i = i + 1
            else:
                reloading[k] = nums[j] ** 2
                j = j - 1
                k = k - 1
        return reloading

Leetcode209. 长度最小的子数组

题目要求：给定一个数组（无序），要求找出和大于目标值的最短子序列长度。

只需要从第一个位置的值开始记录（同时记录累和值、元素个数、最终答案），快指针每移动一次记录累和值，直到大于目标值，将元素个数更新为最终答案。然后移动慢指针，更新各个值，直到累和值小于目标值，再移动快指针，重复上述操作，直到快指针移动到数组末尾，慢指针移动到累和值小于目标值即可。这时的最终答案已经被更新为最小子数组的长度。

C++：
 

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

Python：

class Solution(object):
    def minSubArrayLen(self, target, nums):
        """
        :type target: int
        :type nums: List[int]
        :rtype: int
        """
        result = float("inf")
        i = sum = 0
        for j in range(len(nums)):
            sum += nums[j]
            while (sum >= target):
                subL = j - i + 1
                result = min(result, subL)
                sum -= nums[i]
                i += 1
        return 0 if result == float("inf") else result

Leetcode59. 螺旋矩阵II

题目要求：给定一个正整数n，返回一个n*n的螺旋矩阵。

注意边界，循环更新每个位置的值即可。

C++：

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        int startx = 0, starty = 0;
        int count  = 1;
        int loop = n /2;
        int mid = n / 2;
        vector<vector<int>> List(n, vector<int>(n, 0));

        for (int offset = 1; offset <= loop; ++offset){
          for (int j = starty; j < n - offset; ++j){
            List[startx][j] = count++;
          }
          for (int i = startx; i < n - offset; ++i){
            List[i][n - offset] = count++;
          }
          for (int j = n - offset; j > starty; --j){
            List[n - offset][j] = count++;
          }
          for (int i = n - offset; i > startx; --i){
            List[i][starty] = count++;
          }
          ++startx;
          ++starty;
        }

        if (n%2 == 1){
          List[mid][mid] = count;
        }

        return List;
    }
};

Python：

class Solution(object):
    def generateMatrix(self, n):
        """
        :type n: int
        :rtype: List[List[int]]
        """
        startx, starty = 0, 0
        count = 1
        loop, mid = n // 2, n // 2
        List = [[0] * n for _ in range(n)]
        for offset in range(1, loop + 1):
            for j in range(starty, n - offset, 1):
                List[startx][j] = count
                count += 1
            for i in range(startx, n - offset, 1):
                List[i][n - offset] = count
                count += 1
            for j in range(n - offset, starty, -1):
                List[n - offset][j] = count
                count += 1
            for i in range(n - offset, startx, -1):
                List[i][starty] = count
                count += 1 
            startx += 1
            starty += 1
        if (n % 2 == 1):
            List[mid][mid] = count
        return List