js二叉树

二叉树：

二叉树的每个节点最多有两个子节点的树结构

根结点：

一棵树最上面的节点称之为根结点

父节点，字节点：

如果一个下面连接多个子节点，那么这个节点就是父节点，下面的节点称之为子节点

满二叉树：

一棵二叉树的结点要么是叶子结点，要么它有两个子结点（如果一个二叉树的层数为K，且结点总数是(2^k) -1，则它就是满二叉树。）

完全二叉树：

若设二叉树的深度为k，除第 k 层外，其它各层 (1～k-1) 的结点数都达到最大个数，第k 层所有的结点都连续集中在最左边，这就是完全二叉树。

平衡二叉树：

它或者是一颗空树，或它的左子树和右子树的深度之差(平衡因子)的绝对值不超过1，且它的左子树和右子树都是一颗平衡二叉树。
实现代码

class Tree {
  constructor(key) {
      this.key = key
      this.left = null
      this.right = null
  }
}

class BinarySearchTree {
  constructor(key) {
      this.root = null
      this.keys = key
  }
  // 创建二叉树 
  insertNode(root, newTree) {
      if (newTree.key < root.key) {
          if (root.left === null) {
              root.left = newTree
          } else {
              this.insertNode(root.left, newTree)
          }
      } else {
          if (root.right === null) {
              root.right = newTree
          } else {
              this.insertNode(root.right, newTree)
          }
      }
  }
  sortTree() {
      this.keys.forEach(ele => {
          let a = new Tree(ele)
          if (this.root === null) {
              this.root = a
          } else {
              this.insertNode(this.root, a)
          }
      });
      return this.root
  }
  //中序遍历的递归定义：先左子树，后根节点，再右子树
  inOrderTraverseFunction(node, cb) {
      // console.log(node,'aaaa')
      if (node !== null) {
          this.inOrderTraverseFunction(node.left, cb)
          cb(node.key)
          this.inOrderTraverseFunction(node.right, cb)
      }
  }
  // 前序遍历的递归定义：先根节点，后左子树，再右子树
  preOrderTraverseFunction(node, cb) {
      if (node !== null) {
          cb(node.key)
          this.preOrderTraverseFunction(node.left, cb)
          this.preOrderTraverseFunction(node.right, cb)
      }
  }
  //后序遍历的递归定义：先左子树，后右子树，再根节点
  postOrderTraverseFunction = (node, cb) => {
      if (node !== null) {
          this.postOrderTraverseFunction(node.left, cb)
          this.postOrderTraverseFunction(node.right, cb)
          cb(node.key)
      }
  }
  // 寻找最小值  寻找二叉树左子树最左侧那个没有子节点的树
  minNode(node) {
      if (node) {
          while (node && node.left !== null) {
              node = node.left
          }
          console.log(node.key)
          return node.key
      }
      return null
  }
  // 寻找最大值 寻找二叉树右子树最右侧没有子节点的树
  maxNode(node) {
      if (node) {
          while (node && node.right !== null) {
              node = node.right
          }
          console.log(node.key)
          return node.key
      }
      return null
  }

  // 寻找某个值
  searchNode(node, key) {
      if (node === null) {
          return false
      }
      if (key < node.key) {
          return this.searchNode(node.left, key)
      } else if (key > node.key) {
          return this.searchNode(node.right, key)
      } else {
          return true
      }
  }
  // 删除某个叶子节点
  removeNode(node, key) {
      if (node === null) {
          return null
      }
      if (key < node.key) {
          node.left = this.removeNode(node.left, key)
          return node
      } else if (key > node.key) {
          node.right = this.removeNode(node.right, key)
          return node
      } else {
          if (node.left === null && node.right === null) {
              node = null
              return node
          }
      }
  }
}
let callback = (key) => {
  console.log(key)
}