二叉树的前序、中序、后序、层序遍历的Python实现（代码+部分注释）

二叉树的前中后序遍历可以用递归和迭代两种方式实现，层序遍历使用BFS（广度优先搜索）实现。

下面直接手写代码，使用的是Python3.

首先是前序遍历：两种方法

#按照Leetcode的格式来写
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 = []
        def Temp(root):
            #临界条件要考虑好
            if root is None:
                return 
            res.append(root.val)
            Temp(root.left)
            Temp(root.right)
        Temp(root)
        return res

#按照Leetcode的格式来写
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 = []
        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

中序遍历：两种方法

#按照Leetcode的格式来写
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 Temp(root):
            if root is None:
                return
            Temp(root.left)
            res.append(root.val)
            Temp(root.right)
        Temp(root)
        return res

#按照Leetcode的格式来写
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 p or stack:
            while p:
                stack.append(p)
                p = p.left #所有的左子树根节点压进栈，再pop出来
            temp = stack.pop()
            res.append(temp.val)
            p = p.right #有右子树就对右子树执行同样的操作
        return res

后序遍历：两种方法

#按照Leetcode的格式来写
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 = []
        def Temp(root):
            if root is None:
                return
            Temp(root.left)
            Temp(root.right)
            res.append(root.val)
        Temp(root)
        return res

#按照Leetcode的格式来写
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 = []
        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] #关键再这,我们是从根节点开始以根节点->右->左的方式进栈，那么也就是后序遍历的逆序操作。

层序遍历：BFS

#按照Leetcode的格式来写
class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

#层序遍历BFS   
class Solution:
    def LevelorderTraversal(self, root: TreeNode) -> List[int]:
        if root is None:
            return
        res, cur_level = [], [root]
        while cur_level:
            temp = []
            next_level = []
            for i in cur_level:
                temp.append(i.val)
                if i.left:
                    next_level.append(i.left)
                if i.right:
                    next_level.append(i.right)
            res.append(temp) #层序遍历每一层都是一个一维数组
            cur_level = next_level #不像之前的pop，这里直接是把每一层的左右子树直接赋值给cur_level.
        return res #res的结果形式是类似于：[[...], [...], [...]]

以上就是用Python来做这四种遍历的情况。