二叉树遍历（python）

注：参考博客 不积跬步无以至千里 ，以这个二叉树为例：

# -*- coding:utf-8 -*-
class TreeNode:
   def __init__(self, x=None, left=None, right=None):
       self.val = x
       self.left = left
       self.right = right
       
class Order:
    def PreOrder(self, pRoot):
        if not pRoot: return []
        return [pRoot.val] + self.PreOrder(pRoot.left) + self.PreOrder(pRoot.right)
        
    def InOrder(self, pRoot):
        if not pRoot: return []
        return self.InOrder(pRoot.left) + [pRoot.val] + self.InOrder(pRoot.right)
        
    def BackOrder(self, pRoot):
        if not pRoot: return []
        return self.BackOrder(pRoot.left) + self.BackOrder(pRoot.right) + [pRoot.val]

class Circle:
    def PreOrder(self, pRoot):
        res, stack = [],[]
        while pRoot or stack:
            if pRoot:
                res.append(pRoot.val)
                stack.append(pRoot.right)
                pRoot = pRoot.left
            else:
                pRoot = stack.pop()
        return res

    def InOrder(self, pRoot):
        res, stack = [],[]
        while pRoot or stack:
            if pRoot:
                stack.append(pRoot)
                pRoot = pRoot.left
            else:
                pRoot = stack.pop()
                res.append(pRoot.val)
                pRoot = pRoot.right
        return res
        
    def BackOrder(self, pRoot):
        res, stack = [],[]
        while pRoot or stack:
            if pRoot:
                res.append(pRoot.val)
                stack.append(pRoot.left)
                pRoot = pRoot.right
            else:
                pRoot = stack.pop()
        return res[::-1]

    def BFS(self, pRoot):
        if not pRoot: return
        queue = [pRoot]
        res = []
        while queue:
            node = queue.pop(0)
            res.append(node.val)
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)
        return res
            
    def DFS(self, pRoot):
        if not pRoot: return
        stack = [pRoot]
        res = []
        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
                
### 新建二叉树 ###          
node5 = TreeNode(5)
node6 = TreeNode(6)
node7 = TreeNode(7)
node8 = TreeNode(8)
node9 = TreeNode(9)
node4 = TreeNode(4, node8, node9)
node3 = TreeNode(3, node6, node7)
node2 = TreeNode(2, node4, node5)
root = TreeNode(1, node2, node3)
 
order = Order()
circle = Circle()
print('前序遍历(根-左-右):',order.PreOrder(root))
print('前序遍历(根-左-右):',circle.PreOrder(root))
print('中序遍历(左-根-右):',order.InOrder(root))
print('中序遍历(左-根-右):',circle.InOrder(root))
print('后序遍历(左-右-根):',order.BackOrder(root))
print('后序遍历(左-右-根):',circle.BackOrder(root))
print('层次遍历:          ',circle.BFS(root))
print('深度优先遍历:      ',circle.DFS(root))