Javascript 尝试返回二叉树的级别顺序遍历

我在白板上编写了以下代码，根据这一步骤，它给出了正确的结果；然而，在计算机上运行它却证明了这一点。代码如下：

class TreeNode {
    constructor(val) {
        this.val = val
        this.left = this.right = null
    }
}

const levelOrderBottom = root => {
    let visited = []
    if (!root) return visited
    let queue = [root, 's']
    let current
    let row = []

    while (queue.length > 1) {
        current = queue.shift()
        if (current === 's') {
            visited.unshift(row)
            row = []
            queue.push('s')
        } else {
            if (current.left) queue.push(current.left)
            if (current.right) queue.push(current.right)
            row.push(current.val)
        }
    }
    return visited
}

//example 1
const tree1 = new TreeNode(3)
tree1.left = new TreeNode(9)
tree1.right = new TreeNode(20)
tree1.right.left = new TreeNode(15)
tree1.right.right = new TreeNode(7)

console.log(levelOrderBottom(tree1)) //[ [15,7], [9,20], [3] ]

树和输出应该如下所示

Given binary tree [3,9,20,null,null,15,7],
    3
   / \
  9  20
    /  \
   15   7
return its bottom-up level order traversal as:
[
  [15,7],
  [9,20],
  [3]
]

---

但是，我只得到

[[9,20]，[3]]

。我无法指出我逻辑上的缺陷。关于我做错了什么，你有什么想法吗？

你没有调用

已访问。当
queue.length==1
时，取消移动（行）

，尽管

row

仍然包含你想要添加的结果。

当

queue.length==1时，你没有调用
已访问。取消移动（行）
，尽管
行
仍包含要添加的结果。
您可以存储一个级别并分配给该级别


类树节点{
构造函数（val）{
this.val=val
this.left=null
this.right=null
}
}
const levelOrderBottom=根=>{
让我们访问=[]
如果（！root）返回访问
让队列=[[root，0]]
while（queue.length）{
let[current，level]=queue.shift（）
如果（！已访问[level]）已访问[level]=[]
if（current.left）queue.push（[current.left，level+1]）
if（current.right）queue.push（[current.right，level+1]）
已访问[level]。推送（current.val）
}
return.reverse（）
}
//例1
常量树1=新树节点（3）
树1.left=新树节点（9）
树1.right=新树节点（20）
树1.right.left=新树节点（15）
tree1.right.right=新树节点（7）
log（levelOrderBottom（tree1））/[[15,7]，[9,20]，[3]]
您可以存储一个级别并分配给该级别


类树节点{
构造函数（val）{
this.val=val
this.left=null
this.right=null
}
}
const levelOrderBottom=根=>{
让我们访问=[]
如果（！root）返回访问
让队列=[[root，0]]
while（queue.length）{
let[current，level]=queue.shift（）
如果（！已访问[level]）已访问[level]=[]
if（current.left）queue.push（[current.left，level+1]）
if（current.right）queue.push（[current.right，level+1]）
已访问[level]。推送（current.val）
}
return.reverse（）
}
//例1
常量树1=新树节点（3）
树1.left=新树节点（9）
树1.right=新树节点（20）
树1.right.left=新树节点（15）
tree1.right.right=新树节点（7）
console.log（levelOrderBottom（tree1））/[[15,7]，[9,20]，[3]]
当您需要分为多个级别时，不需要使用队列：

const levelOrderBottom = root => {
  let visited = []
  let row = root ? [root] : []
  while(row.length > 0) {
    visited.unshift(row.map(n => n.val))
    row = row
      .flatMap(n => [n.left, n.right])
      .filter(n => n!=null);
  }
  return visited
}

当需要分为多个级别时，不需要使用队列：

const levelOrderBottom = root => {
  let visited = []
  let row = root ? [root] : []
  while(row.length > 0) {
    visited.unshift(row.map(n => n.val))
    row = row
      .flatMap(n => [n.left, n.right])
      .filter(n => n!=null);
  }
  return visited
}

您只是没有按最后一行

，您只是没有按最后一行