算法工程师第二天（977.有序数组的平方 ，209.长度最小的子数组 ，59.螺旋矩阵II）

参考文献  代码随想录

一、有序数组的平方

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

示例 1：

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]

示例 2：

输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]

解法1：暴力枚举（先将每个元素平方，然后调用内置函数进行排序）时间复杂度：nlogn

class Solution(object):
    def sortedSquares(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        for i in range(len(nums)):
            nums[i] *= nums[i]
        nums.sort()
        return nums

解法2：双指针（它是有序的，但是存在负数，所以平方后，那么最大值就在数组的两边，left指向左边（0），right指向数组的右边（数组长度-1），如果left平方 > right平方，说明left平方是最大的数，把它添加到新的数组，然后left指针移动，在接下来寻找left所指向元素和right比较，以此类推，）时间复杂度：n

class Solution(object):
    def sortedSquares(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        right = len(nums) - 1
        left = 0
        result = []
        while left <= right:  # 两个指针同时指向了同一个元素
            if nums[left] ** 2 > nums[right] ** 2:  # 因为存在负数，说明最大值，在两边
                result.append(nums[left] * nums[left]) # 则说明左指针指向了最大值，所以要移动left指针
                left += 1
            else:  # nums[left] ** 2 <= nums[right] ** 2   # left == right 说明，指向的元素都一样
                result.append(nums[right] * nums[right])   # 则说明右指针指向了最大值，所以要移动right指针，接着在left指针移动，找寻当前指针能够找到的最大值
                right -= 1
        result.reverse()
        return result

二、 长度最小的子数组

        给定一个含有 n 个正整数的数组和一个正整数 target 。找出该数组中满足其总和大于等于 target 的长度最小的 子数组[numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

示例 1：

输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。

示例 2：

输入：target = 4, nums = [1,4,4]
输出：1

示例 3：

输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0

解法1：暴力枚举（超时）

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

解法2：滑动窗口（双指针），一个for循环，这个for循环是这个窗口的起始位置，定义终止位置，求和，在判断这个和是否大于Target时使用if呢还是while呢，如果使用if，则这个只会找到一次从当前起始位置到终止位置的长度，后面就直接移动起始位置，这会忽略掉例如 [2, 5, 2, 6]，Target = 7, 当起始位值指向下标为0，终止位置指向小标为2时，此时之和是满足的，但是使用了if，它只会找到一次，而无法找到 [5, 2]，因为if只执行一次，那么下一次终止位置就指向了3，所以只能使用while

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

三、 螺旋矩阵 II

        给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。

示例 1：

输入：n = 3
输出：[[1,2,3],[8,9,4],[7,6,5]]

示例 2：

输入：n = 1
输出：[[1]]

class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        nums = [[0] * n for _ in range(n)]
        startx, starty = 0, 0               # 起始点
        loop, mid = n // 2, n // 2          # 迭代次数、n为奇数时，矩阵的中心点
        count = 1                           # 计数

        for offset in range(1, loop + 1) :      # 每循环一层偏移量加1，偏移量从1开始
            for i in range(starty, n - offset) :    # 从左至右，左闭右开
                nums[startx][i] = count
                count += 1
            for i in range(startx, n - offset) :    # 从上至下
                nums[i][n - offset] = count
                count += 1
            for i in range(n - offset, starty, -1) : # 从右至左
                nums[n - offset][i] = count
                count += 1
            for i in range(n - offset, startx, -1) : # 从下至上
                nums[i][starty] = count
                count += 1                
            startx += 1         # 更新起始点
            starty += 1

        if n % 2 != 0 :			# n为奇数时，填充中心点
            nums[mid][mid] = count 
        return nums