JS 实现 二叉树

① 二叉树定义
② 二叉排序树
③ 二叉平衡树

① 二叉树定义

二叉树（Binary tree）是每一个节点最多只有两个分支(不存在分支度大于2的节点)的树结构。一般分支被称为「左子树」和「右子树」。二叉树的分支具备左右次序，不能颠倒。

② 二叉排序树

简单定义
二叉排序树 又称为 二叉搜索树或二叉查找树
特征
(1) 若它的左子树不空，则左子树上全部结点的值均小于它的根结点的值
(2) 若它的右子树不空，则右子树上全部结点的值均大于它的根结点的值
(3) 它的左、右子树也分别为二叉查找树
Javascript实现

function BinarySearchTree(keys){
  //Node构造函数
  let Node = function (key){
     this.key = key
     this.left = null
     this.right = null
  }
  let root = null
  let insertNode = (node,newNode)=>{
     if(newNode.key < node.key){
       if(node.left === null){
         node.left = newNode
       }else {
         insertNode(node.left,newNode)
       }
     }else {
       if (node.right === null) {
         node.right = newNode
       }else {
         insertNode(node.right,newNode)
       }
     }
  }
  this.insert = (key)=>{
     let newNode = new Node(key)
     if (root === null) {
       root = newNode
     }else {
       insertNode(root,newNode)
     }
  }
  keys.forEach((key)=>{
   this.insert(key)
  })
  return root
}
const keys = [8,3,10,1,6,14,4,7,13]
BinarySearchTree(keys)

chrome中打印以下：

效果图：

中序遍历
中序遍历的递归定义：先左子树，后根节点，再右子树

let inOrderTraverseFunction =(node,cb)=>{
   if(node!==null){
      inOrderTraverseFunction(node.left,cb)
      cb(node.key)
      inOrderTraverseFunction(node.right,cb)
   }
} 
let callback =(key)=>{
  console.log(key)
}
//BST的中序遍历
inOrderTraverseFunction(BinarySearchTree(keys),callback)

chrome中打印以下：

结果：整颗二叉树节点以从小到大依次显示

前序遍历
前序遍历的递归定义：先根节点，后左子树，再右子树

let preOrderTraverseFunction =(node,cb)=>{
   if(node!==null){
      cb(node.key)
      preOrderTraverseFunction(node.left,cb)
      preOrderTraverseFunction(node.right,cb)
   }
} 
//BST前序遍历
preOrderTraverseFunction(BinarySearchTree(keys),callback)

chrome打印以下

后序遍历
后序遍历的递归定义：先左子树，后右子树，再根节点

let postOrderTraverseFunction =(node,cb)=>{
   if(node!==null){
      postOrderTraverseFunction(node.left,cb)
      postOrderTraverseFunction(node.right,cb)
      cb(node.key)
   }
} 
//BST后序遍历
postOrderTraverseFunction(BinarySearchTree(keys),callback)

chrome打印以下

查找BST最小值
白话:即二叉树左子树最左侧的那个没有左子树的节点

let minNode =(node)=>{
  if(node){
    while (node&&node.left !== null){
       node = node.left
    }
    return node.key
  }
  return null
}
//查找BST最小值
console.log('the min node is '+minNode(BinarySearchTree(keys)))

chrome打印以下

查找BST最大值
白话:即二叉树右子树最右侧的那个没有右子树的节点

let maxNode =(node)=>{
  if(node){
    while (node&&node.right !== null){
       node = node.right
    }
    return node.key
  }
  return null
}
//查找BST最大值
console.log('the max node is '+maxNode(BinarySearchTree(keys)))

chrome打印以下

查找BST某个值
即将该值和每一个节点比较 若是该值比此节点小 则进入左子树再递归比较 反之 若是该值比此节点大 则进入右子树再递归比较

let searchNode = (node,key)=>{
  if(node === null){
    return false   
  }
  if(key<node.key){
    return searchNode(node.left,key)
  }else if (key>node.key) {
    return searchNode(node.right,key)
  }else{
    return true
  }
}
//BST查找某个值
console.log(searchNode(BinarySearchTree(keys),3)?'node 3 is found':'node 3 is not found')
console.log(searchNode(BinarySearchTree(keys),5)?'node 5 is found':'node 5 is not found')

chrome打印以下:

删除BST某个叶子节点
叶子节点：没有左子树和右子树的节点

let removeNode = (node,key)=>{
  if(node === null){
    return null
  }
  if(key<node.key){
    node.left = removeNode(node.left,key)
    return node
  }else if(key>node.key){
    node.right = removeNode(node.right,key)
    return node
  } else{
    if(node.left === null && node.right === null){
      node = null
      return node
    }
  }
}
//BST删除某个叶子节点
console.log(removeNode(BinarySearchTree(keys),1),BinarySearchTree(keys))

chrome打印以下:

效果图：

删除BST某个度为1的节点

let removeNode = (node,key)=>{
  if(node === null){
    return null
  }
  if(key<node.key){
    node.left = removeNode(node.left,key)
    return node
  }else if(key>node.key){
    node.right = removeNode(node.right,key)
    return node
  } else{
    if(node.left === null && node.right === null){
      node = null
      return node
    }
    if(node.left === null){
      node = node.right
      return node
    }else if (node.right === null) {
      node = node.left
      return node     
    }
  }
}
//BST删除某个度为1的子节点
console.log(removeNode(BinarySearchTree(keys),10),BinarySearchTree(keys))

chrome打印以下:

效果图：

删除BST某个度为2的节点

let findMinNode = (node) =>{
  if(node){
    while(node&& node.left !== null){
      node = node.left
    }
    return node 
  }
  return null
}
let removeNode = (node,key)=>{
  if(node === null){
    return null
  }
  if(key<node.key){
    node.left = removeNode(node.left,key)
    return node
  }else if(key>node.key){
    node.right = removeNode(node.right,key)
    return node
  } else{
    if(node.left === null && node.right === null){
      node = null
      return node
    }
    if(node.left === null){
      node = node.right
      return node
    }else if (node.right === null) {
      node = node.left
      return node     
    }
    let minNode = findMinNode(node.right) 
    node.key = minNode.key
    node.right = removeNode(node.right,minNode.key)
    return node
  }
}
//BST删除某个度为2的子节点
console.log(removeNode(BinarySearchTree(keys),3),BinarySearchTree(keys))

chrome打印以下:

效果图：

未完待续