LeetCode 144,94,145,102,103 Binary Tree Traversal 二叉樹遍歷 Python Solution

這篇文章彙總介紹 LeetCode 上的二叉樹的遍歷題目，由於內容可能比較多，所以持續更新中ing

1.

首先是 144. Binary Tree Preorder Traversal

二叉樹的前序遍歷，這裏分別給出遞歸和循環的做法。

思路：

遞歸，用一個類屬性(類似於全局變量)來保存需要返回遍歷列表

循環，使用mystack(先入後出的堆)作爲輔助結構來儲存一些中間信息。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def __init__(self):
        self.l = []
        
    def preorderTraversal(self, root):
        '''利用遞歸實現樹的前序遍歷''' 
        if root == None:
            return []
        self.l.append(root.val)
        self.preorderTraversal(root.left)
        self.preorderTraversal(root.right)
        return self.l
    
    def preorderTraversal(self, root):
        '''利用循環實現樹的前序遍歷''' 
        if root == None:
            return []
        mystack = []
        out = []
        cur = root
        while cur or myqueue:
            while cur:#從根節點開始，一直找它的左子樹
                mystack.append(cur)
                out.append(cur.val)
                cur = cur.left
            cur = mystack.pop().right #while結束表示當前節點node爲空，即前一個節點沒有左子樹了,開始查看它的右子樹
        return out
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        

2.

接着是94. Binary Tree Inorder Traversal

二叉樹的中序遍歷，這裏分別給出遞歸和循環的做法。

思路：

遞歸，用一個類屬性(類似於全局變量)來保存需要返回遍歷列表

循環，使用mystack(先入後出的堆)作爲輔助結構來儲存一些中間信息。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def __init__(self):
        self.l = []
        
    def inorderTraversal(self, root):
        '''利用遞歸實現樹的中序遍歷'''
        if root == None:
            return []
        self.inorderTraversal(root.left)
        self.l.append(root.val)
        self.inorderTraversal(root.right)
        return self.l
        """
        :type root: TreeNode
        :rtype: List[int]
        """
    def inorderTraversal(self, root):
         '''利用堆棧實現樹的中序遍歷'''
        if root == None:
            return []
        cur = root
        mystack = [] 
        outstack = []
        while mystack or cur:
            while cur:
                mystack.append(cur)
                cur = cur.left
            tmp = mystack.pop()
            outstack.append(tmp.val)
            cur = tmp.right
        return outstack
        
        """
        :type root: TreeNode
        :rtype: List[int]
        """

3.

再接着是145. Binary Tree Postorder Traversal

二叉樹的後序遍歷，這裏分別給出遞歸和循環的做法。

思路：

遞歸，用一個類屬性(類似於全局變量)來保存需要返回遍歷列表

循環，這裏使用到一個trick,就是後續遍歷(左右根)是(根右左的)反轉，而根右左的遍歷做法和

前序遍歷（根左右類似），這樣問題就很輕鬆了。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def __init__(self):
        self.l = []
        
    def postorderTraversal(self, root):
        if root == None:
            return []
        self.postorderTraversal(root.left)
        self.postorderTraversal(root.right)
        self.l.append(root.val)
        return self.l
    
    def postorderTraversal(self, root):
        if root == None:
            return []
        cur = root
        mystack = []
        out = []
        while mystack or cur:# 根右左的遍歷，類似前序的寫法
            while cur:
                out.append(cur.val)
                mystack.append(cur)
                cur = cur.right
            cur = mystack.pop().left
        return out[::-1]#反轉後就是左右根
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        

4.然後是102. Binary Tree Level Order Traversal

題目要求給出樹的層次遍歷，值得注意的是要求了返回格式rtype: List[List[int]]，這個格式有別去上面3題要求的

返回格式，所以一定程度上改變了解法和加強的難度。

return its level order traversal as:

[
  [3],
  [9,20],
  [15,7]
]

這裏給出兩種解法：

（1）做廣度優先遍歷BFS，做法就是用一個輔助list來存放每層的遍歷節點，並循環更新節點。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def levelOrder(self, root):
        res = []
        if root == None:
            return res
        q = [root] #輔助list
        while len(q)!=0:
            res.append([node.val for node in q])
            new_q = []
            for node in q:#對於上一層的每一個節點都進行以下操作
                if node.left:
                    new_q.append(node.left)
                if node.right:
                    new_q.append(node.right)
            q = new_q
        return res        
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """

(2) 做深度優先搜索DFS,做法就是構建一個輔助list res，並根據list的層數和深度就地操作res

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def dfs(self,root,depth,res):
        if root == None:
            return res
        if len(res) < depth+1:#判斷當前節點的深度，進行對應操作
            res.append([])
        res[depth].append(root.val)
        self.dfs(root.left,depth+1,res)
        self.dfs(root.right,depth+1,res)
    def levelOrder(self, root):
        res = []
        self.dfs(root,0,res)
        return res
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """

BTW，這裏如果該一下返回list的格式問題就簡單多了，比如改rtype: List[int]

下面也想前，中，後序遍歷一樣給出了兩種解法，值得注意的是這裏用來存儲

節點的是先入先出的隊列。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def __init__(self):
        self.l = []
        
    def levelOrder(self, root):
        if root == None:
            return []
        self.l.append(root.val)
        self.levelOrder(root.left)
        self.levelOrder(root.right)
        return self.l
    
    def levelOrder(self, root):
        if root == None:
            return []
        myqueue = [root]#以隊列來存放層次遍歷的節點
        res = []
        while len(myqueue)!=0:
            node = myqueue.pop(0)
            res.append(node.val)
            if node.left:
                myqueue.append(node.left)
            if node.right:
                myqueue.append(node.right)
        return res
        """
        :type root: TreeNode
        :rtype: List[int]
        """

5.再着是103. Binary Tree Zigzag Level Order Traversal 

題目要求：

Given a binary tree, return the zigzag level order traversal of its nodes' values. (ie, from left to right, then right to left for the next level and alternate between).

For example:
Given binary tree [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

return its zigzag level order traversal as:

[
  [3],
  [20,9],
  [15,7]
]

解法同層次遍歷類似，只需要最後對res的部分元素進行重新組織即可：

這裏和層次遍歷一樣提供兩種解法：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def dfs(self,root,depth,res):
        if root == None:
            return res
        if len(res) < depth+1:
            res.append([])
        res[depth].append(root.val)
        self.dfs(root.left,depth+1,res)
        self.dfs(root.right,depth+1,res)
    def zigzagLevelOrder(self, root):
        res = []
        self.dfs(root,0,res)
        for i in range(len(res)):
            if i%2 == 1:
                res[i] = res[i][::-1]
        return res
    def zigzagLevelOrder(self, root):
        res = []
        if root == None:
            return res
        q = [root]
        cnt = 0
        while len(q)!=0:
            res.append([node.val for node in q])
            new_q = []
            for node in q:
                if node.left:
                    new_q.append(node.left)
                if node.right:
                    new_q.append(node.right)
            q = new_q
        for i in range(len(res)):
            if i%2==1:
                res[i] = res[i][::-1]          
        return res
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """