二叉树 题目合集

一、二叉树的层序遍历（广度搜索）从上到下打印二叉树

利用队列的 先进先出原则：

class Solution:
    def levelOrder(self, root: TreeNode) -> List[int]:
        if not root:
            return []
        List ,queue= [], collections.deque()
        queue.append(root)
        
        while(queue):
            node = queue.popleft()
            List.append(node.val)

            if node.left !=None:
                queue.append(node.left)
            if node.right !=None:
                queue.append(node.right)
        return List

二、二叉树按层输出 从上到下打印二叉树 II

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root:
            return []
        
        List = []
        que = collections.deque()

        que.append(root)
        while(que):
            sublist = []
            for node in range(len(que)):
                node = que.popleft()
                sublist.append(node.val)
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
            List.append(sublist)
        return List

三、之字形 打印二叉树：从上到下打印二叉树 III

1. 按照二叉树层序遍历的方法：偶数层倒叙输出，奇数层正序输出；（方法一）

2. 使用两个 双端队列，当为偶数层时，采用左侧插入；奇数层时右侧插入

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root:
            return []       
        List,que = [],collections.deque()
        que.append(root)
        high = 0
        while(que):
            high+=1
            sublist = collections.deque()
            for _ in range(len(que)):
                node = que.popleft()
                if high%2==0:    
                    sublist.appendleft(node.val)
                else:
                    sublist.append(node.val)

                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
            List.append(list(sublist))


        return List

四、路径总和

​​​​​​112. 路径总和

解法一：递归

将计算路径和长度 转化为 targetsum - val ？=0 的问题

class Solution:
    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        if not root :
            return False
        if not root.left and not root.right:
            if targetSum - root.val == 0:
                return True 
        return self.hasPathSum(root.left,targetSum-root.val) or self.hasPathSum(root.right,targetSum-root.val)

解法二：利用广度优先（BFS）的方法，记录从根节点到当前节点的路径和，避免重复计算。

使用两个队列，一个存储节点，一个存储路径和

import collections
class Solution:
    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        if not root:
            return False
        node_que = collections.deque()
        sum_que = collections.deque()
        node_que.append(root)
        sum_que.append(root.val)

        while node_que:
            root = node_que.popleft()
            Sum = sum_que.popleft() 
            if root.left:
                node_que.append(root.left)
                sum_que.append(root.left.val+Sum)
            if root.right:
                node_que.append(root.right)
                sum_que.append(root.right.val+Sum)
            if not root.left and not root.right:
                if targetSum == Sum:
                    return True 
        return False