代码随想录算法训练营 Day2｜数组2

代码随想录算法训练营 Day2｜977.有序数组的平方 ，209.长度最小的子数组 ，59.螺旋矩阵II.md

LeetCode 977.有序数组的平方

思路

利用python的sort方法，先平方，再排序。
时间复杂度O(n)+sort()方法的时间复杂度

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        for i in range(len(nums)):
            nums[i] = nums[i] ** 2
        nums.sort()
        return nums

看了文章后，看了图

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        length = len(nums)
        front = 0
        back = length - 1
        result = [0] * length
        cur = length - 1
        while front <= back:
            if nums[front] ** 2 >= nums[back] ** 2:
                result[cur] = nums[front] ** 2
                front += 1
            else:
                nums[back] ** 2 > nums[front] ** 2
                result[cur] = nums[back] ** 2
                back -= 1
            cur -= 1
        return result

res = [float('inf')] * len(nums) # 需要提前定义列表，存放结果
定义新列表 无限大值

Python List sort()方法

描述
sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。
语法
sort()方法语法：

list.sort(cmp=None, key=None, reverse=False)
reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。

LeetCode 209. 长度最小的子数组

思路

暴力法
两层for循环遍历
尝试写代码：

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        cur = 0
        count = 0
        result = 0
        for i in range(len(nums)):
            for j in range(i, len(nums)):
                cur += nums[j]
                count += 1
                if cur >= target:
                    if not result:
                        result = count
                    else: 
                        result = min(result, count)
                    break
            cur = 0
            count = 0
        return result

超出时间限制

根据代码随想录
要点：

1. 滑动窗口法，也属于双指针
2. 滑动窗口思路：用一个for循环，下标j代表终止位置，起始位置需要一个动态指针
3. 滑动窗口中的和大于等于目标值，移动起始位置

最终代码：滑动窗口法：

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        start = 0
        result = float('inf')
        sum = 0
        for end in range(len(nums)):
            sum += nums[end]
            while sum >= target:
                length = end - start + 1
                result = min(result, length)
                sum -= nums[start]
                start += 1
        if result == float('inf'):
            return 0
        return result

LeetCode 59. 螺旋矩阵 II

思路

暴力解法，新建一个nxn的二维列表，按照大小顺讯依次填入。
在写具体代码过程中，发现矩阵的螺旋性很难表示出来，不知道如何设置i和j，才能保证可以按照大小顺序依次填入。
不知道如何判断终止条件，怎么样才算

第二次写
尝试以四种不同的方向代替遍历的顺序
以最终数是否为n*n为终止条件

尝试写代码：

class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        result = [[0] * n for _ in range(n)]
        count = 1
        i = 0
        j = 0
        direction = 1  # 四个方向，代表四条边不同的遍历方向
        l = n  # 控制每次遍历的终止位置
        while count <= n * n:  # 如果所有的数都放入结果中，则结束
            if direction == 1:
                result[i][j] = count
                j += 1
                if j == l - 1:  # 如果遍历到最后一个数，此时还没有填充该数，放到下一个方向的第一个填充
                    direction = 2
            elif direction == 2:
                result[i][j] = count
                i += 1
                if i == l - 1:
                    direction = 3
            elif direction == 3:
                result[i][j] = count
                j -= 1
                if j == n - l:
                    direction = 4
                    l -= 1 # 此时需要进入下一个loop，每次填充的数都要减一
            elif direction == 4:
                result[i][j] = count
                i -= 1
                if i == n - l:
                    direction = 1
            count += 1
        return result

成功通过！

根据代码随想录
本题不涉及算法，就是模拟过程