這篇文章總結了關于二叉樹的創建和各種遍歷方式。

二叉樹的創建方式

• 通過層次遍歷順序創建
• 先序遍歷順序(帶上葉子結點標識符)創建
• 先序順序+中序順序
• 中序順序+后序順序

二叉樹的遞歸方式

• 先序遍歷(遞歸+非遞歸)
• 中序遍歷(遞歸+非遞歸)
• 后序遍歷(遞歸+非遞歸)
• 廣度優先遍歷(BFS)

首先來定義一下節點的結構

            
              class Node():
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None
            
          

然后定義樹類

            
              class BinaryTree():
    def __init__(self):
        self.root = None
        self.queue = [] #用來存放正在操作的三個樹節點，分別是root,left和right
        self.create_queue = [] #用來存放先序序列來創建二叉樹
        pass
            
          

然后開始實現函數，這些函數都是在 BinaryTree 這個類下定義的。

通過先序序列帶有葉子結點標識符創建二叉樹

            
              #通過先序序列創建二叉樹，沒有左右子節點被標記為'#'
    def createTree(self):
        current = self.create_queue.pop(0)
        if current != '#':
            new_node = Node(current)
            if self.root is None:
                self.root = new_node
            new_node.left = self.createTree()
            new_node.right = self.createTree()
            return new_node
        return None
            
          

通過層次遍歷順序創建二叉樹

            
              #通過層次遍歷順序創建二叉樹
    def add(self, val):
        new_node = Node(val)
        self.queue.append(new_node)
        if self.root is None:
            self.root = new_node
        else:
            tree_node = self.queue[0]
            if tree_node.left is None:
                tree_node.left = new_node
            else:
                tree_node.right = new_node
                self.queue.pop(0)
            
          

通過 先序+中序 創建二叉樹

            
              #通過前序序列和中序序列創建二叉樹
    def create_tree(self, pre_order, mid_order):
        if len(pre_order) == 0:
            return None
        new_node = Node(pre_order[0])
        if self.root is None:
            self.root = new_node
        i = mid_order.index(pre_order[0])
        print(i)
        new_node.left = self.create_tree(pre_order[1:1+i], mid_order[:i])
        new_node.right = self.create_tree(pre_order[1+i:], mid_order[i+1:])
        return new_node
            
          

通過 中序+后序 創建二叉樹

            
              #通過中序和后序創建二叉樹
    def construct_tree(self, mid_order, post_order):
        length = len(post_order)
        if length == 0:
            return None
        new_node = Node(post_order[-1])
        if self.root is None:
            self.root = new_node
        i = mid_order.index(post_order[-1])
        new_node.left = self.construct_tree(mid_order[:i], post_order[:i])
        new_node.right = self.construct_tree(mid_order[i+1:], post_order[length-2-i:length-1])
        return new_node
            
          

以上是全部創建二叉樹的方法，下面開始實現遍歷方法。

先序遍歷(遞歸)

            
              #通過遞歸進行先序遍歷
    def recursion_vlr(self, root):
        if root is None:
            return
        print(root.val)
        self.recursion_vlr(root.left)
        self.recursion_vlr(root.right)
            
          

先序遍歷(非遞歸)

            
              #通過棧非遞歸進行先序遍歷
    def pre_order_stack(self, root):
        if root is None:
            return
        mystack = []
        node = root
        while mystack or node:
            while node:
                print(node.val)
                mystack.append(node)
                node = node.left
            node = mystack.pop()
            node = node.right
            
          

中序遍歷(遞歸)

            
              #通過遞歸進行中序遍歷
    def recursion_lvr(self, root):
        if root is None:
            return
        self.recursion_lvr(root.left)
        print(root.val)
        self.recursion_lvr(root.right)
            
          

中序遍歷(非遞歸)

            
              #通過棧非遞歸進行中序遍歷
    def mid_order_stack(self, root):
        if root is None:
            return
        mystack = []
        node = root
        while mystack or node:
            while node:
                mystack.append(node)
                node = node.left
            node = mystack.pop()
            print(node.val)
            node = node.right
            
          

后序遍歷(遞歸)

            
              #通過遞歸進行后序遍歷
    def recursion_lrv(self, root):
        if root is None:
            return
        self.recursion_lrv(root.left)
        self.recursion_lrv(root.right)
        print(root.val)
            
          

后序遍歷(非遞歸)

            
              #通過棧非遞歸進行后序遍歷，先遍歷右子樹，在遍歷左子樹，最后逆序數出
    def post_order_stack(self, root):
        if root is None:
            return
        mystack1 = []
        #stack2是為了逆序輸出，全都存在2棧中，1棧的作用是按照右、左的順序遍歷節點存入2棧
        mystack2 = []
        node = root
        while mystack1 or node:
            while node:
                mystack2.append(node)
                mystack1.append(node)
                node = node.right
            node = mystack1.pop()
            node = node.left
        while mystack2:
            print(mystack2.pop().val)
            
          

廣度優先遍歷(BFS)

            
              #利用隊列進行廣度優先遍歷BFS
    def level_scan(self):
        queue = []
        current = self.root
        queue.append(current)
        while queue:
            current = queue.pop(0)
            print(current.val)
            if current.left:
                queue.append(current.left)
            if current.right:
                queue.append(current.right)
            
          

整個項目源碼：傳送門

?

?