二叉搜索树

// 节点
class Node{
  constructor(value){
    this.value=value;
    this.left=null;
    this.right=null;
  }
}

// 二叉搜索树
class BinarySearchTree{
  constructor(){
    this.root=null;
  }
  // 插入节点到合适位置
  insertNode(node,newNode){
    // 判断新节点与当前节点的大小，然后小放左大放右
    if(newNode.value>node.value){
      // 判断是否为末节点，不为则递归调用插入合适位置
      if(node.right===null){
        node.right=newNode
      }else{
        this.insertNode(node.right,newNode)
      }
    }else if(newNode.value<node.value){
      if(node.left===null){
        node.left=newNode
      }else{
        this.insertNode(node.left,newNode)
      }
    }
  }
  // 插入操作
  insert(value){
    let newNode=new Node(value)
    // 判断是否有值，有值则调用插入合适节点的操作
    if(this.root===null){
      this.root=newNode
    }else{
      this.insertNode(this.root,newNode)
    }
  }

  // 先序遍历
  preOrderTraversal(cb){
    this.preOrderTraversalNode(this.root,cb)
  }
  
  preOrderTraversalNode(node,cb){
    if(node===null) return
    cb(node.value)
    this.preOrderTraversalNode(node.left,cb)
    this.preOrderTraversalNode(node.right,cb)
  }

  // 中序遍历
  miOrderTraversal(cb){
    this.miOrderTraversalNode(this.root,cb)
  }
  miOrderTraversalNode(node,cb){
    if(node===null) return
    this.miOrderTraversalNode(node.left,cb)
    cb(node.value)
    this.miOrderTraversalNode(node.right,cb)
  }

  // 后序遍历
  postOrderTraversal(cb){
    this.postOrderTraversalNode(this.root,cb)
  }
  postOrderTraversalNode(node,cb){
    if(node===null) return
    this.postOrderTraversalNode(node.left,cb)
    this.postOrderTraversalNode(node.right,cb)
    cb(node.value)
  }

  max(){
    let node=this.root
    while(node.right!==null){
      node=node.right
    }
    return node.value
  }

  min(){
    let node=this.root
    while(node.left!==null){
      node=node.left
    }
    return node.value
  }

  search(val){
    let node=this.root
    while(node!==null){
      if(node.value>val){
        node=node.left
      }else if(node.value<val){
        node=node.right
      }else{
        return true
      }
    }
  }
}


// const code=new Node(1);
// console.log(code);

const bst= new BinarySearchTree()
bst.insert(11)
bst.insert(7)
bst.insert(15)
bst.insert(5)
bst.insert(9)
bst.insert(13)
bst.insert(20)
bst.insert(3)
bst.insert(8)
bst.insert(10)
// console.log(bst);

const rst=[];
const cb=(val)=>{
  rst.push(val)
}

// bst.preOrderTraversal(cb)
// bst.miOrderTraversal(cb)
bst.postOrderTraversal(cb)

console.log(rst);

console.log(bst.max());
console.log(bst.min());
console.log(bst.search(10));