JS实现二叉查找树，新手小白秒懂！

前端

2024-02-16 23:09:17

前言

前端开发中，我们经常需要处理各种各样的数据。为了高效地管理和操作这些数据，数据结构就显得尤为重要。二叉查找树（Binary Sort Tree）是一种常用的数据结构，它具有快速搜索和插入的特点，在前端开发中有着广泛的应用。

什么是二叉查找树？

二叉查找树是一种特殊的二叉树，它满足以下两个性质：

左子树的所有节点都小于根节点。
右子树的所有节点都大于根节点。

二叉查找树的实现

使用 JavaScript 实现二叉查找树非常简单，我们可以使用以下代码创建一个二叉查找树的类：

class BinarySearchTree {
  constructor() {
    this.root = null;
  }

  insert(value) {
    // 如果树为空，则直接将值插入为根节点
    if (this.root === null) {
      this.root = new Node(value);
    } else {
      // 否则，将值插入到相应的子树中
      this._insert(value, this.root);
    }
  }

  _insert(value, node) {
    // 如果值小于当前节点的值，则将其插入到左子树中
    if (value < node.value) {
      // 如果左子树为空，则直接将值插入为左子树的根节点
      if (node.left === null) {
        node.left = new Node(value);
      } else {
        // 否则，递归地将值插入到左子树中
        this._insert(value, node.left);
      }
    } else {
      // 如果值大于或等于当前节点的值，则将其插入到右子树中
      if (node.right === null) {
        node.right = new Node(value);
      } else {
        // 否则，递归地将值插入到右子树中
        this._insert(value, node.right);
      }
    }
  }

  search(value) {
    return this._search(value, this.root);
  }

  _search(value, node) {
    // 如果节点为空，则返回 false
    if (node === null) {
      return false;
    }

    // 如果值等于当前节点的值，则返回 true
    if (value === node.value) {
      return true;
    }

    // 如果值小于当前节点的值，则在左子树中搜索
    if (value < node.value) {
      return this._search(value, node.left);
    } else {
      // 否则，在右子树中搜索
      return this._search(value, node.right);
    }
  }

  min() {
    return this._min(this.root);
  }

  _min(node) {
    // 如果节点为空，则返回 null
    if (node === null) {
      return null;
    }

    // 如果左子树为空，则当前节点为最小值
    if (node.left === null) {
      return node.value;
    } else {
      // 否则，在左子树中寻找最小值
      return this._min(node.left);
    }
  }

  max() {
    return this._max(this.root);
  }

  _max(node) {
    // 如果节点为空，则返回 null
    if (node === null) {
      return null;
    }

    // 如果右子树为空，则当前节点为最大值
    if (node.right === null) {
      return node.value;
    } else {
      // 否则，在右子树中寻找最大值
      return this._max(node.right);
    }
  }

  remove(value) {
    this.root = this._remove(value, this.root);
  }

  _remove(value, node) {
    // 如果节点为空，则返回 null
    if (node === null) {
      return null;
    }

    // 如果值小于当前节点的值，则在左子树中寻找该值
    if (value < node.value) {
      node.left = this._remove(value, node.left);
    } else if (value > node.value) {
      // 如果值大于当前节点的值，则在右子树中寻找该值
      node.right = this._remove(value, node.right);
    } else {
      // 如果值等于当前节点的值，则删除该节点
      if (node.left === null && node.right === null) {
        // 如果该节点没有子节点，则直接删除该节点
        node = null;
      } else if (node.left === null) {
        // 如果该节点只有右子节点，则将右子节点提升为该节点
        node = node.right;
      } else if (node.right === null) {
        // 如果该节点只有左子节点，则将左子节点提升为该节点
        node = node.left;
      } else {
        // 如果该节点有左右子节点，则将该节点的值替换为左子树中的最大值，然后删除左子树中的最大值
        node.value = this._max(node.left);
        node.left = this._remove(node.value, node.left);
      }
    }

    // 返回根节点
    return node;
  }
}