二叉樹的層序遍歷按字面意思就是一層一層的遍歷二叉樹

如圖，使用二叉樹的層序遍歷結果應該為1234567

層序遍歷一般用佇列或者遞迴的框架，我主要學習佇列的解法。為什麼用佇列，因為佇列有先入先出的屬性，非常符合層序遍歷的特點。

102. 二叉樹的層序遍歷

給你二叉樹的根節點 root ，返回其節點值的 層序遍歷 。 （即逐層地，從左到右訪問所有節點）。

來源：力扣（LeetCode）

連結：https://leetcode.cn/problems/binary-tree-level-order-traversal/

# Definition for a binary tree node.
#
 
 class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if root == None:
            return []
        que = [root]
        ans 
 
= []
        while que:
            length = len(que)
            ret = []
            for i in range(length):
                cur = que.pop(0)
                ret.append(cur.val)
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            ans.append(ret)
        
 
return ans

一個標準的二叉樹層序遍歷模板

107. 二叉樹的層序遍歷 II

給你二叉樹的根節點 root ，返回其節點值 自底向上的層序遍歷 。 （即按從葉子節點所在層到根節點所在的層，逐層從左向右遍歷）

來源：力扣（LeetCode）

連結：https://leetcode.cn/problems/binary-tree-level-order-traversal-ii/

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def levelOrderBottom(self, root: TreeNode) -> List[List[int]]:
        if root == None:
            return []
        ans = []
        que = [root]
        while que:
            ret = []
            length = len(que)
            for i in range(length):
                cur = que.pop(0)
                ret.append(cur.val)
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            ans.append(ret)
        return ans[::-1]

按照模板與102題非常類似，唯一不同的是這題是自底向上，而模板是自頂向下遍歷的，所以遍歷完成後需要翻轉一下，就變成了自底向上了。

199. 二叉樹的右檢視

給定一個二叉樹的 根節點 root，想象自己站在它的右側，按照從頂部到底部的順序，返回從右側所能看到的節點值。

來源：力扣（LeetCode）

連結：https://leetcode.cn/problems/binary-tree-right-side-view/

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def rightSideView(self, root: Optional[TreeNode]) -> List[int]:
        if root == None:
            return []
        ans = []
        que = [root]
        while que:
            cur = que[-1] #因為是右檢視，所以只需要取每層的最右側的值就行，即佇列的末尾
            ans.append(cur.val)
            length = len(que)
            for i in range(length):
                cur = que.pop(0)
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
        return ans

637. 二叉樹的層平均值

給定一個非空二叉樹的根節點 root , 以陣列的形式返回每一層節點的平均值。與實際答案相差 10-5 以內的答案可以被接受。

來源：力扣（LeetCode）

連結：https://leetcode.cn/problems/average-of-levels-in-binary-tree/

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def averageOfLevels(self, root: Optional[TreeNode]) -> List[float]:
        if root == None:
            return []
        ans = []
        que = [root]
        while que:
            ret = []
            length = len(que)
            for i in range(length):
                cur = que.pop(0)
                ret.append(cur.val)
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            ans.append(sum(ret) / len(ret))
        return ans

一樣的利用模板，最後取個平均值存入ans即可。

429. N 叉樹的層序遍歷

給定一個 N 叉樹，返回其節點值的層序遍歷。（即從左到右，逐層遍歷）。

樹的序列化輸入是用層序遍歷，每組子節點都由 null 值分隔（參見示例）。

來源：力扣（LeetCode）

連結：https://leetcode.cn/problems/n-ary-tree-level-order-traversal/

"""
# Definition for a Node.
class Node:
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children
"""

class Solution:
    def levelOrder(self, root: 'Node') -> List[List[int]]:
        if root == None:
            return []
        ans = []
        que = [root]
        while que:
            ret = []
            length = len(que)
            for i in range(length):
                cur = que.pop(0)
                ret.append(cur.val)
                if cur.children:
                    que.extend(cur.children) #列表用extend拼接
            ans.append(ret)
        return ans

模板是一樣，注意不用列表append

515. 在每個樹行中找最大值

給定一棵二叉樹的根節點 root ，請找出該二叉樹中每一層的最大值。

來源：力扣（LeetCode）

連結：https://leetcode.cn/problems/find-largest-value-in-each-tree-row/

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def largestValues(self, root: Optional[TreeNode]) -> List[int]:
        if root == None:
            return []
        ans = []
        que = [root]
        while que:
            ret = []
            length = len(que)
            for i in range(length):
                cur = que.pop(0)
                ret.append(cur.val)
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            ans.append(max(ret))
        return ans

按照模板來，最後取最大值存入ans中。

104. 二叉樹的最大深度

給定一個二叉樹，找出其最大深度。

二叉樹的深度為根節點到最遠葉子節點的最長路徑上的節點數。

說明: 葉子節點是指沒有子節點的節點。

來源：力扣（LeetCode）

連結：https://leetcode.cn/problems/maximum-depth-of-binary-tree/

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        if root == None:
            return 0
        ans = []
        que = [root]
        while que:
            ret = []
            length = len(que)
            for i in range(length):
                cur = que.pop(0)
                ret.append(cur.val)
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            ans.append(ret)
        return len(ans)

111. 二叉樹的最小深度

給定一個二叉樹，找出其最小深度。

最小深度是從根節點到最近葉子節點的最短路徑上的節點數量。

說明：葉子節點是指沒有子節點的節點。

來源：力扣（LeetCode）

連結：https://leetcode.cn/problems/minimum-depth-of-binary-tree/

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def minDepth(self, root: TreeNode) -> int:
        if root == None:
            return 0
        que = [(root, 1)]
        while que:
            length = len(que)
            for i in range(length):
                cur, step = que.pop(0)
                if cur.left == None and cur.right == None:
                    return step
                if cur.left:
                    que.append((cur.left, step +1))
                if cur.right:
                    que.append((cur.right, step + 1))
        return 0

上一題是求最大深度，所以可以全部遍歷後求結果，這題是求最小深度，那麼要注意葉子節點是指沒有左右節點的節點。

以上就是二叉樹層序遍歷模板的應用，題型略有變化，但是模板都是一個。在此非常感謝程式碼隨想錄提供的模板和題型供我學習。

搜尋

複製