Python学习笔记24（二叉树遍历、最大深度、最大宽度）

class Node(object):
    """节点类"""
    def __init__(self,elem=-1,lchild=None,rchild=None):
        self.elem = elem
        self.lchild = lchild
        self.rchild = rchild

class Tree(object):
    """树类"""
    def __init__(self):
        self.root = None
        self.myQueue = []

    def add(self,elem):
        """为树添加节点"""
        node = Node(elem)
        if self.root == None: #如果树是空的，则对根节点赋值
            self.root = node
            self.myQueue.append(self.root)
        else:
            treeNode = self.myQueue[0] #此节点的子树还没有对齐
            if treeNode.lchild == None:
                treeNode.lchild = node
                self.myQueue.append(treeNode.lchild)
            else:
                treeNode.rchild = node
                self.myQueue.append(treeNode.rchild)
                self.myQueue.pop(0)

    def front_digui(self,root):
        """
        利用递归实现树的先序遍历
        先序遍历：根-->左-->右
        """
        if root == None:
            return
        print(root.elem)
        self.front_digui(root.lchild)
        self.front_digui(root.rchild)

    def middle_digui(self,root):
        """
        利用递归实现树的中序遍历
        中序遍历：左-->根-->右
        """
        if root == None:
            return
        self.middle_digui(root.lchild)
        print(root.elem)
        self.middle_digui(root.rchild)

    def later_digui(self,root):
        """
        利用递归实现树的后序遍历
        后续遍历：左-->右-->根
        """
        if root == None:
            return
        self.later_digui(root.lchild)
        self.later_digui(root.rchild)
        print(root.elem)

    def level_queue(self,root):
        """利用队列实现树的层次遍历"""
        if root == None:
            return
        myQueue = []
        node = root
        myQueue.append(node)
        while myQueue:
            node = myQueue.pop(0)
            print(node.elem)
            if node.lchild != None:
                myQueue.append(node.lchild)
            if node.rchild != None:
                myQueue.append(node.rchild)

    def treeDepth(self,root):
        """求树的最大深度"""
        if root == None:
            return 0
        leftDepth = self.treeDepth(root.lchild)
        rightDepth = self.treeDepth(root.rchild)
        if leftDepth >= rightDepth:
            return leftDepth+1
        else:
            return rightDepth+1

    def treeWidth(self,root):
        """求树的最大宽度"""
        curwidth = 1
        maxwidth = 0
        myQueue = []
        myQueue.append(root)
        while myQueue:
            n = curwidth
            for i in range(n):
                node = myQueue.pop(0)
                curwidth -= 1
                if node.lchild != None:
                    myQueue.append(node.lchild)
                    curwidth += 1
                if node.rchild != None:
                    myQueue.append(node.rchild)
                    curwidth += 1
            if curwidth > maxwidth:
                maxwidth = curwidth
        return maxwidth



if __name__ == "__main__":
    elems = range(14)
    tree = Tree()
    for elem in elems:
        tree.add(elem)

    print("先序遍历")
    tree.front_digui(tree.root)
    print("中序遍历")
    tree.middle_digui(tree.root)
    print("后续遍历")
    tree.later_digui(tree.root)
    print("层次遍历")
    tree.level_queue(tree.root)
    print("树的深度")
    print(tree.treeDepth(tree.root))
    print("树的宽度")
    print(tree.treeWidth(tree.root))