【代码随想录|数组 997.有序数组的平方，209.长度最小的子数组，59. 螺旋矩阵II】

---

python

一、997.有序数组的平方

997.有序数组的平方-力扣

1.核心代码

问题：原数组有负数，所以顺序会改变。
1、直接排序
2、双指针，因为两端的数可能是最大的，所以从两端开始比较收缩

代码如下（示例）：

（版本一）双指针法
class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        l, r, i = 0, len(nums)-1, len(nums)-1
        res = [float('inf')] * len(nums) # 需要提前定义列表，存放结果；float('inf')表示正无穷；*表示将列表重复len(nums)次
        while l <= r:
            if nums[l] ** 2 < nums[r] ** 2: # 左右边界进行对比，找出最大值；**表示幂
                res[i] = nums[r] ** 2
                r -= 1 # 右指针往左移动
            else:
                res[i] = nums[l] ** 2
                l += 1 # 左指针往右移动
            i -= 1 # 存放结果的指针需要往前平移一位
        return res

python与c++的区别：r- -不能用于表示r减一，只能用r-=1来表示；取长度的表达len

（版本二）暴力排序法
class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        for i in range(len(nums)):
            nums[i] *= nums[i]
        nums.sort()
        return nums

python与c++的区别：for循环条件表达

2.输入输出

还是数组

def sortedSquares(nums):
    """
    :type nums: List[int]
    :rtype: List[int]
    """
    l, r, i = 0, len(nums) - 1, len(nums) - 1
    res = [float('inf')] * len(nums)
    while l <= r:
        if nums[l] ** 2 < nums[r] ** 2:
            res[i] = nums[r] ** 2
            r -= 1
        else:
            res[i] = nums[l] ** 2
            l += 1
        i -= 1
    return res

if __name__=="__main__":
    nums = list(map(int,input().strip().split(',')))
    result = sortedSquares(nums)
    print(result)

3.问题

主要是双指针的思路：实质是通过添加指针，自增减，来减少循环数目
注意列表、无穷大、幂次方、自减、for循环、排序函数的表达

二、209.长度最小的子数组

209.长度最小的子数组-力扣
思路：做这题的时候知道要用滑动窗口，但是自己写的时候左边也可能动，右边也可能动，滑来滑去的很混乱。一定要理顺这个逻辑关系。

其中：求和因为是滑动窗口，每次只要加减最两边的值就可以了

1、首先滑动窗口两个初始点都是最左边
2、左边不变，找到满足条件的右边的值。右边的值通常先给最大的限制条件，也就是和数组的长度比较，在自己用具体案例的时候经常一眼可以看出是最小长度是1个或者是2个时候就最小了，但是代码无法看出，所以r是要遍历到最右端的。
3、再给出目标条件：求和大于目标值，在此目标下存最小长度，并且更新滑动窗口的左边
4、所以滑动窗口的右边是随着大循环遍历的，而左边是在满足条件的情况下才进行更新
5、注意不满足条件的情况

1.核心代码

（版本一）滑动窗口法
class Solution:
    def minSubArrayLen(self, s: int, nums: List[int]) -> int:
        l = len(nums)
        left = 0
        right = 0
        min_len = float('inf')
        cur_sum = 0 #当前的累加值
        
        while right < l:
            cur_sum += nums[right]
            
            while cur_sum >= s: # 当前累加值大于目标值
                min_len = min(min_len, right - left + 1)
                cur_sum -= nums[left]
                left += 1
            
            right += 1
        
        return min_len if min_len != float('inf') else 0

2、输入输出

def minSubArrayLen(target, nums):
    """
    :type target: int
    :type nums: List[int]
    :rtype: int
    """
    n = len(nums)
    l = 0
    r = 0
    minn = float('inf')
    cur = 0
    while r < n:
        cur += nums[r]
        while cur >= target:
            minn = min(minn, r - l + 1)
            cur -= nums[l]
            l += 1
        r += 1
    return minn if minn != float('inf') else 0


if __name__ == "__main__":
    target = int(input())
    nums = list(map(int, input().strip().split(',')))
    result = minSubArrayLen(target,nums)
    print(result)

59.螺旋矩阵 II

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

我自己的算法版本

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

1、中心点另算
2、自己的版本和标准代码最大的不同在于，我把startx、starty和loop统一了，其实他们实质是差不多，上面一个代码中的唯一的区别是loop始终比x、y大1，我用把后面换成n-m-1来解决。

这道题理思路花了一个小时，自己逻辑上还是不够清晰，但最终还是自己完全独立的做出来了，可喜

总结

目前的debug都是看力扣的反馈、chatgpt和对照标准代码，希望从后面开始练习用ide的debug
双指针 滑动窗口