Python實現二叉樹的前序、中序、后序、層次遍歷

  有關樹的理論部分描述：《數據結構與算法》-4-樹與二叉樹；

  下面代碼均基於python實現，包含：

• 二叉樹的前序、中序、后序遍歷的遞歸算法和非遞歸算法；
• 層次遍歷；
• 由前序序列、中序序列重構二叉樹；
• 由后序序列、中序序列重構二叉樹；

# -*- coding: utf-8 -*-
# @Time: 2019-04-15 18:35
# @Author: chen

class NodeTree:
    def __init__(self, root=None, lchild=None, rchild=None):
        """創建二叉樹
        Argument:
            lchild: BinTree
                左子樹
            rchild: BinTree
                右子樹

        Return:
            Tree
        """
        self.root = root
        self.lchild = lchild
        self.rchild = rchild

class BinTree:

    # -----------前序遍歷 ------------
    # 遞歸算法
    def pre_order_recursive(self, T):
        if T == None:
            return
        print(T.root, end=' ')
        self.pre_order_recursive(T.lchild)
        self.pre_order_recursive(T.rchild)

    # 非遞歸算法
    def pre_order_non_recursive(self, T):
        """借助棧實現前驅遍歷
        """
        if T == None:
            return
        stack = []
        while T or len(stack) > 0:
            if T:
                stack.append(T)
                print(T.root, end=' ')
                T = T.lchild
            else:
                T = stack[-1]
                stack.pop()
                T = T.rchild

    # -----------中序遍歷 ------------
    # 遞歸算法
    def mid_order_recursive(self, T):
        if T == None:
            return
        self.mid_order_recursive(T.lchild)
        print(T.root, end=' ')
        self.mid_order_recursive(T.rchild)

    # 非遞歸算法
    def mid_order_non_recursive(self, T):
        """借助棧實現中序遍歷
        """
        if T == None:
            return
        stack = []
        while T or len(stack) > 0:
            if T:
                stack.append(T)
                T = T.lchild
            else:
                T = stack.pop()
                print(T.root, end=' ')
                T = T.rchild


    # -----------后序遍歷 ------------
    # 遞歸算法
    def post_order_recursive(self, T):
        if T == None:
            return
        self.post_order_recursive(T.lchild)
        self.post_order_recursive(T.rchild)
        print(T.root, end=' ')

    # 非遞歸算法
    def post_order_non_recursive(self, T):
        """借助兩個棧實現后序遍歷
        """
        if T == None:
            return
        stack1 = []
        stack2 = []
        stack1.append(T)
        while stack1:
            node = stack1.pop()
            if node.lchild:
                stack1.append(node.lchild)
            if node.rchild:
                stack1.append(node.rchild)
            stack2.append(node)
        while stack2:
            print(stack2.pop().root, end=' ')
        return

    # -----------層次遍歷 ------------
    def level_order(self, T):
        """借助隊列（其實還是一個棧）實現層次遍歷
        """
        if T == None:
            return
        stack = []
        stack.append(T)
        while stack:
            node = stack.pop(0)  # 實現先進先出
            print(node.root, end=' ')
            if node.lchild:
                stack.append(node.lchild)
            if node.rchild:
                stack.append(node.rchild)

    # ----------- 前序遍歷序列、中序遍歷序列 —> 重構二叉樹 ------------
    def tree_by_pre_mid(self, pre, mid):
        if len(pre) != len(mid) or len(pre) == 0 or len(mid) == 0:
            return
        T = NodeTree(pre[0])
        index = mid.index(pre[0])
        T.lchild = self.tree_by_pre_mid(pre[1:index+1], mid[:index])
        T.rchild = self.tree_by_pre_mid(pre[index+1:], mid[index+1:])
        return T

    # ----------- 后序遍歷序列、中序遍歷序列 —> 重構二叉樹 ------------
    def tree_by_post_mid(self, post, mid):
        if len(post) != len(mid) or len(post) == 0 or len(mid) == 0:
            return
        T = NodeTree(post[-1])
        index = mid.index(post[-1])
        T.lchild = self.tree_by_post_mid(post[:index], mid[:index])
        T.rchild = self.tree_by_post_mid(post[index:-1], mid[index+1:])
        return T

if __name__ == '__main__':

    # ----------- 測試：前序、中序、后序、層次遍歷 -----------
    # 創建二叉樹
    nodeTree = NodeTree(1,
             lchild=NodeTree(2,
                         lchild=NodeTree(4,
                                     rchild=NodeTree(7))),
             rchild=NodeTree(3,
                         lchild=NodeTree(5),
                         rchild=NodeTree(6)))
    T = BinTree()
    T.pre_order_recursive(nodeTree)  # 前序遍歷-遞歸
    print('\n')
    T.pre_order_non_recursive(nodeTree)  # 前序遍歷-非遞歸
    print('\n')
    T.mid_order_recursive(nodeTree)  # 中序遍歷-遞歸
    print('\n')
    T.mid_order_non_recursive(nodeTree)  # 前序遍歷-非遞歸
    print('\n')
    T.post_order_recursive(nodeTree)  # 后序遍歷-遞歸
    print('\n')
    T.post_order_non_recursive(nodeTree)  # 前序遍歷-非遞歸
    print('\n')
    T.level_order(nodeTree)  # 層次遍歷
    print('\n')

    print('==========================================================================')
    
    # ----------- 測試：由遍歷序列構造二叉樹 -----------
    T = BinTree()
    pre = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I']
    mid = ['B', 'C', 'A', 'E', 'D', 'G', 'H', 'F', 'I']
    post = ['C', 'B', 'E', 'H', 'G', 'I', 'F', 'D', 'A']
   
    newT_pre_mid = T.tree_by_pre_mid(pre, mid)  # 由前序序列、中序序列構造二叉樹
    T.post_order_recursive(newT_pre_mid)  # 獲取后序序列
    print('\n')
    
    newT_post_mid = T.tree_by_post_mid(post, mid)  # 由后序序列、中序序列構造二叉樹   
    T.pre_order_recursive(newT_post_mid)  # 獲取前序序列

  測試用的兩個二叉樹：