1.問題描述

給定一個二叉樹，它的每個結點都存放一個0-9的數字，每條從根到葉子節點的路徑都代表一個數字。

例如，從根到葉子節點路徑 1->2->3 代表數字 123。

計算從根到葉子節點生成的所有數字之和。

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

示例 1:

輸入: [1,2,3]
1
/ \
2 3
輸出: 25
解釋:
從根到葉子節點路徑 1->2 代表數字 12.
從根到葉子節點路徑 1->3 代表數字 13.
因此，數字總和 = 12 + 13 = 25.

示例 2:

輸入: [4,9,0,5,1]
4
/ \
9 0
/ \
5 1
輸出: 1026
解釋:
從根到葉子節點路徑 4->9->5

2.求解

深度優先遍歷

• 從根節點開始，遍歷每個節點。每層遞迴要做的就是再次呼叫遞迴函式計算左右子節點之和
• 遞迴停止的條件有兩個
  1. 當節點為空時，直接返回0
  2. 當節點左右子節點均為空是，說明遍歷至終點，此時返回sum

程式碼如下

/*
 * 執行用時：0 ms, 在所有 Java 提交中擊敗了100.00% 的使用者
 * 記憶體消耗：36.2 MB, 在所有 Java 提交中擊敗了87.91% 的使用者
 * */
public int sumNumbers(TreeNode root) {
    return dfs(root, 0);
}

public int dfs(TreeNode root,int prevSum){
    //當前節點為空，返回0
    if(root == null){
        return 0;
    }
    //不為空，計算sum
    int sum = prevSum * 10 + root.val;
    //左右節點為空，說明已經到達終點，返回sum
    if(root.left == null && root.right == null){
        return sum;
    }
    //左右節點有非空，繼續計算sum
    return dfs(root.left,sum) + dfs(root.right,sum);
}
 

• 時間、空間複雜度均為O(n)

廣度優先搜尋

• 維護兩個佇列，一個儲存節點，另一個儲存目前已經計算的sum
• 每次先取出一個節點，若左右節點不為空，將左右節點放入節點佇列，將當前節點的值乘10分別加左節點和右節點入sum佇列

程式碼如下

/*
 * 執行用時：1 ms, 在所有 Java 提交中擊敗了31.04% 的使用者
 * 記憶體消耗：36.5 MB, 在所有 Java 提交中擊敗了69.26% 的使用者
 * */
public int sumNumbers(TreeNode root) {
    if(root == null){
        return 0;
    }
    int sum = 0;
    Queue<TreeNode> nodeQueue = new LinkedList<>();
    Queue<Integer> numQueue = new LinkedList<>();
    nodeQueue.offer(root);
    numQueue.offer(root.val);
    while(!nodeQueue.isEmpty()){
        TreeNode node = nodeQueue.poll();
        int num = numQueue.poll();
        TreeNode left = node.left,right = node.right;
        if(left == null && right == null){
            sum += num;
        }else {
            if(left != null){
                nodeQueue.offer(left);
                numQueue.offer(num * 10 + left.val);
            }
            if(right != null){
                nodeQueue.offer(right);
                numQueue.offer(num * 10 + right.val);
            }
        }
    }
    return sum;
}
 

• 時間、空間複雜度均為O(n)