使用JavaScript

Question

这是一个leetcode问题。

二进制树，返回其节点值的级别顺序遍历。 （即，从左到右，按级别按级别）。

例如： 给定二进制树

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

，

    3
   / \
  9  20
    /  \
   15   7

返回其水平顺序遍历：

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

，但是我正在尝试一种新的JavaScript，而不是完全通过他们的解决方案来进行。到目前为止，我能够打印阵列但是

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

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

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

我认为你快到了。不确定是什么是为了什么。 this'将通过：

Answer 1

参考

有关其他详细信息，您可以看到

障碍委员会。有很多接受的解决方案，具有各种

语言和解释，有效的算法以及渐近

Time

/

---

Space

-Space

复杂性分析

• 1，2 在您的代码库上，我将其修改为工作。 添加了增加输出索引的索引。 使用严格的平等操作员而不是分配变量。 反弹

  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
  }

  ，因为输出是一个数组。

Answer 2

output = output + '/n'

• 这是IT的递归解决方案

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;
};

您可以在@ahmadatrach'Code

中尝试此一点修改

    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;
};

本JavaScript代码使用了广度优先搜索（BFS）模式。您还可以使用此代码

Answer 3

Reference