代码随想录 DAY15 ｜ 二叉树02

1、层序遍历

二叉树中的前中后序遍历就是图论里的深度搜索，层序遍历就是广度搜索。

层序遍历就是一层一层搜索

层序遍历：

把每一层的size记录下来，在queue里，根据size--弹出元素，并且在弹出的时候加入这个节点的左右孩子进入队列

题目1:

102. Binary Tree Level Order Traversal

# 先新建一个tree

class TreeNode:
    def __init__(self,val=0,left=None,right=None):
        self.val = val
        self.left = left
        self.right = right
        
# 解题
class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:
            return []
        
        queue = collections.deque([root])
        # 初始化一个双端队列，并把树的根节点加入 
        # 创建一个空的双端队列：mydeque = collections.deque()
        
        result = []
        size = 0
        while(queue):
            level = []
            for _ in range(len(queue)):
                
                cur = queue.popleft()
                #why left?
                #cuz it's first node
                
                level.append(cur.val)
                        
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            result.append(level)
           
        return result

        

同类型

1.1 
107. Binary Tree Level Order Traversal II

思路：最后反转result数组

1.2

199. Binary Tree Right Side View

# 199. Binary Tree Right Side View
# 只要右边

# 记得加一个判断
# 判断是否遍历到单层的最后面的元素，
# 如果是，就放进result数组中，随后返回result就可以了。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def rightSideView(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root:
            return []
        
        queue = collections.deque([root])
        
        result = []
        size = 0
        while(queue):
            #level = []
            for _ in range(len(queue)):
                
                cur = queue.popleft()
                
                result.append(cur.val)
                        
                #if cur.left:
                    #queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            #result.append(level)
        
        return result
        
#不是这样写的
#参考答案：

class Solution:
    def rightSideView(self, root: TreeNode) -> List[int]:
        if not root:
            return []
        
        queue = collections.deque([root])
        right_view = []
        
        while queue:
            level_size = len(queue)
            
            for i in range(level_size):
                node = queue.popleft()
                
                #关键在这一步
                if i == level_size - 1:
                    right_view.append(node.val)
# 用于检查当前节点的索引 i 是否等于当前层的节点数减一。
# 也就是说，它在循环中检查当前节点是否是当前层的最后一个节点。             
                
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        
        return right_view

1.3

637. Average of Levels in Binary Tree

# 637. Average of Levels in Binary Tree
     if not root:
            return []
        
        queue = collections.deque([root])

        result = []
        
        while(queue):
            size = len(queue)
            level_sum = 0
            
            
            for i in range(size):
                
                cur = queue.popleft()
                
                level_sum += cur.val
                
                        
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
                
            #这里错了，注意精确度 float
            result.append(level_sum / size)
            
            
           
        return result

1.4

429. N-ary Tree Level Order Traversal

# 429 N叉树 N-ary Tree Leve order Traversal

# The line for child in node.children: is a loop that iterates over each child node of the current node.
# queue.append(child) adds each child node to the end of the queue. 
# This ensures that the child nodes will be processed in the next level of the traversal.

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: Node
        :rtype: List[List[int]]
        """
        if not root:
            return []
        
        queue = collections.deque([root])
        
        
        result = []
        while(queue):
            
            #重点变动：
            level_size = len(queue)
            level = []
            
            for _ in range(level_size):
                
                cur = queue.popleft()
                
                #这里变成level而不是result
                level.append(cur.val)
                
                for child in cur.children:
                    queue.append(child)
                
                #if cur.left:
                    #queue.append(cur.left)
                #if cur.right:
                    #queue.append(cur.right)
            
            result.append(level)
            
            
        return result

1.5

515. Find Largest Value in Each Tree Row

# 515. Find Largest Value in Each Tree Row
if not root:
    return []

    queue = collections.deque([root])
    
    result = []
    
    while(queue):
        size = len(queue)
        # 注意⚠️这里要设置一个最小数来确定没有树节点比它大
        level_max = 0
        
        #这是负无穷大
        level_max = float('-inf')
        
        for i in range(size):
            
            cur = queue.popleft()
            
            if cur.val > level_max:
                level_max = cur.val
            
            if cur.left:
                queu.append(cur.left)
            if cur.right:
                queue.append(cur.right)
        
        result.append(level_max)
    
    return result
                

1.6

116. Populating Next Right Pointers in Each Node

1.7

67 填充节点先跳过

1.8 最大深度【重要】

104. Maximum Depth of Binary Tree

# 104. Maximum Depth of Binary Tree
# 515. Find Largest Value in Each Tree Row


    queue = collections.deque([root])
    
    result = 0
    
    if not root:
        return result
    
    while(queue):
        size = len(queue)
        
        result += 1
        
        for i in range(size):
            
            cur = queue.popleft()
            
            
            if cur.left:
                queu.append(cur.left)
            if cur.right:
                queue.append(cur.right)
        
    
    return result
                

1.9 最小深度

​​​​​​111. Minimum Depth of Binary Tree

2、翻转二叉树

在下一章

3、对称二叉树

3.1 traversal use post order

3.2 use symmetric queue

import collections

class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if not root:
            return []
        #这里不是加入根节点，而是加入左右孩子？为什么
        #queue = collections.deque([root])
        queue = collections.deque()
        queue.append(root.left)
        queue.append(root.right)
        # 因为要比较的就是左右孩子节点
        
        #result = []
        while queue:
            #level = []
            #for _ in range(len(queue)):
                #cur = queue.popleft()
                #level.append(cur.val)
            
            leftNode = queue.popleft()
            rightNode = queue.popleft()
            
            # 左节点、右节点为空，说明此时对称
            if not leftNode and not rightNode:
                continue
            
            if not leftNode or not rightNode or leftNode.val != rightNode.val:
                return False
            
            queue.append(leftNode.left)
            queue.append(rightNode.right)
            queue.append(leftNode.right)
            queue.append(rightNode.left)       
            #queue.append(cur.right)
           
        return True