Leetcode: Tree

定义

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

102. 二叉树的层次遍历

有两种思路，BFS和DFS，时间复杂度都是O(n)，BFS需要维护一个队列，而DFS是建立一个二维数组

# BFS
class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root: return []
        
        q = [root]
        res = []
        '''
        维护一个队列，
        逐层弹出节点，将结果添加到res，
        同时将子节点加入队列中，为下一次循环做准备
        '''
        while q:
            len_q = len(q)
            cur = []
            for _ in range(len_q): 
                node = q.pop(0)
                cur.append(node.val)
                if node.left: q.append(node.left)
                if node.right: q.append(node.right)   
            res.append(cur)
        return res

# DFS
class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root: return []
        self.result = []
        self._dfs(root, 0)
        return self.result
    
    def _dfs(self, node, level):
        if not node: return # 递归结束条件
        
		# 通过level建立数组的第一维
        if len(self.result) < level + 1:
            self.result.append([])

        self.result[level].append(node.val)

        self._dfs(node.left, level + 1)
        self._dfs(node.right, level + 1)

104/111. 二叉树的最大/小深度

# BFS，判断是否是叶子节点， 第一个到达的叶子节点就是最小深度，最后到达的就是最大深度
class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if not root: return 0
        q = [root]
        depth = 0
        while q:
            q2 = []
            for node in q:
                if node.left: q2.append(node.left)
                if node.right: q2.append(node.right)
            q = q2
            depth += 1
        return depth 
    
class Solution:
    def minDepth(self, root: TreeNode) -> int:
        # BFS
        if not root: return 0
        q = [root]
        depth = 0
        while q:
            q2 = []
            for node in q:
                if node.left: q2.append(node.left)
                if node.right: q2.append(node.right)
                if not node.left and not node.right:
                    return depth + 1
            depth += 1
            q = q2
        return

# DFS + 分治
class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        # DFS
        if not root: return 0   
        return 1 + max(self.maxDepth(root.left), self.maxDepth(root.right))
    
class Solution:
    def minDepth(self, root: TreeNode) -> int:
        if not root: return 0
        # 特殊情况
        if not root.left: return 1 + self.minDepth(root.right)
        if not root.right: return 1 + self.minDepth(root.left)
            
        return 1 + min(self.minDepth(root.left), self.minDepth(root.right))

# DFS，当遇到叶子结点时，将其深度与最大/小值进行比较，记录最大/小值并返回
class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if not root: return 0    
        _max = 0
        for next_node in [root.left, root.right]:
            level = 1 + self.maxDepth(next_node)
            if level > _max: _max = level 
        return _max

class Solution:
    def minDepth(self, root: TreeNode) -> int:
        if not root: return 0
        # 特殊情况
        if not root.left: return 1 + self.minDepth(root.right)
        if not root.right: return 1 + self.minDepth(root.left)
        
        _min = 999
        for next_node in [root.left, root.right]:
            level = 1 + self.minDepth(next_node)
            if level < _min: _min = level 
        return _min

145. Binary Tree Postorder Traversal

迭代法

class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        res = []
        stack = []
        pre = None
        while stack or root:
            if root:
                stack.append(root)
                root = root.left
            else:
                root = stack[-1]
                # 若当前结点没有右结点，或其右节点为上一次访问的结点，则当前结点出栈
                if not root.right or root.right == pre:
                    res.append(root.val)
                    pre = root
                    root = None
                    stack.pop()
                else:
                    root = root.right
        return res

这里比较巧妙，后序遍历是左右根，前序遍历是根左右，
这里用前序遍历根右左，然后反向结果列表，更容易理解，但不容易想到

class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        if not root: return []
        stack = [root]
        res = []
        while stack:
            node = stack.pop()
            res.append(node.val)
            if node.left:
                stack.append(node.left)
            if node.right:
                stack.append(node.right)
        return res[::-1]