二叉树之深度优先搜索和广度优先搜索 | python

class Node(object):

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

class 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
        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 node
        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 postorder(self, node):
        #  左子树，右子树，根
        if node is None:
            return
        self.postorder(node.lchild)
        self.postorder(node.rchild)
        print(node.elem, end=" ")

    def getHeight(self,root):
        if (root == None):
            return 0
        left_height = self.getHeight(root.lchild)
        right_height = self.getHeight(root.rchild)
        return max(left_height, right_height) + 1

if __name__ =="__main__":
    tree = Tree()
    tree.add(0)
    tree.add(1)
    tree.add(2)
    tree.add(3)
    tree.add(4)
    tree.add(5)
    tree.add(6)
    tree.add(7)
    tree.add(8)
    tree.add(9)
    tree.add(10)
    tree.add(11)
    tree.add(12)
    tree.add(13)
    tree.add(14)
    tree.add(15)

    print("数的高度是%d"%tree.getHeight(tree.root))
    tree.breadth_travel()
    print(" " + "宽度优先搜索")
    tree.preorder(tree.root)
    print(" " + "前序遍历")
    tree.inorder(tree.root)
    print(" " + "中序遍历")
    tree.postorder(tree.root)
    print(" " + "后序遍历")