二叉树的实现和遍历（Python）

class Node(object):
    def __init__(self, data=None, left=None, right=None):
        self.data = data
        self.left = left
        self.right = right

class BinaryTree(object):
    def __init__(self):
        self.root = Node()
        self.queue = []

    def append_node(self, data):
        node = Node(data)
        if self.root.data == None:
            self.root = node
            self.queue.append(self.root)
        else:
            tree_node = self.queue[0]
            if tree_node.left == None:
                tree_node.left = node
                self.queue.append(tree_node.left)
            else:
                tree_node.right = node
                self.queue.append(tree_node.right)
                self.queue.pop(0)
    def BFS(self):
        if self.root.data == None:
            return None
        queue = [self.root]
        while queue:
            tree_node = queue.pop(0)
            print(tree_node.data, end=',')
            if tree_node.left != None:
                queue.append(tree_node.left)
            if tree_node.right != None:
                queue.append(tree_node.right)

    def pre_order_traverse(self, node):
        if node == None:
            return None
        print(node.data, end=",")
        self.pre_order_traverse(node.left)
        self.pre_order_traverse(node.right)

    def in_order_traverse(self, node):
        if node == None:
            return None
        self.in_order_traverse(node.left)
        print(node.data, end=",")
        self.in_order_traverse(node.right)

    def post_order_traverse(self, node):
        if node == None:
            return None
        self.post_order_traverse(node.left)
        self.post_order_traverse(node.right)
        print(node.data, end=",")

if __name__ == '__main__':
    data_list = range(15)
    tree = BinaryTree()
    for data in data_list:
        tree.append_node(data)

    tree.BFS()
    print()
    tree.pre_order_traverse(tree.root)
    print()
    tree.in_order_traverse(tree.root)
    print()
    tree.post_order_traverse(tree.root)