给定一颗二叉树，从根节点到叶子节点组成一个数，计算一颗二叉树所有叶子节点之和

leetcode 地址：
https://leetcode-cn.com/problems/sum-root-to-leaf-numbers/

自己的解法：

先获取叶子节点的每一个遍历的数字为数组，再对其求和
没有想到可以利用每一个节点的数字为上一个节点数字10再加上当前值*

function (root){
  let stackPtr =[];
  let stackArr = []
  let ptr = root;
  let bianli = []
  let result = []
  while(ptr){
    bianli.push(ptr.val)
    if(ptr.right){
      stackPtr.push(ptr.right)
      stackArr.push(bianli)
    }
    if(ptr.left){
      ptr = ptr.left
    }else{
      ptr = stackPtr.pop()
      if(!ptr.right) result.push([...stackArr.pop()))
    }
  }
return result.reduce((pre,cur)=>{
  return pre+=Number(cur.join(''))
  },0)
}

太复杂了

官方解法

深度遍历

如果一个节点是叶子节点，所代表的值为前一个节点的值*10加上当前值
如果一个节点有左右节点，则对其左右节点值相加即为当前节点的值

var sumNumbers =  (root)=>{
    var tree = (root,sum)=>{
        if(!root)return 0
        sum = sum*10+root.val
        if(!root.left&&!root.right){
            return sum
        }else {
            return tree(root.right,sum)+tree(root.left,sum)
        }
    }
    return tree(root,0)

}

广度遍历

对求和和当前节点建立两个队列
对叶子节点，则直接返回队首的求和值
有左右节点，前一个值*10+当前值放入队列中

var sumNumbers =  (root)=>{
    if(!root)return 0
    var stackNum = []
    var stackPtr = []
    stackNum.push(root.val)
    stackPtr.push(root)
    let result = 0
    while(stackPtr.length){
        var nodePtr = stackPtr.shift()
        var nodeNum = stackNum.shift()
        if(!nodePtr.right&&!nodePtr.left){
            result+=nodeNum
        }
         if(nodePtr.left){
            stackPtr.push(nodePtr.left)
            stackNum.push(nodeNum*10+nodePtr.left.val)
        }
         if(nodePtr.right){
            stackPtr.push(nodePtr.right)
            stackNum.push(nodeNum*10+nodePtr.right.val)
        }
    }
    return result

}