python-leetcode-1022. 从根到叶的二进制数之和

1022. 从根到叶的二进制数之和 - 力扣（LeetCode）

可以使用深度优先搜索（DFS）或广度优先搜索（BFS）遍历整棵二叉树，在遍历过程中维护当前路径表示的二进制数，并在到达叶子节点时将其累加到结果中。

解法：

1. DFS 递归：

   • 用一个变量 currentSum 记录当前路径的二进制值。

   • 当遍历到叶子节点时，将 currentSum 加入总和。

   • 递归遍历左右子树，将 currentSum 左移一位，并加上当前节点的值。

2. BFS 迭代：

   • 使用队列存储 (node, currentSum)，进行层序遍历。

   • 在到达叶子节点时累加总和。

---

代码实现：

方法 1：递归 DFS

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

class Solution:
    def sumRootToLeaf(self, root: TreeNode) -> int:
        def dfs(node, currentSum):
            if not node:
                return 0
            
            currentSum = (currentSum << 1) | node.val  # 左移并加上当前节点值
            
            # 如果是叶子节点，直接返回当前路径的值
            if not node.left and not node.right:
                return currentSum
            
            # 递归求左子树和右子树的路径和
            return dfs(node.left, currentSum) + dfs(node.right, currentSum)
        
        return dfs(root, 0)

方法 2：迭代 BFS

from collections import deque

class Solution:
    def sumRootToLeaf(self, root: TreeNode) -> int:
        if not root:
            return 0
        
        total_sum = 0
        queue = deque([(root, 0)])  # (节点, 当前路径值)
        
        while queue:
            node, currentSum = queue.popleft()
            currentSum = (currentSum << 1) | node.val  # 更新当前路径的二进制值
            
            # 如果是叶子节点，加到总和
            if not node.left and not node.right:
                total_sum += currentSum
            
            # 左右子树入队
            if node.left:
                queue.append((node.left, currentSum))
            if node.right:
                queue.append((node.right, currentSum))
        
        return total_sum

复杂度分析：

• 时间复杂度： O(N)，其中 N 为二叉树的节点数，每个节点访问一次。

• 空间复杂度： O(H)，H 为二叉树的高度（最坏 O(N)，平衡树 O(log N)）。

这两种方法都可以正确求解问题，DFS 递归更简洁，BFS 适用于避免递归栈溢出情况。