Question

我正在构建树遍历函数，它必须使用递归。

我想要的输出是

'{"value":9,"left":{"value":4,"left":{"value":1},"right":{"value":6}},"right":{"value":20,"left":{"value":15},"right":{"value":170}}}'

有人能弄清楚如何在traverse函数中使用递归来获取输出吗？

这是我的JS：

   
    class Node {
       constructor(value){
       this.left = null;
       this.right = null;
       this.value = value;
      }
     }

    class BinarySearchTree {
         constructor(){
         this.root = null;
     }
    insert(value){
        const newNode = new Node(value);
    if (this.root === null) {
        this.root = newNode;
    } else {
        let currentNode = this.root;
        while(true){
        if(value < currentNode.value){
          //Left
          if(!currentNode.left){
            currentNode.left = newNode;
            return this;
          }
          currentNode = currentNode.left;
        } else {
          //Right
          if(!currentNode.right){
            currentNode.right = newNode;
            return this;
          } 
          currentNode = currentNode.right;
          }
         }
        }
       }  
      }

     const tree = new BinarySearchTree();
     tree.insert(9)
     tree.insert(4)
     tree.insert(6)
     tree.insert(20)
     tree.insert(170)
     tree.insert(15)
     tree.insert(1)
     JSON.stringify(traverse(tree.root))

    //     9
   //  4     20
   //1  6  15  170

  function traverse(node) {
      const tree = { value: node.value };
      tree.left=node.left
       if(node.left===null) {
            return  null
      }else{
           traverse(node.left);
      }     
      tree.right=node.right
          if(node.right===null) {
                 return null
          }else{
                 traverse(node.right);
            }
       }

Answer 1

您处在正确的轨道上；我看到结果字符串中需要特殊格式的对象。我建议首先检查当前节点是否为空。如果是这样，则什么也不返回（调用函数将忽略此键）。否则，请创建一个节点对象以准备返回并遍历左右子级。递归遍历两个子树后，返回根节点。这样将从叶子开始构建结果结构，并以根结尾。

在您的代码中，

   if(node.left===null) {
        return  null

例如，

还为时过早。如果node拥有正确的子树，我们不想放弃遍历它。在所有情况下，除了空孩子之外，还必须将某些东西返回给呼叫者。

此外，您可以考虑将traverse放在BinaryTree类中，并使其在其成员字段中进行操作；在下面的示例中，我保持原样。

最后，这是pre-order traversal；首先访问根，然后访问左侧和右侧子树。

function traverse(node) {
  if (node) {
    const left = traverse(node.left);
    const right = traverse(node.right);    
    return {
      value: node.value,
      [left&&"left"]: left,
      [right&&"right"]: right
    };
  }
}

class Node {
  constructor(value, left=null, right=null) {
    this.value = value;
    this.left = left;
    this.right = right;
  }
}

class BinarySearchTree {
  constructor() {
    this.root = null;
  }
  
  insert(value) {
    const newNode = new Node(value);
    
    if (this.root === null) {
      this.root = newNode;
    } 
    else {
      let currentNode = this.root;
      
      while (true) {
        if (value < currentNode.value) {
          if (!currentNode.left) {
            currentNode.left = newNode;
            return this;
          }
          
          currentNode = currentNode.left;
        } 
        else {
          if (!currentNode.right) {
            currentNode.right = newNode;
            return this;
          }
          
          currentNode = currentNode.right;
        }
      }
    }
  }
}

const tree = new BinarySearchTree();
tree.insert(9);
tree.insert(4);
tree.insert(6);
tree.insert(20);
tree.insert(170);
tree.insert(15);
tree.insert(1);
console.log(JSON.stringify(traverse(tree.root)));
console.log(traverse(tree.root));

//      9
//   4     20
// 1  6  15  170

如何在Javascript中使用递归函数遍历树

1 个答案: