leetcode 94 145 144 binary-tree-inorder / preorder/ postorder - traversal 二叉树中/先/后序遍历 python3【递归 迭代】

时间：2020-7-22

题目地址：

https://leetcode-cn.com/problems/binary-tree-inorder-traversal/

https://leetcode-cn.com/problems/binary-tree-preorder-traversal/

https://leetcode-cn.com/problems/binary-tree-postorder-traversal/

题目难度：

Medium

Medium

Hard

题目描述：

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

示例:

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

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

---

思路1：递归，以中序为例，其他只要调整rooot的处理顺序即可

主要是看了labuladong的算法小抄，几乎所有二叉树的题目都是一套这个框架就出来了。

void traverse(TreeNode root) {
    // 前序遍历
    traverse(root.left)
    // 中序遍历
    traverse(root.right)
    // 后序遍历
}

代码段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 inorderTraversal(self, root: TreeNode) -> List[int]:
        res = []
        def helper(root):
            if root == None: return None
            helper(root.left)
            res.append(root.val)
            helper(root.right)
        helper(root)
        return res

2020-8-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 __init__(self):
        self.res = []
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        self.helper(root)
        return self.res

    def helper(self, root):
        if root == None: return None
        self.helper(root.left)
        self.helper(root.right)
        self.res.append(root.val)
        
        

总结：

1. 了解框架
2. 这两种写法，第一种就看起来优雅很多。

---

思路2：迭代

中序用栈,再用一个指针模拟访问过

代码段2：通过

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

# 中序

class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        res = []
        stack = []
        p = root
        while stack or p:
            while p:
                stack.append(p)
                p = p.left
            p = stack.pop()
            res.append(p.val)
            p = p.right
        return res

# 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]:
        res = []
        if not root:
            return res
        stack = [root]
        while stack:
            node = stack.pop()
            res.append(node.val)
            if node.right:
                stack.append(node.right)
            if node.left:
                stack.append(node.left)
        return res

# 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]:
        res = []
        if not root:
            return res
        stack = [root]
        while stack:
            node = stack.pop()
            if node.left:
                stack.append(node.left)
            if node.right:
                stack.append(node.right)
            res.append(node.val)
        return res[::-1]

总结：

1. 迭代挺折腾的