【从蛋壳到满天飞】JS 数据结构解析和算法实现-红黑树（二）

时间  2019-11-06
标签 从蛋壳到满天飞 数据 结构 解析 算法 实现 栏目 JavaScript 繁體版
原文   原文链接

思惟导图

前言

【从蛋壳到满天飞】JS 数据结构解析和算法实现，所有文章大概的内容以下： Arrays(数组)、Stacks(栈)、Queues(队列)、LinkedList(链表)、Recursion(递归思想)、BinarySearchTree(二分搜索树)、Set(集合)、Map(映射)、Heap(堆)、PriorityQueue(优先队列)、SegmentTree(线段树)、Trie(字典树)、UnionFind(并查集)、AVLTree(AVL 平衡树)、RedBlackTree(红黑平衡树)、HashTable(哈希表)html

源代码有三个：ES6（单个单个的 class 类型的 js 文件） | JS + HTML（一个 js 配合一个 html）| JAVA (一个一个的工程)node

所有源代码已上传 github，点击我吧，光看文章可以掌握两成，动手敲代码、动脑思考、画图才能够掌握八成。git

本文章适合 对数据结构想了解而且感兴趣的人群，文章风格一如既往如此，就以为手机上看起来比较方便，这样显得比较有条理，整理这些笔记加源码，时间跨度也算将近半年时间了，但愿对想学习数据结构的人或者正在学习数据结构的人群有帮助。github

颜色翻转和右旋转

  1. 添加元素的状况面试

    1. 添加的第一个元素会变成根节点，而且会被设置为黑色，
    2. 若是再添加一个元素，若是这个元素被添加为这个根节点的左孩子，
    3. 那么就瓜熟蒂落的保持了红黑树的性质，
    4. 由于这个新节点与根节点组成了二三树中的一个三节点，
    5. 可是若是添加的这个元素被添加为这个根节点的右孩子，
    6. 那么就须要进行左旋转的操做，不然就会违背红黑树的性质。

  2. 在红黑树中的三节点中添加元素的第一种状况算法

    1. 下图中节点 37 和节点 42 已经造成了一个三节点，数组

    2. 由于所谓红色节点的意思就是它和它的父亲是融合在一块儿的，数据结构

    3. 若是这个时候再添加一个元素 66，新添加的节点默认为红色，dom

    4. 那么按照二分搜索树中的性质，这个元素会被添加为根节点 44 的右孩子，ide

    5. 此时就会对应二三树中临时的四节点，在红黑树的表示就是，

    6. 根节点是黑色的，左右孩子节点都是红色的，

    7. 所谓红色节点的意思就是它和它的父亲是融合在一块儿的。

      // 中括号为黑色节点，大括号为红色节点
// [42]
// /
// {37}

// 添加元素 66
// [42]
// / \
// {37} {66}
复制代码

  3. 颜色翻转

    1. 在二三树中这个临时的四节点以后会被分裂成三个二节点，

    2. 对应红黑树中的操做是将根节点 42 下面两个节点 37 和 66 都染成黑色，

    3. 这样就表示了在二三树中三个二节点组成了一棵子树，

    4. 临时的四节点分裂以后，新的子树的根节点须要向上进行融合操做，

    5. 因此在红黑树中的操做是，这个根节点 42 要变成红色，

    6. 由于所谓红色节点的意思就是它和它的父亲是融合在一块儿的，

    7. 这个过程就让根节点的颜色与左右子树的颜色进行了一个翻转操做，

    8. 颜色翻转的英文就是 flipColors，这是在红黑树中添加一个新元素的辅助过程，

    9. 实际上也是等价的在二三树中的三节点中添加了一个新元素所对应的一个辅助过程。

      // 中括号为黑色节点，大括号为红色节点
// 添加元素 66
// [42]
// / \
// {37} {66}

// 颜色翻转
// {42}
// / \
// [37] [66]
复制代码

  4. 在红黑树中的三节点中添加元素的另一种状况

    1. 下图中节点 37 和节点 42 已经造成了一个三节点，，
    2. 若是这个时候再添加一个元素 12，新添加的节点默认为红色，
    3. 那么按照二分搜索树中的性质，这个元素会被添加为根节点 44 的左孩子 37 的左孩子，
    4. 这样一来就至关于节点 42 的左孩子是红色节点而后左孩子的左孩子仍是红色节点，
    5. 所谓红色的节点，就是它与它的父节点是融合在了一块儿，
    6. 这样的一种状况也能够将它理解为一个临时的四节点，
    7. 节点 23 是红色的，它和它的父节点 37 融合在了一块儿，而后节点 37 是红色，
    8. 它和它的父节点 42 也是融合在一块儿的，因此这种形状也表示对应二三树中的四节点，
    9. 也是同样的，须要对四节点进行分裂操做，变成一个由三个二节点组成的子树，
    10. 因此在红黑树中须要将这样的向左偏斜的形状进行一个纠正，
    11. 要让它变成一个根节点左右两个孩子的形状，此时就须要引入另一个子过程右旋转。
    // 中括号为黑色节点，大括号为红色节点
// [42]
// /
// {37}

// 添加元素 12
// [42]
// /
// {37}
// /
// {23}
复制代码

  5. 右旋转

    1. 让节点 node 的左子树与节点 x 进行断开链接，让节点 x 与右子树 T1 断开链接，
    2. 让节点 x 的右子树与节点 node 进行链接，让节点 node 的左子树与 T1 进行链接，
    3. 这样就有一个右旋转的过程，这个和左旋转是相似的，
    4. 以后对于红黑树来讲还须要维护一下颜色的信息，
    5. 这个维护的过程和以前讲的左旋转的过程是同样的，
    6. 新的根节点 x 的颜色应该和原来的根节点 node 的颜色是同样的，
    7. 通过这样的处理以后，node 虽然变成了 x 的右孩子了，
    8. 可是须要将它染色成红色，这是为了保证后续的操做可以有效进行，
    9. 右旋转的做用只是让这三个节点对应成二三树中的临时四节点。
    10. 也仍是同样，须要进行颜色翻转操做，从而维护红黑树的性质，
    11. 新的子树的根节点须要向上进行融合，因此它须要变成红色，
    12. 在红黑树中红色节点的左右子树的颜色都是黑色的，
    13. 因此根节点的左右孩子节点颜色都要变成黑色。
    // 中括号为黑色节点，大括号为红色节点
// 小括号只是参与演示，并不真实存在
// 原来是这样的
// [42] node
// / \
// x {37} (T2)
// / \
// {23} (T1)

// 进行右旋转后
// {37} x
// / \
// {23} {42} node
// / \
// (T1) (T2)

// node.left = T1
// x.right = node;
// x.color = node.color;
// node.color = RED;

// 颜色翻转后
// {37} x
// / \
// [23] [42] node
// / \
// (T1) (T2)

// x.color = RED;
// x.left.color = BLACK;
// x.right.color = BLACK;
复制代码

代码示例

  1. MyRedBlackTree

    // 自定义红黑树节点 RedBalckTreeNode
class MyRedBalckTreeNode {
   constructor(key = null, value = null, left = null, right = null) {
      this.key = key;
      this.value = value;
      this.left = left;
      this.right = right;
      this.color = MyRedBlackTree.RED; // MyRedBlackTree.BLACK;
   }

   // @Override toString 2018-11-25-jwl
   toString() {
      return (
         this.key.toString() +
         '--->' +
         this.value.toString() +
         '--->' +
         (this.color ? '红色节点' : '绿色节点')
      );
   }
}

// 自定义红黑树 RedBlackTree
class MyRedBlackTree {
   constructor() {
      MyRedBlackTree.RED = true;
      MyRedBlackTree.BLACK = false;

      this.root = null;
      this.size = 0;
   }

   // 判断节点node的颜色
   isRed(node) {
      // 定义：空节点颜色为黑色
      if (!node) return MyRedBlackTree.BLACK;

      return node.color;
   }

   // node x
   // / \ 左旋转 / \
   // T1 x ---------> node T3
   // / \ / \
   // T2 T3 T1 T2
   leftRotate(node) {
      const x = node.right;

      // 左旋转过程
      node.right = x.left;
      x.left = node;

      // 染色过程
      x.color = node.color;
      node.color = MyRedBlackTree.RED;

      // 返回这个 x
      return x;
   }

   // 颜色翻转 当前节点变红 左右孩子变黑
   // 表示当前节点须要继续向上进行融合
   flipColors(node) {
      node.color = MyRedBlackTree.RED;
      node.left.color = MyRedBlackTree.BLACK;
      node.right.color = MyRedBlackTree.BLACK;
   }

   // node x
   // / \ 右旋转 / \
   // x T2 -------> y node
   // / \ / \
   // y T1 T1 T2
   rightRotate(node) {
      const x = node.left;

      // 右翻转过程
      node.left = x.right;
      x.right = node;

      // 染色过程
      x.color = node.color;
      node.color = MyRedBlackTree.RED;

      // 返回这个 x
      return x;
   }

   // 比较的功能
   compare(keyA, keyB) {
      if (keyA === null || keyB === null)
         throw new Error("key is error. key can't compare.");
      if (keyA > keyB) return 1;
      else if (keyA < keyB) return -1;
      else return 0;
   }

   // 根据key获取节点 -
   getNode(node, key) {
      // 先解决最基本的问题
      if (node === null) return null;

      // 开始将复杂的问题 逐渐缩小规模
      // 从而求出小问题的解，最后构建出原问题的解
      switch (this.compare(node.key, key)) {
         case 1: // 向左找
            return this.getNode(node.left, key);
            break;
         case -1: // 向右找
            return this.getNode(node.right, key);
            break;
         case 0: // 找到了
            return node;
            break;
         default:
            throw new Error(
               'compare result is error. compare result : 0、 一、 -1 .'
            );
            break;
      }
   }

   // 添加操做 +
   add(key, value) {
      this.root = this.recursiveAdd(this.root, key, value);
      this.root.color = MyRedBlackTree.BLACK;
   }

   // 添加操做 递归算法 -
   recursiveAdd(node, key, value) {
      // 解决最简单的问题
      if (node === null) {
         this.size++;
         return new MyRedBalckTreeNode(key, value);
      }

      // 将复杂的问题规模逐渐变小，
      // 从而求出小问题的解，从而构建出原问题的答案
      if (this.compare(node.key, key) > 0)
         node.left = this.recursiveAdd(node.left, key, value);
      else if (this.compare(node.key, key) < 0)
         node.right = this.recursiveAdd(node.right, key, value);
      else node.value = value;

      return node;
   }

   // 删除操做 返回被删除的元素 +
   remove(key) {
      let node = this.getNode(this.root, key);
      if (node === null) return null;

      this.root = this.recursiveRemove(this.root, key);
      return node.value;
   }

   // 删除操做 递归算法 +
   recursiveRemove(node, key) {
      // 解决最基本的问题
      if (node === null) return null;

      if (this.compare(node.key, key) > 0) {
         node.left = this.recursiveRemove(node.left, key);
         return node;
      } else if (this.compare(node.key, key) < 0) {
         node.right = this.recursiveRemove(node.right, key);
         return node;
      } else {
         // 当前节点的key 与 待删除的key的那个节点相同
         // 有三种状况
         // 1. 当前节点没有左子树，那么只有让当前节点的右子树直接覆盖当前节点，就表示当前节点被删除了
         // 2. 当前节点没有右子树，那么只有让当前节点的左子树直接覆盖当前节点，就表示当前节点被删除了
         // 3. 当前节点左右子树都有， 那么又分两种状况，使用前驱删除法或者后继删除法
         // 1. 前驱删除法：使用当前节点的左子树上最大的那个节点覆盖当前节点
         // 2. 后继删除法：使用当前节点的右子树上最小的那个节点覆盖当前节点

         if (node.left === null) {
            let rightNode = node.right;
            node.right = null;
            this.size--;
            return rightNode;
         } else if (node.right === null) {
            let leftNode = node.left;
            node.left = null;
            this.size--;
            return leftNode;
         } else {
            let predecessor = this.maximum(node.left);
            node.left = this.removeMax(node.left);
            this.size++;

            // 开始嫁接 当前节点的左右子树
            predecessor.left = node.left;
            predecessor.right = node.right;

            // 将当前节点从根节点剔除
            node = node.left = node.right = null;
            this.size--;

            // 返回嫁接后的新节点
            return predecessor;
         }
      }
   }

   // 删除操做的两个辅助函数
   // 获取最大值、删除最大值
   // 之前驱的方式 来辅助删除操做的函数

   // 获取最大值
   maximum(node) {
      // 不再能往右了，说明当前节点已是最大的了
      if (node.right === null) return node;

      // 将复杂的问题渐渐减少规模，从而求出小问题的解，最后用小问题的解构建出原问题的答案
      return this.maximum(node.right);
   }

   // 删除最大值
   removeMax(node) {
      // 解决最基本的问题
      if (node.right === null) {
         let leftNode = node.left;
         node.left = null;
         this.size--;
         return leftNode;
      }

      // 开始化归
      node.right = this.removeMax(node.right);
      return node;
   }

   // 查询操做 返回查询到的元素 +
   get(key) {
      let node = this.getNode(this.root, key);
      if (node === null) return null;
      return node.value;
   }

   // 修改操做 +
   set(key, value) {
      let node = this.getNode(this.root, key);
      if (node === null) throw new Error(key + " doesn't exist.");

      node.value = value;
   }

   // 返回是否包含该key的元素的判断值 +
   contains(key) {
      return this.getNode(this.root, key) !== null;
   }

   // 返回映射中实际的元素个数 +
   getSize() {
      return this.size;
   }

   // 返回映射中是否为空的判断值 +
   isEmpty() {
      return this.size === 0;
   }

   // @Override toString() 2018-11-05-jwl
   toString() {
      let mapInfo = `MyBinarySearchTreeMap: size = ${this.size}, data = [ `;
      document.body.innerHTML += `MyBinarySearchTreeMap: size = ${ this.size }, data = [ <br/><br/>`;

      // 以非递归的前序遍历 输出字符串
      let stack = new MyLinkedListStack();

      stack.push(this.root);

      if (this.root === null) stack.pop();

      while (!stack.isEmpty()) {
         let node = stack.pop();

         if (node.left !== null) stack.push(node.left);
         if (node.right !== null) stack.push(node.right);

         if (node.left === null && node.right === null) {
            mapInfo += ` ${node.toString()} \r\n`;
            document.body.innerHTML += ` ${node.toString()} <br/><br/>`;
         } else {
            mapInfo += ` ${node.toString()}, \r\n`;
            document.body.innerHTML += ` ${node.toString()}, <br/><br/>`;
         }
      }

      mapInfo += ` ] \r\n`;
      document.body.innerHTML += ` ] <br/><br/>`;

      return mapInfo;
   }
}
复制代码

向红黑树中添加新节点

  1. 在红黑树中添加新节点等价于在二三树的一个二或三节点上融合一个新的元素

    1. 在二节点上进行融合操做，

    2. 若是新添加的这个节点比最后找到的叶子节点的元素小，

    3. 那么对应在红黑树中的操做就是直接添加为当前节点的左孩子便可；

    4. 若是新添加的这个节点比最后找到的叶子节点的元素大，

    5. 那么对应在红黑树中的操做是 首先直接添加为当前节点的右孩子，

    6. 而后再进行左旋转操做，让新添加的节点做为根节点，

    7. 而原来的根节点做为新添加的节点的左孩子节点便可；

    8. 左旋转操做须要将新的根节点与原来的根节点的颜色对调，

    9. 而后将原来的根节点染色为红色，最后，

    10. 左旋转的过程当中并不会去维护红黑树的性质，

    11. 左旋转的做用只是让这两个节点对应成二三树中的三节点。

    12. 在三节点上进行融合操做，

    13. 若是新添加的这个节点比根节点要大，

    14. 那么对应在红黑树中的操做就是直接添加为根节点的右孩子，

    15. 以后进行一下颜色的翻转操做便可；

    16. 若是新添加的这个节点比根节点要小而且比根节点的左孩子要小，

    17. 那么对应在红黑树中的操做就是先直接添加为根节点的左孩子的左孩子，

    18. 而后进行一下右旋转，

    19. 旋转右旋转操做须要将新的根节点与原来的根节点的颜色对调，

    20. 而后将原来的根节点染色为红色，

    21. 也是同样，旋转操做不会去维护红黑树的性质，

    22. 右旋转的做用只是让这三个节点对应成二三树中的临时四节点，

    23. 以后进行一下颜色的翻转操做便可；

    24. 若是新添加的这个节点比根节点要小而且比根节点的左孩子要大，

    25. 那么对应在红黑树中的操做就是先直接添加为根节点的左孩子的右孩子，

    26. 而后对这个根节点的左孩子进行一个左旋转操做，

    27. 左旋转操做以后就以下图所示，

    28. 就变成了新添加的这个节点比根节点要小而且比根节点的左孩子要小的状况，

    29. 那么就对这个根节点进行一个右旋转操做，

    30. 再来一个颜色翻转操做便可。

      // 中括号为黑色节点，大括号为红色节点
// 原来是这样的
// [42]
// /
// {37}
// \
// {40}

// 对根节点的左孩子 进行左旋转后 染色后
// [42]
// /
// {40}
// /
// {37}

// 对根节点 进行右旋转后 染色后
// [40]
// / \
// {37} {42}
//

// 对根节点 颜色翻转后
// {40}
// / \
// [37] [42]
复制代码

  2. 红黑树添加节点逻辑分布图

    1. 下图中的逻辑只要分为三种

    2. 是否须要左旋转、右旋转、颜色翻转，

    3. 当当前节点的右孩子为红色而且当前节点的左孩子不为红色时，那么就须要进行左旋转；

    4. 当当前节点的左孩子为红色而且当前节点的左孩子的左孩子也为红色时，那么就须要进行右旋转；

    5. 当当前节点的左右孩子全都是红色时，那么就须要进行颜色翻转；

    6. 这三种逻辑并不是是互斥的，而是相吸，每一次都须要进行这三种判断，

    7. 下图也是按照这样的顺序来进行步骤的执行的。

      // 中括号为黑色节点，大括号为红色节点

// 融合二节点
// 步骤一 步骤二 步骤三
// [null] [node] [node] [X]
// ----> ----> \ ----> /
// {X} {node}
// 首次添加节点 ----> 添加节点X ----> 左旋转
//
// 状况一 若是红黑树的根节点为空
// 那么 步骤一
// 状况二 若是红黑树的根节点不为空 新添加的节点小于根节点
// 那么 步骤一 --> 步骤三
// 状况三 若是红黑树的根节点不为空 新添加的节点大于根节点
// 那么 步骤一 --> 步骤二 --> 步骤三

// 融合三节点
//
// 步骤1 步骤2 步骤3 步骤4 步骤5
// [node] [node] [node] [Y] {Y}
// / ----> / ----> / ----> / \ ----> / \
//{X} {X} {Y} {X} {node} [X] [node]
// \ /
// {Y} {X}
// 添加节点Y ----> 左旋转 ----> 右旋转 ----> 颜色翻转
//
// 状况一 若是新添加的这个新节点 大于 根节点
// 那么步骤1 --> 步骤4 --> 步骤5
// 状况二 若是新添加的这个节点比根节点要小而且比根节点的左孩子要小
// 那么步骤1 --> 步骤3 --> 步骤4 --> 步骤5
// 状况三 若是新添加的这个节点比根节点要小而且比根节点的左孩子要大
// 那么步骤1 --> 步骤2 --> 步骤3 --> 步骤4 --> 步骤5
复制代码

  3. 红黑树添加节点时维护性质的时机

    1. 红黑树维护的时机和 AVL 树同样，
    2. 先使用二分搜索树的基本逻辑将新的节点添加进红黑树中，
    3. 以后再来进行回溯向上维护的操做，
    4. 也就是将当前的节点维护以后，再将维护后的新的节点返回给递归调用的上一层，
    5. 而后再到上一层中进行维护，再将维护后的新的节点返回给递归调用的上一层，
    6. 整个过程依此类推。

代码示例

  1. MyRedBlackTree

    // 自定义红黑树节点 RedBalckTreeNode
class MyRedBalckTreeNode {
   constructor(key = null, value = null, left = null, right = null) {
      this.key = key;
      this.value = value;
      this.left = left;
      this.right = right;
      this.color = MyRedBlackTree.RED; // MyRedBlackTree.BLACK;
   }

   // @Override toString 2018-11-25-jwl
   toString() {
      return (
         this.key.toString() +
         '--->' +
         this.value.toString() +
         '--->' +
         (this.color ? '红色节点' : '绿色节点')
      );
   }
}

// 自定义红黑树 RedBlackTree
class MyRedBlackTree {
   constructor() {
      MyRedBlackTree.RED = true;
      MyRedBlackTree.BLACK = false;

      this.root = null;
      this.size = 0;
   }

   // 判断节点node的颜色
   isRed(node) {
      // 定义：空节点颜色为黑色
      if (!node) return MyRedBlackTree.BLACK;

      return node.color;
   }

   // node x
   // / \ 左旋转 / \
   // T1 x ---------> node T3
   // / \ / \
   // T2 T3 T1 T2
   leftRotate(node) {
      const x = node.right;

      // 左旋转过程
      node.right = x.left;
      x.left = node;

      // 染色过程
      x.color = node.color;
      node.color = MyRedBlackTree.RED;

      // 返回这个 x
      return x;
   }

   // 颜色翻转 当前节点变红 左右孩子变黑
   // 表示当前节点须要继续向上进行融合
   flipColors(node) {
      node.color = MyRedBlackTree.RED;
      node.left.color = MyRedBlackTree.BLACK;
      node.right.color = MyRedBlackTree.BLACK;
   }

   // node x
   // / \ 右旋转 / \
   // x T2 -------> y node
   // / \ / \
   // y T1 T1 T2
   rightRotate(node) {
      const x = node.left;

      // 右翻转过程
      node.left = x.right;
      x.right = node;

      // 染色过程
      x.color = node.color;
      node.color = MyRedBlackTree.RED;

      // 返回这个 x
      return x;
   }

   // 比较的功能
   compare(keyA, keyB) {
      if (keyA === null || keyB === null)
         throw new Error("key is error. key can't compare.");
      if (keyA > keyB) return 1;
      else if (keyA < keyB) return -1;
      else return 0;
   }

   // 根据key获取节点 -
   getNode(node, key) {
      // 先解决最基本的问题
      if (!node) return null;

      // 开始将复杂的问题 逐渐缩小规模
      // 从而求出小问题的解，最后构建出原问题的解
      switch (this.compare(node.key, key)) {
         case 1: // 向左找
            return this.getNode(node.left, key);
            break;
         case -1: // 向右找
            return this.getNode(node.right, key);
            break;
         case 0: // 找到了
            return node;
            break;
         default:
            throw new Error(
               'compare result is error. compare result : 0、 一、 -1 .'
            );
            break;
      }
   }

   // 添加操做 +
   add(key, value) {
      this.root = this.recursiveAdd(this.root, key, value);
      this.root.color = MyRedBlackTree.BLACK;
   }

   // 添加操做 递归算法 -
   recursiveAdd(node, key, value) {
      // 解决最简单的问题
      if (!node) {
         this.size++;
         return new MyRedBalckTreeNode(key, value);
      }

      // 将复杂的问题规模逐渐变小，
      // 从而求出小问题的解，从而构建出原问题的答案
      if (this.compare(node.key, key) > 0)
         node.left = this.recursiveAdd(node.left, key, value);
      else if (this.compare(node.key, key) < 0)
         node.right = this.recursiveAdd(node.right, key, value);
      else {
         node.value = value;
         return node;
      }

      // 红黑树性质的维护
      // 是否须要左旋转
      // 若是当前节点的右孩子是红色 而且 左孩子不是红色
      if (this.isRed(node.right) && !this.isRed(node.left))
         node = this.leftRotate(node);

      // 是否须要右旋转
      // 若是当前节点的左孩子是红色 而且 左孩子的左孩子也是红色
      if (this.isRed(node.left) && this.isRed(node.left.left))
         node = this.rightRotate(node);

      // 是否须要颜色的翻转
      // 当前节点的左孩子和右孩子全都是红色
      if (this.isRed(node.left) && this.isRed(node.right))
         this.flipColors(node);

      // 最后返回这个node
      return node;
   }

   // 删除操做 返回被删除的元素 +
   remove(key) {
      let node = this.getNode(this.root, key);
      if (!node) return null;

      this.root = this.recursiveRemove(this.root, key);
      return node.value;
   }

   // 删除操做 递归算法 +
   recursiveRemove(node, key) {
      // 解决最基本的问题
      if (!node) return null;

      if (this.compare(node.key, key) > 0) {
         node.left = this.recursiveRemove(node.left, key);
         return node;
      } else if (this.compare(node.key, key) < 0) {
         node.right = this.recursiveRemove(node.right, key);
         return node;
      } else {
         // 当前节点的key 与 待删除的key的那个节点相同
         // 有三种状况
         // 1. 当前节点没有左子树，那么只有让当前节点的右子树直接覆盖当前节点，就表示当前节点被删除了
         // 2. 当前节点没有右子树，那么只有让当前节点的左子树直接覆盖当前节点，就表示当前节点被删除了
         // 3. 当前节点左右子树都有， 那么又分两种状况，使用前驱删除法或者后继删除法
         // 1. 前驱删除法：使用当前节点的左子树上最大的那个节点覆盖当前节点
         // 2. 后继删除法：使用当前节点的右子树上最小的那个节点覆盖当前节点

         if (node.left === null) {
            let rightNode = node.right;
            node.right = null;
            this.size--;
            return rightNode;
         } else if (node.right === null) {
            let leftNode = node.left;
            node.left = null;
            this.size--;
            return leftNode;
         } else {
            let predecessor = this.maximum(node.left);
            node.left = this.removeMax(node.left);
            this.size++;

            // 开始嫁接 当前节点的左右子树
            predecessor.left = node.left;
            predecessor.right = node.right;

            // 将当前节点从根节点剔除
            node = node.left = node.right = null;
            this.size--;

            // 返回嫁接后的新节点
            return predecessor;
         }
      }
   }

   // 删除操做的两个辅助函数
   // 获取最大值、删除最大值
   // 之前驱的方式 来辅助删除操做的函数

   // 获取最大值
   maximum(node) {
      // 不再能往右了，说明当前节点已是最大的了
      if (!node.right) return node;

      // 将复杂的问题渐渐减少规模，从而求出小问题的解，最后用小问题的解构建出原问题的答案
      return this.maximum(node.right);
   }

   // 删除最大值
   removeMax(node) {
      // 解决最基本的问题
      if (!node.right) {
         let leftNode = node.left;
         node.left = null;
         this.size--;
         return leftNode;
      }

      // 开始化归
      node.right = this.removeMax(node.right);
      return node;
   }

   // 查询操做 返回查询到的元素 +
   get(key) {
      let node = this.getNode(this.root, key);
      if (!node) return null;
      return node.value;
   }

   // 修改操做 +
   set(key, value) {
      let node = this.getNode(this.root, key);
      if (!node) throw new Error(key + " doesn't exist.");

      node.value = value;
   }

   // 返回是否包含该key的元素的判断值 +
   contains(key) {
      return this.getNode(this.root, key) !== null;
   }

   // 返回映射中实际的元素个数 +
   getSize() {
      return this.size;
   }

   // 返回映射中是否为空的判断值 +
   isEmpty() {
      return this.size === 0;
   }

   // @Override toString() 2018-11-05-jwl
   toString() {
      let mapInfo = `MyBinarySearchTreeMap: size = ${this.size}, data = [ `;
      document.body.innerHTML += `MyBinarySearchTreeMap: size = ${ this.size }, data = [ <br/><br/>`;

      // 以非递归的前序遍历 输出字符串
      let stack = new MyLinkedListStack();

      stack.push(this.root);

      if (this.root === null) stack.pop();

      while (!stack.isEmpty()) {
         let node = stack.pop();

         if (node.left !== null) stack.push(node.left);
         if (node.right !== null) stack.push(node.right);

         if (node.left === null && node.right === null) {
            mapInfo += ` ${node.toString()} \r\n`;
            document.body.innerHTML += ` ${node.toString()} <br/><br/>`;
         } else {
            mapInfo += ` ${node.toString()}, \r\n`;
            document.body.innerHTML += ` ${node.toString()}, <br/><br/>`;
         }
      }

      mapInfo += ` ] \r\n`;
      document.body.innerHTML += ` ] <br/><br/>`;

      return mapInfo;
   }
}
复制代码

红黑树的性能测试

  1. 测试用例的结果
    1. 结论是，
    2. 并不是在任何状况下越复杂的算法或者看起来复杂度更低的算法就是更好的，
    3. 不少状况下对于比较简单的数据，或者对于比较少的数据，
    4. 可能简单的算法反而是更快一点，归并排序算法虽然是O(nlogn)级别的，
    5. 可是在数据规模比较小的状况下，颇有可能插入排序法才是最优秀的选择，
    6. 红黑树自己并非一个严格的平衡树，红黑树从根到叶子节点的高度最多会到 2logn，
    7. 因此是比 avl 树要高一些的，因此在查询这个操做中，红黑树并不占优点，
    8. 红黑树真正占优点的操做在于添加或者删除这两个操做上，
    9. 若是结合添加、删除、查询这三个操做，那么总体上红黑树的性能要比 AVL 树高一点，
    10. 若是比较偏重查询的过程，红黑树的优点体现不出来，
    11. 红黑树的实现其实还能够更加的优化一下。

性能测试总结

  1. 对于彻底随机的数据，普通的二分搜索树不会退化成一个链表
    1. 因此仍是很好用的，它的高度相对保持的比较好，
    2. 它的内部也不会有一些比较复杂的维持平衡的代码，
    3. 因而在必定程度上下降了它的开销。
    4. 缺点是在极端状况下会退化成链表，或者高度严重不平衡。
  2. 对于查询和修改操做比较多的使用状况，AVL 树比较好用。
  3. 对于添加删除操做比较多的使用状况，红黑树比较好用。
    1. 红黑树牺牲了平衡性（2logn 的高度），
    2. 因此红黑树并不彻底知足平衡二叉树的定义 ，
    3. 这个高度确定是比 AVL 树要高的，
    4. 红黑树的统计性能更优（综合增删改查全部的操做），
    5. 也正是如此，不少语言内部的容器类所实现有序的映射和集合，
    6. 好比 系统内置 的 Map、Set 的底层都是红黑树的，
    7. 红黑树自己仍是一个二分搜索树，因此它也是有序的。
  4. 对于时间复杂度分析来讲
    1. AVL 树与红黑树总体是在一个级别的，
    2. 可是平均的性能是红黑树比 AVL 树要高一点，
    3. 红黑树的添加和删除操做相对 AVL 树来讲更有优点一些。
  5. 二分搜索树是有序性的
    1. 能够很方便的找到最大值、最小值、一个元素的前驱和后继等等，
    2. 因此基于二分搜索树实现的其它树如 AVL、红黑树都是有序的。

代码示例

  1. Main

    // main 函数
class Main {
   constructor() {
      this.alterLine('RedBlackTree Comparison Area');
      const n = 2000000;

      const myBSTMap = new MyBinarySearchTreeMap();
      const myAVLTree = new MyAVLTree();
      const myRedBlackTree = new MyRedBlackTree();
      let performanceTest1 = new PerformanceTest();

      const random = Math.random;
      let arrNumber = new Array(n);

      // 循环添加随机数的值
      for (let i = 0; i < n; i++) arrNumber[i] = Math.floor(n * random());

      this.alterLine('MyBSTMap Comparison Area');
      const myBSTMapInfo = performanceTest1.testCustomFn(function() {
         // 添加
         for (const word of arrNumber)
            myBSTMap.add(word, String.fromCharCode(word));
      });

      // 总毫秒数：4771
      console.log(myBSTMapInfo + ' 节点个数：' + myBSTMap.getSize());
      this.show(myBSTMapInfo + ' 节点个数：' + myBSTMap.getSize());

      this.alterLine('MyAVLTree Comparison Area');
      // const that = this;
      const myAVLTreeInfo = performanceTest1.testCustomFn(function() {
         for (const word of arrNumber)
            myAVLTree.add(word, String.fromCharCode(word));
      });

      // 总毫秒数：6226
      console.log(myAVLTreeInfo + ' 节点个数：' + myAVLTree.getSize());
      this.show(myAVLTreeInfo + ' 节点个数：' + myAVLTree.getSize());

      this.alterLine('MyRedBlackTree Comparison Area');

      const myRedBlackTreeInfo = performanceTest1.testCustomFn(function() {
         for (const word of arrNumber)
            myRedBlackTree.add(word, String.fromCharCode(word));
      });

      // 总毫秒数：6396
      console.log(
         myRedBlackTreeInfo + ' 节点个数：' + myRedBlackTree.getSize()
      );
      this.show(
         myRedBlackTreeInfo + ' 节点个数：' + myRedBlackTree.getSize()
      );
   }

   // 将内容显示在页面上
   show(content) {
      document.body.innerHTML += `${content}<br /><br />`;
   }

   // 展现分割线
   alterLine(title) {
      let line = `--------------------${title}----------------------`;
      console.log(line);
      document.body.innerHTML += `${line}<br /><br />`;
   }
}

// 页面加载完毕
window.onload = function() {
   // 执行主函数
   new Main();
};
复制代码

更多和红黑树相关的话题

  1. 红黑树中删除节点
    1. 红黑树中的删除节点操做比添加节点操做还要复杂的多，
    2. 在面试中让你实现一个删除节点的操做几乎是不可能的，
    3. 就连添加节点的操做都不多让你实现，
    4. 只要是看你知不知道红黑树的本质是怎样的，
    5. 红黑树的本质就是，
    6. 红黑树与二三树之间是等价的，红黑树知足的那五条基本性质，
    7. 红黑树本质上是保持黑平衡的这样的一种数据结构，
    8. 它从某种程度上来说牺牲了平衡性，
    9. 可是它的统计性能更优，添加及删除性能比 AVL 树好，
    10. 红黑树的添加操做是分各类状况来进行处理的，
    11. 红黑树的删除操做也是分各类状况来进行处理的，
    12. 删除节点的各类状况处理方式更加复杂，
    13. 就连红黑树发明人写的算法 4 里面都没有对红黑树的删除操做的逻辑进行一个详细的介绍，
    14. 删除操做的逻辑分杂琐碎，因此逻辑很是的复杂。
  2. 左倾红黑树和右倾红黑树
    1. 本身实现的红黑树属于左倾红黑树，
    2. 也是相对比较标准的一种红黑树，
    3. 也能够实现右倾红黑树，也就是红色节点做为右孩子节点，
    4. 实现出右倾红黑树就可以让你对红黑树内部的逻辑及运行机制有一个至关深入的理解。
  3. 统计性能更优的树
    1. 红黑树是一种统计性能更优的树，
    2. 还有另一种统计性能更优的树结构叫作伸展树(SplayTree)，
    3. 它的本质也是一种二叉树，它也能够维持自平衡，
    4. 这种树没有像 AVL 树那样严格的定义，它更重要的一点是运用了局部性的原理，
    5. 它假设一般在数据结构中存储的数据，
    6. 若是刚刚被访问的内容下次会有更高的几率去访问它，
    7. 基于这样的一个假设，
    8. 对这个树建立的过程以及查询、修改操做都会对这个树的结构进行必定的变化，
    9. 伸展树的实现要比红黑树的实现要简单。
  4. 基于红黑树的 Map 和 Set
    1. 系统内置的的 Map 和 Set 就是基于红黑树的。
  5. 红黑树的其它实现
    1. 本身实现的红黑树并非红黑树惟一的实现方式，
    2. 虽然总体逻辑上原理是同样的，可是在具体实现上能够有更优化的一些实现方式，
    3. 算法导论中也有对红黑树的实现的描述，
    4. 面试中不会去考察红黑树实现的逻辑中某一个具体细节。
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程