【简单递归】二叉树的前、中、后序遍历

前序遍历：首先访问根结点，然后遍历左子树，最后遍历右子树（根->左->右）
顺序：访问根节点->前序遍历左子树->前序遍历右子树

中序遍历：首先遍历左子树，然后访问根节点，最后遍历右子树（左->根->右）

顺序：中序遍历左子树->访问根节点->中序遍历右子树

后序遍历：首先遍历左子树，然后遍历右子树，最后访问根节点（左->右->根）

顺序：后序遍历左子树->后序遍历右子树->访问根节点

前序遍历A-B-D-F-G-H-I-E-C

中序遍历F-D-H-G-I-B-E-A-C

后序遍历F-H-I-G-D-E-B-C-A

前序(根左右)，中序(左根右)，后序(左右根)

（一）
给出一棵二叉树，返回其节点值的前序遍历。

$\bullet$首个数据为根节点，后面接着是其左儿子和右儿子节点值，"#"表示不存在该子节点。
$\bullet$节点数量不超过20

样例
样例 1：

输入：

二叉树 = {1,2,3}

输出：

[1,2,3]

样例 2：
输入：

二叉树 = {1,#,2,3}

输出：

[1,2,3]

"""
Definition of TreeNode:
class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left, self.right = None, None
"""
# Version 0: Recursion
class Solution:
    """
    @param root: A Tree
    @return: Preorder in ArrayList which contains node values.
    """
    def preorderTraversal(self, root):
        # write your code here
        self.results = []
        self.traverse(root)
        return self.results

    def traverse(self,root):
        if root is None:
            return
        self.results.append(root.val)
        self.traverse(root.left)
        self.traverse(root.right)
# Version 1: Non-recursion
class Solution:
    """
    @param root: The root of binary tree.
    @return: Preorder in list which contains node values.
    """
    def preorderTraversal(self, root):
        if root is None:
            return []
        
        stack = [root]
        preorder = []
        while stack:
            node = stack.pop()
            preorder.append(node.val)
            if node.right:
                stack.append(node.right)
            if node.left:
                stack.append(node.left)
        return preorder
# Version 2:
"""
Definition of TreeNode:
class TreeNode:
    def __init__(self, val):
        this.val = val
        this.left, this.right = None, None
"""
class Solution:
    """
    @param root: The root of binary tree.
    @return: Preorder in list which contains node values.
    """
    def preorderTraversal(self, root):
        if root is None:
            return []
        
        return [root.val] + self.preorderTraversal(root.left) + self.preorderTraversal(root.right)

（二）
描述
给出一棵二叉树,返回其中序遍历。
（常考查中序遍历的非递归版本）
样例 1：
输入：

二叉树 = {1,2,3}

输出：

[2,1,3]

样例 2：
输入：

二叉树 = {1,#,2,3}

输出：

[1,3,2]

# Version 0: Non-Recursion
"""
Definition of TreeNode:
class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left, self.right = None, None
"""

class Solution:
    """
    @param root: A Tree
    @return: Inorder in ArrayList which contains node values.
    """
    def inorderTraversal(self, root):
        # write your code here
        if not root:
            return []

        result = []
        stack = []

        while root:
            stack.append(root)
            root = root.left
        
        while stack:
            curNode = stack.pop()
            result.append(curNode.val)

            if curNode.right:
                curNode = curNode.right
                while curNode:
                    stack.append(curNode)
                    curNode = curNode.left

        return result   

# Version 1: Recursion
"""
Definition of TreeNode:
class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left, self.right = None, None
"""

class Solution:
    """
    @param root: A Tree
    @return: Inorder in ArrayList which contains node values.
    """
    def inorderTraversal(self, root):
        # write your code here
        if not root:
            return []

        return self.inorderTraversal(root.left) + [root.val] + self.inorderTraversal(root.right)

（三）
描述
给出一棵二叉树，返回其节点值的后序遍历。

# Version 0: Recursion
"""
Definition of TreeNode:
class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left, self.right = None, None
"""
class Solution:
    """
    @param root: A Tree
    @return: Postorder in ArrayList which contains node values.
    """
    def postorderTraversal(self, root):
        # write your code here
        if not root:
            return []

        return self.postorderTraversal(root.left) + self.postorderTraversal(root.right) + [root.val]


# Version 1: Non-Recursion(Iteration)

"""
Definition of TreeNode:
class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left, self.right = None, None
"""

class Solution:
    """
    @param root: A Tree
    @return: Postorder in ArrayList which contains node values.
    """
    def postorderTraversal(self, root):
        # write your code here
        if not root:
            return []
        
        stack = []
        result = []
        cur = root

        # cur为当前节点，添加在stack列表尾部
        # 若cur有左孩子，cur向左移动；否则，cur向右移动
        # 直到cur为当前最左节点，停止遍历
        while cur:
            stack.append(cur)
            if cur.left:
                cur = cur.left
            else:
                cur = cur.right
        
        while stack:
            cur = stack.pop()              # stack不为空，弹栈
            result.append(cur.val)         # 并添加到result中
            if stack and stack[-1].left == cur:
                cur = stack[-1].right           # 如果stack不为空，且当前stack[-1]的左节点是刚才弹栈的那个，cur现在变成它的右节点
                while cur:                          # 如果cur存在，则继续遍历，并存于stack中，否则停止循环，回到上一个循环，开始弹栈并添加到result中
                    stack.append(cur)
                    if cur.left:
                        cur = cur.left
                    else:
                        cur = cur.right

        return result