42. Leetcode 144. 二叉树的前序遍历 (二叉树-二叉树遍历)

给你二叉树的根节点 root ，返回它节点值的 前序 遍历。

 

示例 1：


输入：root = [1,null,2,3]
输出：[1,2,3]
示例 2：

输入：root = []
输出：[]
示例 3：

输入：root = [1]
输出：[1]
示例 4：


输入：root = [1,2]
输出：[1,2]
示例 5：


输入：root = [1,null,2]
输出：[1,2]


方法 1—— 递归

定义函数 preorderTraversal(self, node)

很明显要满足根 ➜ 左 ➜ 右的规则，应该返回

[node.val] + preorderTraversal(self, node.left) + preorderTraversal(self, node.right)


# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        # 方法一 递归
        if root == None:
            return []

        output = []
        output.append(root.val)
        output += self.preorderTraversal(root.left)
        output += self.preorderTraversal(root.right)

        return output


方法 2—— 迭代 递归算法使用系统栈，不好控制，性能问题比较严重，需要进一步了解不用递归如何实现。
为了维护固定的访问顺序，使用栈数据结构的先入后出特性。

先处理根节点，根据访问顺序根 ➜ 左 ➜ 右，先入栈的后访问，为了保持访问顺序(先入 后出)，先把右孩子入栈，再入栈左孩子(此处需要注意，出栈才是访问顺序)


# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        # 方法一 递归
        # if root == None:
        #     return []

        # output = []
        # output.append(root.val)
        # output += self.preorderTraversal(root.left)
        # output += self.preorderTraversal(root.right)

        # return output

        # 方法二 迭代
        if root == None:
            return []
        
        stack = [root]
        output = []
        while stack:
            root = stack.pop()
            if root != None:
                stack.append(root.right)
                stack.append(root.left)
                output.append(root.val)

        return output


方法 3—— 颜色标记法 其核心思想是使用颜色标记节点的状态，新节点为白色，已访问的节点为灰色:

如果遇到的节点为白色，则将其标记为灰色，然后将其右子节点、左子节点、自身依次入 栈。

如果遇到的节点为灰色，则将节点的值输出。

颜色标记法的优势:

兼具栈迭代方法的高效，又像递归方法一样简洁易懂，更重要的是， 这种方法对于前序、中序、后序遍历，能够写出完全一致的代码。


# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:

        # 方法三 颜色标记法
        if root == None:
            return []
        WHITE, GARY = 0, 1
        stack = [(WHITE, root)]
        output = []
        while stack:
            color, root = stack.pop()
            if root != None:
                if color == WHITE:
                    stack.append((WHITE, root.right))
                    stack.append((WHITE, root.left))
                    stack.append((GARY, root))
                else:
                    output.append(root.val)

        return output