Day2 数组：977.有序数组的平方 209.长度最小的子数组 59.螺旋矩阵Ⅱ

977.有序数组的平方

977.有序数组的平方https://link.juejin.cn/?target=https%3A%2F%2Fleetcode.cn%2Fproblems%2Fsquares-of-a-sorted-array%2F1.暴力解法：

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

 每个数平方之后，排个序         暴力排序解法O(n + nlog n)

2.双指针法

由于负数的存在，负数平方之后可能就会成为最大数，因此数组平方后的最大值就应该在数组的两端，不是最左边就是最右边，不可能是中间。

此时可以考虑双指针法，i指向起始位置，j指向终止位置。

定义一个新的数组result来装进行平方之后的数组元素。

定义一个索引下标，k = nums.size() - 1; 下标的作用：新的数组要从大到小来更新

因为每次取的时候都是取了一个最大值（两头向中间取，先取最大，再取次大）。

这样的话，更新result数组也要下标由大到小来更新，最后得到的这个result数组才是一个按非递减顺序排序（元素从小到大）的集合。

通过for循环定义2个下标 i 和 j ，

循环终止的条件：只要 i <= j 就继续执行该循环

（版本一）双指针法
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) # 需要提前定义列表，存放结果
        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


#First try
class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        left = 0
        right = len(nums) - 1
        i = len(nums) - 1
        result = [0] * len(nums)
        while left <= right:
            if nums[left] * nums[left] > nums[right] * nums[right]:
                result[i] = nums[left] * nums[left]
                i -= 1 
                left += 1
            else:
                result[i] = nums[right] * nums[right]
                i -= 1
                right -= 1
        return result
      

res = [0.0] * len(nums)  # 用 0 初始化结果数组 不用写成list[0], [0]已经是list.  i-=1 可以放在if else外面，省去一行。

209.长度最小的子数组

209.长度最小的子数组https://link.juejin.cn/?target=https%3A%2F%2Fleetcode.cn%2Fproblems%2Fminimum-size-subarray-sum%2F

最直接的想法：2层for循环进行遍历：第一层for循环控制区间的起始位置，第二层for循环控制区间的终止位置。

把数组的所有区间情况都遍历出来，然后找到 >= target 的最小区间长度。
在这个区间里面不断搜索，把所有区间情况都枚举出来，然后判断 >= target 的最小长度是多少，最后返回这个最小长度。

（版本二）暴力法
class Solution:
    def minSubArrayLen(self, s: int, nums: List[int]) -> int:
        l = len(nums)
        min_len = float('inf')
        
        for i in range(l):
            cur_sum = 0
            for j in range(i, l):
                cur_sum += nums[j]
                if cur_sum >= s:
                    min_len = min(min_len, j - i + 1)
                    break
        
        return min_len if min_len != float('inf') else 0

• 时间复杂度：O(n^2)
• 空间复杂度：O(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

#FT

class Solution:
    def minSubArrayLen(self, target: 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 >= target:
                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

不能单独return min_len 需要加上判别为0的情况 if min_len != float('inf') else 0

while right<l 是len(nums) NOT left.因为右指针要从末端开始计算，否则跟暴力解法没区别。从而将O(n^2)暴力解法降为O(n)

59.螺旋矩阵Ⅱ

题目链接：59.螺旋矩阵Ⅱ

不过转圈这个过程需要处理的边界条件很多。

左闭右开，处理第一个节点，最后一个节点留给下一条边遍历的时候再做处理，这样4条边的遍历规则就统一了。

每一条规则都需要仔细揣摩，搞明白。for中的条件跟nums[i][j] 对应的角标

• 时间复杂度 O(n^2): 模拟遍历二维矩阵的时间
• 空间复杂度 O(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

 需要弄清楚

1.if n % 2 != 0

这个条件用于检查 n 是否是奇数。n % 2 表示 n 除以 2 的余数。如果余数不等于 0，则 n 是一个奇数。
 

2.if n / 2 != 0

这个条件用于检查 n 除以 2 的结果是否不等于 0。n / 2 是浮点除法，结果总是一个浮点数。当 n 不为 0 时，n / 2 总是不为 0，因此这个条件检查 n 是否不为 0。

3.if n // 2 != 0

这个条件用于检查 n 整除 2 的结果是否不等于 0。n // 2 是整数除法，结果是 n 除以 2 的整数商。当 n 小于 2 时，n // 2 为 0；当 n 大于或等于 2 时，n // 2 不为 0。