[Swift]LeetCode129. 求根到叶子节点数字之和 | Sum Root to Leaf Numbers

Given a binary tree containing digits from 0-9 only, each root-to-leaf path could represent a number.

An example is the root-to-leaf path 1->2->3 which represents the number 123.

Find the total sum of all root-to-leaf numbers.

Note: A leaf is a node with no children.

Example:

Input: [1,2,3]
    1
   / \
  2   3
Output: 25
Explanation:
The root-to-leaf path 1->2 represents the number 12.
The root-to-leaf path 1->3 represents the number 13.
Therefore, sum = 12 + 13 = 25.

Example 2:

Input: [4,9,0,5,1]
    4
   / \
  9   0
 / \
5   1
Output: 1026
Explanation:
The root-to-leaf path 4->9->5 represents the number 495.
The root-to-leaf path 4->9->1 represents the number 491.
The root-to-leaf path 4->0 represents the number 40.
Therefore, sum = 495 + 491 + 40 = 1026.

---

给定一个二叉树，它的每个结点都存放一个 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 代表数字 495.
从根到叶子节点路径 4->9->1 代表数字 491.
从根到叶子节点路径 4->0 代表数字 40.
因此，数字总和 = 495 + 491 + 40 = 1026.

---

12ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    func sumNumbers(_ root: TreeNode?) -> Int {
        guard let root = root else { return 0 }
        var sum = 0
        var stack: [(node: TreeNode, accum: Int)] = [(node: root, accum: 0)]
        
        while !stack.isEmpty {
            let currentVal = stack.removeLast()
            let updatedAccum = currentVal.accum * 10 + currentVal.node.val
            
            guard currentVal.node.left != nil || currentVal.node.right != nil else {
                sum += updatedAccum
                continue
            }
            
            if let leftNode = currentVal.node.left {
                stack.append((node: leftNode, accum: updatedAccum))
            }
            
            if let rightNode = currentVal.node.right {
                stack.append((node: rightNode, accum: updatedAccum))
            }
        }
        
        return sum
    }
    
}

---

16ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    func sumNumbers(_ root: TreeNode?) -> Int {
        if root == nil { return 0 }
        else {
            let result = getNumber(root!, 0)
            return result
        }
    }
    
    func getNumber(_ node: TreeNode, _ number: Int) -> Int {
        let currentNumber = number * 10 + node.val
        var result = 0
        if node.left == nil && node.right == nil {
            return currentNumber
        } else if node.left == nil {
            result = getNumber(node.right!, currentNumber)
        } else if node.right == nil {
            result = getNumber(node.left!, currentNumber)
        } else {
            result = getNumber(node.left!, currentNumber) + getNumber(node.right!, currentNumber)
        }
        return result
    }
}

---

20ms

class Solution {
    func sumNumbers(_ root: TreeNode?) -> Int {
        let nums = numbers(root)
        print(nums)
        return nums.reduce(0, { $0 + Int($1)! })
    }
    
    func numbers(_ root: TreeNode?) -> [String] {
        guard let root = root else { return [] }
        
        if root.left == nil && root.right == nil {
            return [String(root.val)]
        }
        
        return (numbers(root.left) + numbers(root.right)).map { String(root.val) + $0 }
    }
}

---

24ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    func sumNumbers(_ root: TreeNode?) -> Int {
            var sum = 0
            treeShowNodeVal(root: root, item: "", sum: &sum)
            return sum
        }
        func treeShowNodeVal(root: TreeNode?, item: String, sum: inout Int){
            if root == nil {
                return
            }
            var newItem = item
            newItem.append(String((root?.val)!))
            if root?.left == nil && root?.right == nil {
                let itemValue = Int(newItem)
                sum = sum + itemValue!
            }
            treeShowNodeVal(root: root?.left, item: newItem, sum: &sum)
            treeShowNodeVal(root: root?.right, item: newItem, sum: &sum)
        }
}

---

28ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    func sumNumbers(_ root: TreeNode?) -> Int {
        var array = [String]()
        guard let root = root else { return 0 }
        
        func helper(_ node: TreeNode, _ temp: String) {
            var temp = temp + "\(node.val)"
            if node.left == nil && node.right == nil {
                array.append(temp)
            } else {
                if let left = node.left {
                    helper(left, temp)    
                }
                if let right = node.right {
                    helper(right, temp)    
                }
            }
        }
        
        helper(root, "")
        return array.reduce(0, {return $0 + Int($1)!})
    }
}