Python实现二叉树的遍历（前序，中序，后序，层级，深度）

前序遍历：前序遍历算法先访问树的根节点，然后以类似的方式分别遍历左子树和右子树，如下图所示

中序遍历：中序遍历算法先遍历左子树，然后访问根节点，最后遍历右子树，如下图所示：

后序遍历：后序遍历算法先遍历左子树，然后右子树，最后访问根节点， 如下图所示：

层序遍历： 层序遍历的算法从0层级开始，在每一层级按照从左到右的顺序访问节点，如下图所示：

 

用Python来实现：

#coding=utf-8

#节点
class Node(object):
    def __init__(self, elem=-1, left=None, right=None):
        self.elem = elem
        self.left = left
        self.right = right

#树
class Tree(object):
    def __init__(self):
        self.root = Node()
        self.myQueue = []

    def add(self,elem):
        # 为树加入节点
        node  = Node(elem)
        if self.root.elem == -1:        #如果树为空，就对根节点赋值
            self.root = node
        else:
            myQueue = []
            treeNode = self.root
            myQueue.append(treeNode)
            while myQueue:              #对已有的节点进行层次遍历
                treeNode = myQueue.pop(0)
                if not treeNode.left:
                    treeNode.left = node
                    return
                elif not treeNode.right:
                    treeNode.right = node
                    return
                else:
                    myQueue.append(treeNode.left)
                    myQueue.append(treeNode.right)



    #前序遍历
    def front_digui(self, root):
        if root == None:
            return
        print(root.elem)
        self.front_digui(root.left)
        self.front_digui(root.right)

    #中序遍历
    def middle_digui(self, root):
        if root == None:
            return
        self.middle_digui(root.left)
        print(root.elem)
        self.middle_digui(root.right)

    #后序遍历
    def later_digui(self, root):
        if root == None:
            return
        self.later_digui(root.leftd)
        self.later_digui(root.right)
        print(root.elem)

    #层级遍历
    def level_list(self, root):
        if root == None:
            return
        myList = []
        node = root
        myList.append(node)
        while myList:
            node = myList.pop(0)
            print(node.elem)
            if node.left != None:
                myList.append(node.left)
            if node.right != None:
                myList.append(node.right)
   
    #深度遍历    
    def TreeDepth(self,root):
        if not root: #空的返回0
            return 0
        left = self.TreeDepth(root.left)+1   #向左延伸
        right = self.TreeDepth(root.right)+1 #向右延伸
        print(max(left, right)) #打印最大的


if __name__ == '__main__':
    nums = range(10)           #生成十个数据作为树节点
    tree = Tree()              #新建一个树对象
    for elem in nums:                  
        tree.add(elem)         #逐个添加树的节点

    print ('递归实现先序遍历:',tree.front_digui(tree.root))
  
    print ('递归实现中序遍历:' ,tree.middle_digui(tree.root))
    
    print ('递归实现后序遍历:',tree.later_digui(tree.root))

    print ('队列实现层次遍历:',tree.level_list(tree.root))

    print ('递归实现深度遍历:',tree.TreeDepth(tree.root))