【python数据结构】二叉树遍历的七种实现方式

二叉树的遍历方式：

1、深度优先遍历方式DFS

1.1 前序遍历  （递归、非递归）

1.2 中序遍历  （递归、非递归）

1.3 后序遍历  （递归、非递归）

2、宽度优先遍历方式BFS

---

'''树的构建：

                10
           6         14
        4    8    12    16

'''

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 = Node()
        self.mq = []
        self.res_preorder = []
        self.res_inorder = []
        self.res_postorder = []
    
    def add(self, elem):
        '''为树添加节点'''
        node = Node(elem)
        if self.root.elem == -1:  # 如果树是空的，对根节点赋值
            self.root = node
            self.mq.append(self.root)
        else:
            treeNode = self.mq[0] 
            if treeNode.lchild == None:
                treeNode.lchild = node
                self.mq.append(treeNode.lchild) # 将新的结点加入mq中，当结点的左、右孩齐全的时候将从mq中删除该结点
            else:
                treeNode.rchild = node
                self.mq.append(treeNode.rchild)
                self.mq.pop(0)  # 如果该结点存在右子树则将此结点丢弃   ?妙啊啊啊啊！

    def preorder_traversal(self, root):
        '''前序遍历： 递归实现
                    先访问根节点，再访问左子节点，最后访问右子节点
        '''
        if root == None:
            return
        self.res_preorder.append(root.elem) 
        self.preorder_traversal(root.lchild)
        self.preorder_traversal(root.rchild)

    def inorder_traversal(self, root):
        '''中序遍历： 递归实现
                    先访问左子节点，再访问根节点，最后访问右子节点
        '''
        if root == None:
            return
        self.inorder_traversal(root.lchild)
        self.res_inorder.append(root.elem)
        self.inorder_traversal(root.rchild)

    def postorder_traversal(self, root):
        '''后序遍历： 递归实现
                    先访问左子节点，再访问右子节点，最后访问根节点
        '''
        if root == None:
            return
        self.postorder_traversal(root.lchild)
        self.postorder_traversal(root.rchild)   
        self.res_postorder.append(root.elem)
    
    def preorder_traversal1(self, root):
        '''前序遍历： 栈实现
                    先访问根节点，再访问左子节点，最后访问右子节点
        '''
        if root == None:
            return
        mystack = [] # 用栈实现后进先出，弹出最近一个没有左子树的节点
        node = root
        while node or mystack:
            while node:  # 从根节点开始，一直寻找它的左子树
                print(node.elem)
                mystack.append(node)
                node = node.lchild
            node = mystack.pop() 
            print('*', node.elem)
            node = node.rchild  # 开始查看右子树

    def inorder_traversal1(self, root):
        '''中序遍历： 栈实现
                    先访问左子节点，再访问根节点，最后访问右子节点
        '''
        if root == None:
            return
        mystack = [] 
        node = root
        while node or mystack:
            while node:  # 从根节点开始，一直寻找它的左子树
                mystack.append(node)
                node = node.lchild
            node = mystack.pop() # 叶节点的父节点
            print(node.elem)
            node = node.rchild  # 开始查看右子树

    def postorder_traversal1(self, root):
        '''后序遍历： 栈实现
                    先访问左子节点，再访问右子节点，最后访问根节点
        '''
        if root == None:
            return
        mystack1 = []
        mystack2 = []
        mystack1.append(root)

        while mystack1:
            node = mystack1.pop()
            if node.lchild:
                mystack1.append(node.lchild)
            if node.rchild:
                mystack1.append(node.rchild)
            mystack2.append(node)
        while mystack2:
            print(mystack2.pop().elem)

    # 宽度优先遍历
    def BFS(self,root):              
        if root is None:
            return
        queue = []
        queue.append(root)
        while queue:
            now_node = queue.pop(0)
            print(now_node.elem)
            if now_node.lchild:
                queue.append(now_node.lchild)
            if now_node.rchild:
                queue.append(now_node.rchild)
        




if __name__ == '__main__':

    # 生成十个数据作为树节点
    elems  = [10, 6, 14, 4, 8, 12, 16]
    # 新建一个树对象
    tree = Tree()
    for elem in elems:
        tree.add(elem)
    # # 输出递归结果    
    # print('树的前序遍历')
    # tree.preorder_traversal(tree.root)
    # print(tree.res_preorder)

    # print('树的中序遍历')
    # tree.inorder_traversal(tree.root)
    # print(tree.res_inorder)

    print('树的后序遍历')
    tree.postorder_traversal(tree.root)
    print(tree.res_postorder)

    # 输出非递归结果
    # tree.preorder_traversal1(tree.root)
    # print('******************************')
    # tree.inorder_traversal1(tree.root)
    print('******************************')
    tree.postorder_traversal1(tree.root)