二叉树的实现

class Node(object):
    def __init__(self, item):
        self.elem = item
        self.lchild = None
        self.rchild = None


class Binary_Tree(object):
    def __init__(self):
        self.root = None

    def add(self, item):
        node = Node(item)
        if self.root is None:
            self.root = node
            return
        queue = [self.root]
        while queue:
            cur_node = queue.pop(0)
            if cur_node.lchild is None:
                cur_node.lchild = node
                return
            else:
                queue.append(cur_node.lchild)
            if cur_node.rchild is None:
                cur_node.rchild = node
                return
            else:
                queue.append(cur_node.rchild)
    def breadth_travel(self):
        if self.root is None:
            return None
        queue = [self.root]
        while queue:
            cur_node = queue.pop(0)
            print(cur_node.elem, end=" ")
            if cur_node.lchild is not None:
                queue.append(cur_node.lchild)
            if cur_node.rchild is not None:
                queue.append(cur_node.rchild)
    def preorder(self, node):
        """先序遍历, 根,左,右"""
        if node is None:
            return
        print(node.elem, end=" ")
        self.preorder(node.lchild)
        self.preorder(node.rchild)

    def inorder(self, node):
        """中序遍历: 左,根,右"""
        if node is None:
            return
        self.inorder(node.lchild)
        print(node.elem, end=" ")
        self.inorder(node.rchild)

    def posorder(self, node):
        """后续遍历: 左,右,根"""
        if node is None:
            return
        self.posorder(node.lchild)
        self.posorder(node.rchild)
        print(node.elem, end=" ")

class Node(object):
    # 节点类
    def __init__(self, item):
        # 初始化函数, 将传递进来的元素, 创建成新节点的elem
        self.elem = item
        self.lchild = None
        # 新节点的lchild左孩子, 默认为None
        self.rchild = None
        # 新节点的rchild右孩子, 默认为None


class Binary_Tree(object):
    # 二叉树类
    def __init__(self):
        self.root = None
        # 默认情况下树的根节点为None, 即: 空树
        # 只能通过add添加节点

    def add(self, item):
        node = Node(item)
        # 将要插入的元素创建新节点


        # 添加节点用广度遍历, 从根节点root开始遍历
        # cur_node代表当前节点, 从队列的头部取出节点
        if self.root is None:
            # 如果是空树, 则直接将元素当作根节点插入, 然后退出
            self.root = node
            return
        queue = [self.root]
        while queue:
            # 如果队列不为空, 一直执行
            # 创建队列, 内含树的根节点
            cur_node = queue.pop(0)
            if cur_node.lchild is None:
                # 如果当前节点的左孩子不存在, 将新对象插入到左孩子位置, 然后退出
                cur_node.lchild = node
                return
            else:
                # 如果当前节点的左孩子存在, 将左孩子添加到队列中
                queue.append(cur_node.lchild)
            if cur_node.rchild is None:
                # 如果当前节点的右孩子不存在, 将新对象插入到右孩子位置, 然后退出
                cur_node.rchild = node
                return
            else:
                # 如果当前节点的右孩子存在, 将右孩子添加到队列内
                queue.append(cur_node.rchild)
    def breadth_travel(self):
        """广度遍历"""

        if self.root is None:
            # 如果树为空, 直接返回
            return None
        queue = [self.root]
        while queue:
            # 如果队列不为空
            cur_node = queue.pop(0)
            # 从队列中取出一个节点
            print(cur_node.elem, end=" ")
            # 打印当前节点的elem
            if cur_node.lchild is not None:
                # 如果当前节点的左孩子存在, 添加到队列内
                queue.append(cur_node.lchild)
            if cur_node.rchild is not None:
                # 如果当前节点的右孩子存在, 添加到队列内
                queue.append(cur_node.rchild)
    def preorder(self, node):
        """先序遍历, 每次传递进来的根  都不一样"""
        # 按照(根, 左, 右)的顺序来递归调用先序遍历函数
        if node is None:
            # 如果当前节点为None, 退出
            return
        print(node.elem, end=" ")
        self.preorder(node.lchild)
        self.preorder(node.rchild)

    def inorder(self, node):
        """中序遍历, 每次传递进来的根  都不一样"""
        # 按照(左, 根, 右)的顺序来递归调用先序遍历函数
        if node is None:
            # 如果当前节点为None, 退出
            return
        self.inorder(node.lchild)
        print(node.elem, end=" ")
        self.inorder(node.rchild)

    def posorder(self, node):
        """后续遍历, 每次传递进来的根  都不一样"""
        # 按照(左, 右,  根)的顺序来递归调用先序遍历函数
        if node is None:
            # 如果当前节点为None, 退出
            return
        self.posorder(node.lchild)
        self.posorder(node.rchild)
        print(node.elem, end=" ")


if __name__ == "__main__":
    tree = Binary_Tree()
    for i in range(0, 10):
        tree.add(i)
        # print(i, end=" ")
    tree.breadth_travel()
    print(" ")
    tree.preorder(tree.root)
    print(" ")
    tree.inorder(tree.root)
    print(" ")
    tree.posorder(tree.root)
    print(" ")