力扣算法打卡第二天（数组） | 977. 有序数组的平方、209. 长度最小的子数组、59. 螺旋矩阵 II

977.有序数组的平方

题目链接：力扣977
思路：双指针

因为数组有序，且存在负数，所以数组元素平方后的最大元素一定在两边，大小会从两边向内递减，所以左右指针指向数组左右边界，向内遍历。

完整代码：

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        left, right = 0, len(nums) - 1
        index = len(nums) - 1
        res = [-1] * len(nums)

        while left <= right:
            if pow(nums[left], 2) > pow(nums[right], 2):
                res[index] = pow(nums[left], 2)
                left += 1
            else:
                res[index] = pow(nums[right], 2)
                right -= 1 
            index -= 1
        return res

209. 长度最小的子数组

题目链接：力扣209
思路：滑动窗口（双指针）

使用右指针遍历数组，当sum满足条件时移动左指针，尝试缩小子数组大小，用res记录目前所有符合条件的子数组里最小的数组

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        res = float("INF")  # 正无穷,res存放目前搜索到的子序列中最小的符合条件的长度
        sum = 0  # 当前窗口内元素和
        left, right = 0, 0 
        for right in range(len(nums)):
            sum += nums[right]
            while sum >= target:
                subl = right - left + 1  # 当前窗口长度
                res = min(res, subl)
                sum -= nums[left]
                left += 1
                
        if res < float("INF"):
            return res
        else:
             return 0

59. 螺旋矩阵

题目链接：力扣59
思路：模拟

注意循环不变量，也就是注意边界点交给那条边处理
遍历方式：如图（图片源自代码随想录网站），最后一个点交给下一条边处理

n-offset为每次循环圈里的边界值数组下标，到下一圈时加1

class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        res = [[0] * n for _ in range(n)]
        cnt = 1  # 需要填入的数
        round = n//2  # 需要遍历的圈数
        startx, starty = 0, 0  # 当前遍历圈起始的横纵坐标
        offset = 1  # 控制上下左右每条边遍历的长度，每次循环加1
        while round > 0:
            for j in range(starty, n - offset):
                res[startx][j] = cnt
                cnt += 1
            for i in range(startx, n-offset):
                res[i][n - offset] = cnt
                cnt += 1
            for j in range(n - offset, starty, -1):
                res[n - offset][j] = cnt
                cnt += 1
            for i in range(n - offset, startx, -1):
                res[i][starty] = cnt
                cnt += 1
            startx += 1
            starty += 1
            offset += 1
            round -= 1
        if n%2 == 1: #  因为round是整除的n，所以n为奇数时，中心点需要额外处理
            res[n//2][n//2] = cnt
        return res