使用Javascript实现二叉树级顺序遍历

这是一个leetcode问题

给定二叉树，返回其节点值的级别顺序遍历。（即，从左到右，逐级）

例如： 给定二叉树[3,9,20,null,null,15,7]

    3
   / \
  9  20
    /  \
   15   7

将其级别顺序遍历返回为：

[
  [3],
  [9,20],
  [15,7]
]

但我正在用JavaScript尝试一种新的方式，而不是完全按照他们的解决方案。到目前为止，我能够打印阵列，但

如何在新行中打印不同的级别

以下是我目前的代码：

var levelOrder = function(root) {
let output = [];
let queue = [];
let currentNode = root;
queue.push(currentNode);
let currentLevel = 1;
while(queue.length){
    
    currentNode = queue.shift();
    currentLevel--; //this will ensure we are adding new lines only on next level
    output.push(currentNode);
    
    if(currentNode.left){
        queue.push(currentNode.left);
    }
    if(currentNode.right){
        queue.push(currentNode.right);
    }
    
    if(currentLevel = 0){
        output = output + '/n'; //Insert a new line
        currentLevel = queue.length; //2
    }
}
return output;
};

输入：[3,9,20，空，空，15,7]

LeetCode问题链接：

---

我想你就快到了。不确定什么

output=output+'/n'是用于

这将通过：

var levelOrder = function(root) {
    const levels = []

    if(!root) {
        return levels
    }

    const queue = [root]
    while (queue.length){
       const queueLength = queue.length
       const level = []

       for(let i = 0; i < queueLength; i++){

           const node = queue.shift()

           if(node.left){
               queue.push(node.left)
           }
           if(node.right){
               queue.push(node.right)
           }

           level.push(node.val)
       }
       levels.push(level)
   }
    return levels
}

var levelOrder=函数（根）{
常量级别=[]
如果（！root）{
回报水平
}
常量队列=[root]
while（queue.length）{
常量queueLength=queue.length
常量级别=[]
for（设i=0；i


工具书类

有关其他详细信息，请参见。这里有很多公认的解决方案，有各种解释和解释，有高效的算法，还有渐近/复杂性分析
基于您的代码库，我修改它以便工作


添加用于增加输出索引的索引
使用严格相等运算符而不是赋值变量
删除
output=output+'/n'
，因为输出是一个数组


var levelOrder=函数（根）{
让输出=[]；
让队列=[]；
让currentNode=root；
push（currentNode）；
设currentLevel=1；
让index=0；//添加一个索引以增加输出索引
while（queue.length）{
currentNode=queue.shift（）；
当前级别--；
如果（！output[index]）{//Set default是第一次为每个输出元素设置的数组
输出[索引]=[]；
}
输出[index].push（currentNode.val）；
if（currentNode.left）{
queue.push（currentNode.left）；
}
if（currentNode.right）{
push（currentNode.right）；
}
如果（currentLevel==0）{//使用严格相等运算符比较0
index++；//增加索引
currentLevel=queue.length；
}
}
返回输出；
};那个；这是一个很好的解决方案，你击中了靶心。我是Javascript新手，所以基本上您有级别数组，每次子节点完成时，您都会将此数组推到父数组级别。新行对于数组来说并不重要，只是为了显示，但我想如果我们需要将其显示为字符串，那么必须输入新行。谢谢。你正在寻找的战略是BFS，请参考以下链接-和
var levelOrder = function(root) {
    const levels = []

    if(!root) {
        return levels
    }

    const queue = [root]
    while (queue.length){
       const queueLength = queue.length
       const level = []

       for(let i = 0; i < queueLength; i++){

           const node = queue.shift()

           if(node.left){
               queue.push(node.left)
           }
           if(node.right){
               queue.push(node.right)
           }

           level.push(node.val)
       }
       levels.push(level)
   }
    return levels
}