红黑树插入与删除完整代码（dart语言实现）

　　之前分析了红黑树的删除，这里附上红黑树的完整版代码，包括查找、插入、删除等。删除后修复实现了两种算法，均比之前的更为简洁。一种是我自己的实现，代码非常简洁，行数更少；一种是Linux、Java等源码版本的实现，实现的略为复杂，但效率更高。两种算法经过测试，在百万级的数据上效率不分伯仲；1000万的数据中，我自己的实现比Linux内核版本的运行时间多2秒左右。

　　红黑树的插入相对简单，本文中的代码实现与Linux源码版本也略有差异，效率差别不大。

　　其他方法，如查找、遍历等，比较简单，不多做解释。遍历支持前序、中序、后序遍历。

　　在研究红黑树的过程中，为了彻底弄懂插入与删除，画了无数的图，以删除修复为例，根据父亲节点、兄弟节点、兄弟节点的左右子节点的空、红、黑的情况，穷举了36中情况，再进行归纳合并。而弄明白以后，发现是如此的简单；实现了多种写法，最后总结为两种最简洁的实现，并进行性能测试。还写了检查一棵树是否是红黑树的代码，将在下篇博客中发布。

　　至此，二叉树和红黑树研究完毕。代码如下：

 import 'tree_node.dart';
 import 'tree_exception.dart';
 import 'traverse_order.dart';

 class RBTree<E extends Comparable<E>> {
   RBTNode<E> _root;
   int _nodeNumbers;

   RBTree() : _nodeNumbers = 0;

   factory RBTree.from(Iterable<Comparable<E>> elements) {
     var tree = RBTree<E>();
     for (var e in elements) tree.insert(e);
     return tree;
   }

   bool get isEmpty => _root == null;
   int get nodeNumbers => _nodeNumbers;
   RBTNode<E> get root => _root;

   void clear() {
     _root = null;
     _nodeNumbers = 0;
   }

   bool contains(E value) => find(value) != null;

   bool delete(E value) => _delete(value, _fixAfterDelete);

   // the implement in Linux core.
   bool quickDelete(E value) => _delete(value, _fixAfterDelete2);

   RBTNode<E> find(E value) {
     var current = _root;
     while (current != null) {
       var c = value.compareTo(current.value);
       if (c == 0) break;
       current = c < 0 ? current.left : current.right;
     }
     return current;
   }

   void insert(E value) {
     var inserted = RBTNode<E>(value);
     _insert(inserted);
     _fixAfterInsert(inserted);
   }

   E get max {
     if (isEmpty) throw TreeEmptyException();
     var maxNode = _root;
     while (maxNode.right != null) maxNode = maxNode.right;
     return maxNode.value;
   }

   E get min {
     if (isEmpty) throw TreeEmptyException();
     return _minNode(_root).value;
   }

   void traverse(void f(E e), [TraverseOrder order = TraverseOrder.inOrder]) =>
       _traverse(_root, order, f);

   void _insert(RBTNode<E> inserted) {
     RBTNode<E> p, c = _root;
     while (c != null) {
       p = c;
       c = inserted.value.compareTo(c.value) <= 0 ? c.left : c.right;
     }

     if (p == null) {
       _root = inserted;
     } else if (inserted.value.compareTo(p.value) <= 0) {
       p.left = inserted;
     } else {
       p.right = inserted;
     }
     inserted.parent = p;
     _nodeNumbers++;
   }

   void _fixAfterInsert(RBTNode<E> node) {
     while (_hasRedFather(node) && _hasRedUncle(node)) {
       var g = _gparent(node);
       g.left.paintBlack();
       g.right.paintBlack();
       g.paintRed();
       node = g;
     }

     if (_hasRedFather(node)) {
       var g = _gparent(node);
       if (node.parent == g.left) {
         if (node == node.parent.right) {
           _rotateLeft(node.parent);
           node = node.left;
         }
         _rotateRight(g);
       } else {
         if (node == node.parent.left) {
           _rotateRight(node.parent);
           node = node.right;
         }
         _rotateLeft(g);
       }
       node.parent.paintBlack();
       g.paintRed();
     }
     _root.paintBlack();
   }

   bool _hasRedFather(RBTNode<E> node) =>
       node.parent != null && node.parent.isRed;

   bool _hasRedUncle(RBTNode<E> node) {
     var gparent = _gparent(node);
     var uncle = node.parent == gparent.left ? gparent.right : gparent.left;
     return uncle != null && uncle.isRed;
   }

   RBTNode _gparent(RBTNode<E> node) => node.parent.parent;

   bool _delete(E value, void _fix(RBTNode<E> p, bool isLeft)) {
     var d = find(value);
     if (d == null) return false;

     if (d.left != null && d.right != null) {
       var s = _successor(d);
       d.value = s.value;
       d = s;
     }
     var rp = d.left ?? d.right;
     rp?.parent = d.parent;
     if (d.parent == null)
       _root = rp;
     else if (d == d.parent.left)
       d.parent.left = rp;
     else
       d.parent.right = rp;

     if (rp != null)
       rp.paintBlack();
     else if (d.isBlack && d.parent != null)
       _fix(d.parent, d.parent.left == null);

     _nodeNumbers--;
     return true;
   }

   RBTNode<E> _successor(RBTNode<E> d) =>
       d.right != null ? _minNode(d.right) : d.left;

   void _fixAfterDelete(RBTNode<E> p, bool isLeft) {
     var c = isLeft ? p.right : p.left;
     if (isLeft) {
       if (c.isRed) {
         p.paintRed();
         c.paintBlack();
         _rotateLeft(p);
         c = p.right;
       }
       if (c.left != null && c.left.isRed) {
         c.left.paint(p.color);
         if (p.isRed) p.paintBlack();
         _rotateRight(c);
         _rotateLeft(p);
       } else {
         _rotateLeft(p);
         if (p.isBlack) {
           p.paintRed();
           if (c.parent != null) _fixAfterDelete(c.parent, c == c.parent.left);
         }
       }
     } else {
       if (c.isRed) {
         p.paintRed();
         c.paintBlack();
         _rotateRight(p);
         c = p.left;
       }
       if (c.right != null && c.right.isRed) {
         c.right.paint(p.color);
         if (p.isRed) p.paintBlack();
         _rotateLeft(c);
         _rotateRight(p);
       } else {
         _rotateRight(p);
         if (p.isBlack) {
           p.paintRed();
           if (c.parent != null) _fixAfterDelete(c.parent, c == c.parent.left);
         }
       }
     }
   }

   // the implement in Linux core.
   void _fixAfterDelete2(RBTNode<E> p, bool isLeft) {
     var c = isLeft ? p.right : p.left;
     if (isLeft) {
       if (c.isRed) {
         p.paintRed();
         c.paintBlack();
         _rotateLeft(p);
         c = p.right;
       }
       if ((c.left != null && c.left.isRed) ||
           (c.right != null && c.right.isRed)) {
         if (c.right == null || c.right.isBlack) {
           _rotateRight(c);
           c = p.right;
         }
         c.paint(p.color);
         p.paintBlack();
         c.right.paintBlack();
         _rotateLeft(p);
       } else {
         c.paintRed();
         if (p.isRed)
           p.paintBlack();
         else if (p.parent != null)
           _fixAfterDelete2(p.parent, p == p.parent.left);
       }
     } else {
       if (c.isRed) {
         p.paintRed();
         c.paintBlack();
         _rotateRight(p);
         c = p.left;
       }
       if ((c.left != null && c.left.isRed) ||
           (c.right != null && c.right.isRed)) {
         if (c.left == null || c.left.isBlack) {
           _rotateLeft(c);
           c = p.left;
         }
         c.paint(p.color);
         p.paintBlack();
         c.left.paintBlack();
         _rotateRight(p);
       } else {
         c.paintRed();
         if (p.isRed)
           p.paintBlack();
         else if (p.parent != null)
           _fixAfterDelete2(p.parent, p == p.parent.left);
       }
     }
   }

   void _rotateLeft(RBTNode<E> node) {
     var r = node.right, p = node.parent;
     r.parent = p;
     if (p == null)
       _root = r;
     else if (p.left == node)
       p.left = r;
     else
       p.right = r;

     node.right = r.left;
     r.left?.parent = node;
     r.left = node;
     node.parent = r;
   }

   void _rotateRight(RBTNode<E> node) {
     var l = node.left, p = node.parent;
     l.parent = p;
     if (p == null)
       _root = l;
     else if (p.left == node)
       p.left = l;
     else
       p.right = l;

     node.left = l.right;
     l.right?.parent = node;
     l.right = node;
     node.parent = l;
   }

   RBTNode<E> _minNode(RBTNode<E> r) => r.left == null ? r : _minNode(r.left);

   void _traverse(RBTNode<E> s, TraverseOrder order, void f(E e)) {
     if (s == null) return;
     switch (order) {
       case TraverseOrder.inOrder:
         _traverse(s.left, order, f);
         f(s.value);
         _traverse(s.right, order, f);
         break;
       case TraverseOrder.preOrder:
         f(s.value);
         _traverse(s.left, order, f);
         _traverse(s.right, order, f);
         break;
       case TraverseOrder.postOrder:
         _traverse(s.left, order, f);
         _traverse(s.right, order, f);
         f(s.value);
         break;
       default:
         break;
     }
   }
 }