数据结构（三）树

在此进行实现的主要是二叉树，其具备广度优先、深度优先两种存储和遍历方式

对于广度优先而言，进行存储的方式是队列，先存进去一个节点，再将其取出，将其左右节点加入列表，即从一端存从另一端取，先存的需要先取

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


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

    #向完全二叉树上添加节点，用广度优先方法进行遍历，进行类似队列的操作，从列表头取出元素看它是否有子节点，若有就添加到
    #队尾，没有就将欲添加的节点链过去
    def add(self,value):
        quenue=[self.root]
        node=Node(value)
        if self.root==None:
            self.root=node
        else:
            while quenue:
                cur_node=quenue.pop(0)
                if cur_node.lchild==None:
                    cur_node.lchild=node
                    return
                else:
                    quenue.append(cur_node.lchild)
                if cur_node.rchild==None:
                    cur_node.rchild=node
                    return
                else:
                    quenue.append(cur_node.rchild)
#进行广度优先遍历
    def breadth_iter(self):
        queue=[self.root]
        if self.root==None:
            return
        else:
            while queue:
                cur_node=queue.pop(0)
                print(cur_node.value)
                if cur_node.lchild!=None:
                    queue.append(cur_node.lchild)
                if cur_node.rchild!=None:
                    queue.append(cur_node.rchild)

#进行深度优先遍历，其中分为先序遍历，中序遍历和后序遍历
    def pre_order_iter(self,root):
        if root!=None:
            print(root.value,end=" ")
            self.pre_order_iter(root.lchild)
            self.pre_order_iter(root.rchild)

    def mid_order_iter(self,root):
        if root!=None:
            self.mid_order_iter(root.lchild)
            print(root.value,end=" ")
            self.mid_order_iter(root.rchild)


    def back_order_iter(self,root):
        if root!=None:
            self.back_order_iter(root.lchild)
            self.back_order_iter(root.rchild)
            print(root.value,end=" ")

if __name__=="__main__":
    tree=Binary_tree()
    tree.add(3)
    tree.add(5)
    tree.add(10)
    tree.add(6)
    # tree.breadth_iter()
    tree.pre_order_iter(tree.root)
    print("\n")
    tree.mid_order_iter(tree.root)
    print("\n")
    tree.back_order_iter(tree.root)