python实现二叉树，前序遍历，中序遍历，后续遍历

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

' a test module '

__author__ = 'Zhang Shuai'


class Node():
    def __init__(self, data=-1, lchild=None, rchild=None):
        self._data = data
        self._lchild = lchild
        self._rchild = rchild

    @property
    def data(self):
        return self._data

    @data.setter
    def data(self, data):
        self._data = data

    @property
    def lchild(self):
        return self._lchild

    @lchild.setter
    def lchild(self, lchild):
        self._lchild = lchild

    @property
    def rchild(self):
        return self._rchild

    @rchild.setter
    def rchild(self, rchild):
        self._rchild = rchild


class BinaryTree():
    def __init__(self):
        self.root = Node()

    def isEmpty(self):
        return True if self.root.data == -1 else False

    def add(self, data):
        node = Node(data)
        if self.isEmpty():
            self.root = node
        else:
            tree_node = self.root
            queue = []
            queue.append(tree_node)
            while queue:
                tree_node = queue.pop(0)
                if tree_node.lchild is None:
                    tree_node.lchild = node
                    return
                elif tree_node.rchild is None:
                    tree_node.rchild = node
                    return
                else:
                    queue.append(tree_node.lchild)
                    queue.append(tree_node.rchild)

    def pre_order(self, start):
        node = start
        if node is None:
            return
        print(node.data)
        self.pre_order(node.lchild)
        self.pre_order(node.rchild)

    def pre_order_loop(self):
        if self.isEmpty():
            return
        stack = []
        now_node = self.root
        while now_node or stack:
            while now_node:
                print(now_node.data)
                stack.append(now_node)
                now_node = now_node.lchild

            if stack:
                now_node = stack.pop()
                now_node = now_node.rchild

    def in_order(self, start):
        node = start
        if node is None:
            return
        self.in_order(node.lchild)
        print(node.data)
        self.in_order(node.rchild)


    def in_order_loop(self,):
        if self.isEmpty():
            return
        stack = []
        now_node = self.root
        while now_node or stack:
            while now_node:
                stack.append(now_node)
                now_node = now_node.lchild
            if stack:
                now_node = stack.pop()
                print(now_node.data)
                now_node = now_node.rchild

    def post_order(self, start):
        node = start
        if node == None:
            return
        self.post_order(node.lchild)
        self.post_order(node.rchild)
        print(node.data)

     def post_order_loop(self):
        if self.isEmpty():
            return
        node = self.root
        stack2 = []
        stack1 = []
        stack1.append(node)
        while stack1:
            node = stack1.pop()
            if node.lchild:
                stack1.append(node.lchild)
            if node.rchild:
                stack1.append(node.rchild)
            stack2.append(node)
        while stack2:
            print(stack2.pop().data)

    def level_order(self):
        node = self.root
        if node == None:
            return

        queue = []
        queue.append(node)

        while queue:
            node = queue.pop(0)
            print(node.data)
            if node.lchild:
                queue.append(node.lchild)
            if node.rchild:
                queue.append(node.rchild)


if __name__ == '__main__':
    arr = []
    for i in range(10):
        arr.append(i)


    tree = BinaryTree()
    for i in arr:
        tree.add(i)

    print('level_order:')
    tree.level_order()
    print('pre order:')
    tree.pre_order(tree.root)
    print('pre order loop:')
    tree.pre_order_loop()
    print('in_order:')
    tree.in_order(tree.root)
    print('in_order loop:')
    tree.in_order_loop()
    print('post_order:')
    tree.post_order(tree.root)
    print('post_order_loop:')
    tree.post_order_loop()