二叉树（增、遍历）的代码实现

‘’’
二叉树：本质是队列
基本操作：
添加：add()
遍历： 先序遍历：根–左--右
中序遍历：左—根–右
后序遍历：左–右--根
由遍历确认一棵树

‘’’

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)

    '''广度遍历----从上到下，从左到右，Z字型开展'''
    def breadth_travel(self):
        if self.root is None:
            return
        queue = [self.root]
        while queue:
            '''queue.pop(0)代表每棵树的根'''
            cur_node = queue.pop(0)
            print(cur_node.elem)
            if cur_node.lchild is None:
                queue.append(cur_node.lchild)
            if cur_node.rchild is not None:
                queue.append(cur_node.rchild)

    '''深度遍历：
                先序遍历：根--左--右
                中序遍历：左--根--右
                后序遍历：左--右--根'''
    def preorder(self,node):
        '''先序遍历'''
        '''node是根结点'''
        if node is None:
            return
        print(node.elem)
        self.preorder(node.lchild)
        self.preorder(node.rchild)


    def inorder(self,node):
        '''中序遍历'''
        '''node是根结点'''
        if node is None:
            return
        self.inorder(node.lchild)
        print(node.elem)
        self.inorder(node.rchild)

    def postorder(self,node):
        '''后序遍历'''
        '''node是根结点'''
        if node is None:
            return
        self.postorder(node.lchild)
        self.postorder(node.rchild)
        print(node.elem)