python實現二叉樹的建立以及遍歷（遞歸前序、中序、后序遍歷，隊棧前序、中序、后序、層次遍歷）

#-*- coding:utf-8 -*-
class Node:
    def __init__(self,data):
        self.data=data
        self.lchild=None
        self.rchild=None

class Tree:
    def __init__(self):
        self.queue=[]#利用隊列存儲樹的節點
        self.flag=0#存儲樹根后flag置為1
        self.root=None

    #建樹
    def createTree(self,list):
        while True:
            #list中沒有數據，表示建樹完成
            if len(list)==0:
                return
            #flag為0，表示樹根不存在
            if self.flag==0:
                self.root=Node(list[0])
                #講樹根存入隊列
                self.queue.append(self.root)
                #樹根已創建，flag置為1
                self.flag=1
                #剔除list中第一個已經使用數
                list.pop(0)
            else:
                '''
                treeNode:隊列中的第一個節點(該節點左右孩子不完全存在)
                添加treeNode的左右孩子，當添加treeNode的右孩子之后，
                將隊列中的第一個節點出隊。
                '''
                treeNode=self.queue[0]
                if treeNode.lchild==None:
                    treeNode.lchild=Node(list[0])
                    self.queue.append(treeNode.lchild)
                    list.pop(0)
                else:
                    treeNode.rchild = Node(list[0])
                    self.queue.append(treeNode.rchild)
                    list.pop(0)
                    self.queue.pop(0)


    # 遞歸實現先序遍歷
    def front_digui(self,root):
        if root==None:
            return
        else:
            print root.data,
            self.front_digui(root.lchild)
            self.front_digui(root.rchild)
    # 遞歸實現中序遍歷
    def middle_digui(self,root):
        if root==None:
            return
        else:
            self.middle_digui(root.lchild)
            print root.data,
            self.middle_digui(root.rchild)
    # 遞歸實現后序遍歷
    def behind_digui(self,root):
        if root==None:
            return
        else:
            self.behind_digui(root.lchild)
            self.behind_digui(root.rchild)
            print root.data,

    # 隊棧實現先序遍歷
    def front_queueAndStack(self,root):
        if root==None:
            return
        #定義一個棧,存儲節點
        stack=[]
        node=root
        while stack or node:
            #從樹根開始一直輸出左孩子
            while node:
                print node.data,
                #將輸出的節點加入棧中
                stack.append(node)
                node=node.lchild
            #該節點不存在左節點時,該節點出棧,搜索該節點右節點，
            node=stack.pop()
            node=node.rchild
    # 隊棧實現中序遍歷
    def middle_queueAndStack(self,root):
        if root==None:
            return
        # 定義一個棧,存儲節點
        stack = []
        node = root
        while stack or node:
            #一直查找樹的左節點,一直進棧
            while node:
                stack.append(node)
                node=node.lchild
            node=stack.pop()#該節點不存在左節點，該節點出棧，查找右節點
            print node.data,
            node=node.rchild
    # 隊棧實現后序遍歷
    def behind_queueAndStack(self,root):
        if root==None:
            return
        # 定義一個棧,存儲節點
        stack_1 = []
        stack_2 = []
        node = root
        stack_1.append(node)
        while stack_1:
            #該節點出棧1.左右節點進棧1(對於左右節點,右節點先出棧1,也先進棧1)
            node=stack_1.pop()
            if node.lchild:
                stack_1.append(node.lchild)
            if node.rchild:
                stack_1.append(node.rchild)
            #該節點進棧2
            stack_2.append(node)
        while stack_2:
            print stack_2.pop().data,
    # 隊棧實現層次遍歷
    def level_queueAndStack(self,root):
        if root==None:
            return
        stack_1=[]
        stack_2=[]
        stack_1.append(root)
        stack_2.append(root)
        while stack_1:
            node=stack_1.pop(0)
            if node.lchild:
                stack_1.append(node.lchild)
                stack_2.append(node.lchild)
            if node.rchild:
                stack_1.append(node.rchild)
                stack_2.append(node.rchild)
        while stack_2:
            print stack_2.pop(0).data,


if __name__ == '__main__':
    list=[0,1,2,3,4,5,6,7,8,9,]
    tree=Tree()
    tree.createTree(list)
    tree.front_digui(tree.root)
    print '\n'
    tree.middle_digui(tree.root)
    print '\n'
    tree.behind_digui(tree.root)
    print '\n'
    tree.front_queueAndStack(tree.root)
    print '\n'
    tree.middle_queueAndStack(tree.root)
    print '\n'
    tree.behind_queueAndStack(tree.root)
    print '\n'
    tree.level_queueAndStack(tree.root)