python 实现二叉树遍历

二叉树分为深度优先遍历以及广度优先遍历，深度优先遍历可以分为先序遍历 、中序遍历、后序遍历。广度优先遍历即层次遍历。

# 定义二叉树节点
class Node(object):
    def __init__(self, item=0, lchild=None, rchild=None):
        self.item = item
        self.lchild = lchild
        self.rchild = rchild

# 二叉树遍历
class Tree(object):
    def __init__(self, root):
        self.root = root
	# 先序遍历递归
    def preorderTraversal(self, root):
        if root == None:
            return []
        res = []
        res.append(root.item)
        res += self.preorderTraversal(root.lchild)
        res += self.preorderTraversal(root.rchild)
        return res
	# 先序遍历非递归方式
	# 把root压入栈中，弹出压入结果列表，把弹出的节点左右孩子压入节点 然后重复循环。
    def preorderTraversal1(self,root):
        if root == None:
            return []
        res = []
        stack = []
        stack.append(root)
        while stack:
            root = stack.pop()
            res.append(root.item)
            if root.rchild:
                stack.append(root.rchild)
            if root.lchild:
                stack.append(root.lchild)
        return res
	#中序递归
    def inorderTraversal(self,root):
        if root==None:
            return []
        res = []
        res += self.inorderTraversal(root.lchild)
        res.append(root.item)
        res += self.inorderTraversal(root.rchild)
        return res
	# 中序非递归
	# root压入stack栈中，root有左节点，则压入栈，root = root.lchild 找到最左节点.
	#没有左节点后，弹出栈压入另一个列表，找是否有右节点，有的话将右节点压入栈中
    def inorderTraversal1(self, root):
        if root == None:
            return []
        res = []
        stack = []
        while stack or root:
            if root:
                stack.append(root)
                root = root.lchild
            else:
                root = stack.pop()
                res.append(root.item)
                root = root.rchild
        return res


	# 后序递归
    def postorderTraversal(self,root):
        if root==None:
            return []
        res = []
        res += self.postorderTraversal(root.lchild)
        res += self.postorderTraversal(root.rchild)
        res.append(root.item)
        return res
	# 后序非递归
	# 准备两个栈 s1、s2 。s1压入root值，将root值弹出 
	# 压入s2 并将root的左节点,右节点依次压入s1 依次重复
    # 直至s1 为空 依次将s2出栈即为后序遍历
    def postorderTraversal1(self, root):
        if root == None:
            return []
        res = []
        stack = []
        stack.append(root)
        while stack:
            root = stack.pop()
            res.append(root.item)
            if root.lchild:
                stack.append(root.lchild)
            if root.rchild:
                stack.append(root.rchild)
        return res[::-1]
    # 层次遍历 root存入队列，弹出 把其左右节点压入队列，重复
    def levelTraversal(self, root):
        if root == None:
            return []
        queue = []
        res = []
        queue.append(root)
        while queue:
            root = queue.pop(0)
            res.append(root.item)
            if root.lchild:
                queue.append(root.lchild)
            if root.rchild:
                queue.append(root.rchild)
        return res






if __name__ == '__main__':
    n4 = Node(4)
    n5 = Node(5)
    n6 = Node(6)
    n7 = Node(7)
    n2 = Node(2, n4, n5)
    n3 = Node(3, n6, n7)
    n1 = Node(1, n2, n3)
    tree_node = Tree(n1)
    print(tree_node.preorderTraversal(n1))
    print(tree_node.preorderTraversal1(n1))
    print(tree_node.inorderTraversal(n1))
    print(tree_node.inorderTraversal1(n1))
    print(tree_node.postorderTraversal(n1))
    print(tree_node.postorderTraversal1(n1))