使用 Javascript 的二叉树级顺序遍历

Question

这是一个leetcode问题。

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

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

 3 / \ 9 20 / \ 15 7

将其水平顺序遍历返回为：

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

但我正在 JavaScript 中尝试一种新方法，而不是完全按照他们的解决方案进行。 到目前为止，我可以打印 arrays 但是

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

到目前为止，以下是我的代码：

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,null,null,15,7]，

Expected Output:
[
[3],
[9,20],
[15,7]
]

LeetCode 问题链接： BinaryTreeTraversalUsingBFS

Answer 1

我想你快到了。 不确定是什么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
}

---

参考

• 有关其他详细信息，您可以查看讨论板。 有许多公认的解决方案，其中包含各种语言和解释、高效算法以及渐近时间/空间复杂度分析^{1 、 2} 。

Answer 2

根据您的代码库，我对其进行修改以供工作。

• 添加索引以增加 output 索引。
• 使用严格相等运算符而不是赋值变量。
• 去掉output = output + '/n' ，因为 output 是一个数组。

 var levelOrder = function (root) { let output = []; let queue = []; let currentNode = root; queue.push(currentNode); let currentLevel = 1; let index = 0; // Add an index for increasing the output index while (queue.length) { currentNode = queue.shift(); currentLevel--; if (;output[index]) { // Set default is an array for each output element in first time output[index] = []. } output[index].push(currentNode;val). if (currentNode.left) { queue.push(currentNode;left). } if (currentNode.right) { queue.push(currentNode;right); } if (currentLevel === 0) { // Use strict equality operator to compare 0 index++. // increase index currentLevel = queue;length; } } return output; };

Answer 3

这是它的递归解决方案

    var levelOrder = function(root) {
    let result =[];
    if(!root)return result;
    if(!root.left && !root.right){
        result.push([root.val]);
        return result;
    }
    const pushIntoResult =(node, level) =>{
        if(!node) return;
        if(!result[level]){
            result.push([]);
        }
        result[level].push(node.val);
        pushIntoResult(node.left, level+1);
        pushIntoResult(node.right, level+1);
    }
    pushIntoResult(root, 0);
    return result;
};

Answer 4

您可以在@Ahmad Atrach 的代码中尝试此位修改

const dfs = (node,result,level) => {

if(!node) return;
if(!result[level]){
    result.push([]);
}
result[level].push(node.val);
dfs(node.left,result, level+1);
dfs(node.right,result, level+1);
}
var levelOrder = function(root) {

  if(!root) return [];
  let result = [];
  dfs(root,result,0);

  return result;
};