python實現二叉樹的遍歷以及基本操作

主要內容：

1. 二叉樹遍歷（先序、中序、后序、寬度優先遍歷）的迭代實現和遞歸實現；

2. 二叉樹的深度，二叉樹到葉子節點的所有路徑；

首先，先定義二叉樹類（python3），代碼如下：

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

目錄

• 1.1 先序遍歷：
• 1.2 中序遍歷
• 1.3 后序遍歷
• 1.4 層次遍歷

二叉樹的遍歷分深度優先遍歷（DFS）和寬度優先遍歷（BFS）。其中深度優先遍歷又分為先序遍歷，中序遍歷，后序遍歷。因為二叉樹是遞歸類數據結構，因此大部分關於二叉樹的操作都可以通過遞歸實現。下面將介紹二叉樹幾種遍歷的實現代碼以及思路。

1.1 先序遍歷：

遍歷順序：根節點——左子節點——右子節點（A-B-D-E-C-F）。

遞歸實現：

def preorder(root):
    if not root:
        return 
    print(root.val)
    preorder(root.left)
    preorder(root.right) 

迭代實現：

def preorder(root):
    stack = [root]
    while stack:
        s = stack.pop()
        if s:
            print(s.val)
            stack.append(s.right)
            stack.append(s.left)

1.2 中序遍歷

遍歷順序：左子節點——根節點——右子節點（D-B-E-A-C-F）

遞歸實現：

def inorder(root):
    if not root:
        return 
    inorder(root.left)
    print(root.val)
    inorder(root.right)

迭代實現：

def inorder(root):
    stack = []
    while stack or root:
        while root:
            stack.append(root)
            root = root.left
        root = stack.pop()
        print(root.val)
        root = root.right

1.3 后序遍歷

遍歷順序：左子節點——右子節點——根節點（D-E-B-F-C-A）

遞歸實現：

def postorder(root):
    if not root:
        return 
    postorder(root.left)
    postorder(root.right)
    print(root.val)

迭代實現：

def postorder(root):
    stack = []
    while stack or root:
        while root:                 # 下行循環，直到找到第一個葉子節點

            stack.append(root)
            if root.left:           # 能左就左，不能左就右

                root = root.left 
            else:
                root = root.right     
        s = stack.pop()
        print(s.val)
        #如果當前節點是上一節點的左子節點，則遍歷右子節點

        if stack and s == stack[-1].left: 

            root = stack[-1].right
        else:
            root = None

1.4 層次遍歷

遍歷順序：一層一層的遍歷（A-B-C-D-E-F）

迭代實現：

def BFS(root):
    queue = [root]
    while queue:
        n = len(queue)
        for i in range(n):
            q = queue.pop(0)
            if q:
                print(q.val)
                queue.append(q.left if q.left else None)
                queue.append(q.right if q.right else None)

內容2：基本操作

2.1 二叉樹的最大深度

基本思路就是遞歸，當前樹的最大深度等於（1+max(左子樹最大深度，右子樹最大深度)）。代碼如下：

def maxDepth(root):

    if not root:
        return 0
    return 1+max(maxDepth(root.left),maxDepth(root.right))

2.2 二叉樹的最小深度

最小深度是從根節點到最近葉子節點的最短路徑上的節點數量。可以通過遞歸求左右節點的最小深度的較小值，也可以層序遍歷找到第一個葉子節點所在的層數。

遞歸方法：

class Solution:
    def minDepth(self, root: TreeNode) -> int:
        if not root:
            return 0
        if not root.left and not root.right:
            return 1 
        if not root.right:
            return 1+self.minDepth(root.left)
        if not root.left:
            return 1+self.minDepth(root.right)
        return 1+min(self.minDepth(root.left),self.minDepth(root.right))

迭代方法：

class Solution:
    def minDepth(self, root: TreeNode) -> int:
        if not root: return 0
        ans,count = [root],1
        while ans:
            n = len(ans)
            for i in range(n):
                r = ans.pop(0)
                if r:
                    if not r.left and not r.right:
                        return count
                    ans.append(r.left if r.left else [])
                    ans.append(r.right if r.right else [])
            count+=1 

2.3 二叉樹的所有路徑

根節點到葉子節點的所有路徑。

def traverse(node):
    if not node.left and not node.right:
        return [str(node.val)]
    left, right = [], []
    if node.left:
        left = [str(node.val) + x for x in traverse(node.left)]
    if node.right:
        right = [str(node.val) + x for x in traverse(node.right)]

    return left + right