[leetcode] Python(27)--分割数组的最大值(410)、二叉树的前序遍历(144)、二叉树的后序遍历(145)、二叉树的层次遍历(102)、二叉树的最大深度(104)

从零开始的力扣（第二十七天）~

1.分割数组的最大值

给定一个非负整数数组和一个整数 m，你需要将这个数组分成 m 个非空的连续子数组。设计一个算法使得这 m 个子数组各自和的最大值最小。

注意:
数组长度 n 满足以下条件:
1 ≤ n ≤ 1000
1 ≤ m ≤ min(50, n)

示例:
输入:
nums = [7,2,5,10,8]
m = 2

输出:
18

解释:
一共有四种方法将nums分割为2个子数组。
其中最好的方式是将其分为[7,2,5] 和 [10,8]，
因为此时这两个子数组各自的和的最大值为18，在所有情况中最小。
—————————————————————————————————————————

依旧使用二分法的思想，找到所有取值范围，这道题就是最大值范围在数组内最大值（m取数组长度）与数组总和（m取1）之间，每次找到的mid来看数组内的不大于此mid的集合数count与m相比，如果count大，那么说明这个mid小了（因为分的过多了），first=mid+1，反之则last=mid

class Solution:
    def splitArray(self, nums: List[int], m: int) -> int:
        n = len(nums)
        first = max(nums)
        last = sum(nums)
        while first < last:
            mid = (first + last) // 2
            add = 0
            count = 1
            for num in nums:
                add += num
                if add > mid:
                    add = num
                    count += 1
            
            if count > m:
                first = mid + 1
            else:
                last = mid
        return first

2.二叉树的前序遍历

给定一个二叉树，返回它的 前序 遍历。

示例:

输入: [1,null,2,3]

输出: [1,2,3]
进阶: 递归算法很简单，你可以通过迭代算法完成吗？
—————————————————————————————————————————

与之前中序遍历相同，只需要内部在写一次函数，用来把root的值写入ans，否则每次会刷新ans

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        ans = []
        def DFS(root):
            if not root:
                return
            ans.append(root.val)
            DFS(root.left)
            DFS(root.right)
        DFS(root)
        return ans

3.二叉树的后序遍历

给定一个二叉树，返回它的 后序 遍历。

示例:

输入: [1,null,2,3]

输出: [3,2,1]
进阶: 递归算法很简单，你可以通过迭代算法完成吗？
—————————————————————————————————————————

与上相同，只需要更改顺序

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        ans = []
        def DFS(root):
            if not root:
                return
            DFS(root.left)
            DFS(root.right)
            ans.append(root.val)
        DFS(root)
        return ans

4.二叉树的层次遍历

给定一个二叉树，返回其按层次遍历的节点值。 （即逐层地，从左到右访问所有节点）。

例如:
给定二叉树: [3,9,20,null,null,15,7],

返回其层次遍历结果：

[
[3],
[9,20],
[15,7]
]
—————————————————————————————————————————

与之前简单的广度遍历不同，这次要依次遍历每一层，使用双重循环完成每一层的结果输出

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root:
            return []
        ans = []
        queue = [root]
        i = 0
        while queue:
            ans.append([])
            for k in range(len(queue)):
                cur_node = queue.pop(0)
                ans[i] += [cur_node.val]
                if cur_node.left:
                    queue.append(cur_node.left)
                if cur_node.right:
                    queue.append(cur_node.right)
            i += 1
        return ans

5.二叉树的最大深度

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：
给定二叉树 [3,9,20,null,null,15,7]，

返回它的最大深度 3 。
—————————————————————————————————————————

递归法，每次向下取子树时内置参数加1，与之前的最大值作比较，但是这里的ans不知道为什么，如果不变成全局变量是读取不到的，而如果把ans变成列表就可以读取

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if not root:
            return 0
        def DFS(root, i):
            if not root:
                return
            if i > self.ans:
                self.ans = i
            DFS(root.left, i + 1)
            DFS(root.right, i + 1)
        self.ans = 0
        DFS(root, 1)
        return self.ans

以上就是今日经验！