AVL树、红黑树

在计算机科学中，AVL树是最早发明的自平衡二叉查找树。AVL树得名于它的发明者 G.M. Adelson-Velsky 和 E.M. Landis，他们在 1962 年的论文 "An algorithm for the organization of information" 中发表了它。html

1、AVL树的旋转规律

AVL树的基本操做通常涉及运作同在不平衡的二叉查找树所运作的一样的算法。可是要进行预先或随后作一次或屡次所谓的"AVL旋转"。java

假设因为在二叉排序树上插入结点而失去平衡的最小子树根结点的指针为a（即a是离插入点最近，且平衡因子绝对值超过1的祖先结点），则失去平衡后进行进行的规律可概括为下列四种状况：node

1. LL型

平衡二叉树某一节点的左孩子的左子树上插入一个新的节点，使得该节点再也不平衡。这时只须要把树向右旋转一次便可，如图所示，原A的左孩子B变为父结点，A变为其右孩子，而原B的右子树变为A的左子树，注意旋转以后Brh是A的左子树（图上忘在A于Brh之间标实线）linux

2. RR型

平衡二叉树某一节点的右孩子的右子树上插入一个新的节点，使得该节点再也不平衡。这时只须要把树向左旋转一次便可，如图所示，原A右孩子B变为父结点，A变为其左孩子，而原B的左子树Blh将变为A的右子树。c++

3. LR型

平衡二叉树某一节点的左孩子的右子树上插入一个新的节点，使得该节点再也不平衡。这时须要旋转两次，仅一次的旋转是不可以使二叉树再次平衡。如图所示，在B节点按照RR型向左旋转一次以后，二叉树在A节点仍然不能保持平衡，这时还须要再向右旋转一次。算法

4. RL型

平衡二叉树某一节点的右孩子的左子树上插入一个新的节点，使得该节点再也不平衡。一样，这时须要旋转两次，旋转方向恰好同LR型相反。编程

2、AVL树的基本操做

1.插入

向AVL树插入能够经过如同它是未平衡的二叉查找树同样把给定的值插入树中，接着自底向上向根节点折回，于在插入期间成为不平衡的全部节点上进行旋转来完成。由于折回到根节点的路途上最多有 1.5 乘 log n 个节点，而每次AVL 旋转都耗费恒定的时间，插入处理在总体上耗费 O(log n) 时间。　安全

在平衡的的二叉排序树Balanced BST上插入一个新的数据元素e的递归算法可描述以下：网络

若BBST为空树，则插入一个数据元素为e的新结点做为BBST的根结点，树的深度增1；

若e的关键字小于BBST的根结点的关键字，并且在BBST的左子树中不存在和e有相同关键字的结点，则将e插入在BBST的左子树上，而且当插入以后的左子树深度增长（+1）时，分别就下列不一样状况处理之：BBST的根结点的平衡因子为-1（右子树的深度大于左子树的深度，则将根结点的平衡因子更改成 0，BBST的深度不变； BBST的根结点的平衡因子为0（左、右子树的深度相等）：则将根结点的平衡因子更改成1，BBST的深度增1；BBST的根结点的平衡因子为1（左子树的深度大于右子树的深度）：则若BBST的左子树根结点的平衡因子为1：则需进行单向右旋平衡处理，而且在右旋处理以后，将根结点和其右子树根结点的平衡因子更改成0，树的深度不变；若e的关键字大于BBST的根结点的关键字，并且在BBST的右子树中不存在和e有相同关键字的结点，则将e插入在BBST的右子树上，而且当插入以后的右子树深度增长（+1）时，分别就不一样状况处理之。

2.删除

从AVL树中删除能够经过把要删除的节点向下旋转成一个叶子节点，接着直接剪除这个叶子节点来完成。由于在旋转成叶子节点期间最多有 log n个节点被旋转，而每次 AVL 旋转耗费恒定的时间，删除处理在总体上耗费 O(log n) 时间。

3.查找

在AVL树中查找同在通常BST彻底同样的进行，因此耗费 O(log n) 时间，由于AVL树老是保持平衡的。不须要特殊的准备，树的结构不会因为查询而改变。（这是与伸展树查找相对立的，它会由于查找而变动树结构。）

3、代码实现

时间仓促，对于插入、删除操做没有就各类状况配上插图，代码里面有一些注释，能够对着代码理解。往后再研究这个的时候定配上插图。

红黑树并无咱们想象的那么难上、下两篇已经完成, 但愿能帮助到你们.

红黑树并无想象的那么难, 初学者以为晦涩难读多是由于状况太多. 红黑树的状况能够经过归结, 经过合并来获得更少的状况, 如此能够加深对红黑树的理解. 网络上的大部分成黑树的讲解由于没有「合并」. 红黑树的五个性质:

红黑树的数据结构

二叉搜索树的插入删除操做

在展开红黑树以前, 首先来看看普通二叉搜索树的插入和删除. 插入很容易理解, 比当前值大就往右走, 比当前值小就往左走. 详细展开的是删除操做.

二叉树的删除操做有一个技巧, 即在查找到须要删除的节点 X; 接着咱们找到要么在它的左子树中的最大元素节点 M、要么在它的右子树中的最小元素节点 M, 并交换(M,X). 此时, M 节点必然至多只有一个孩子; 最后一个步骤就是用 M 的子节点代替 M 节点就完成了. 因此, 全部的删除操做最后都会归结为删除一个至多只有一个孩子的节点, 而咱们删除这个节点后, 用它的孩子替换就行了. 将会看到 sgi stl map 就是这样的策略.

在红黑树删除操做讲解中, 咱们假设代替 M 的节点是 N(下面的讲述再也不出现 M).

红黑树的插入

插入新节点老是红色节点, 由于不会破坏性质 5, 尽量维持全部性质.

假设, 新插入的节点为 N, N 节点的父节点为 P, P 的兄弟(N 的叔父)节点为 U, P 的父亲(N 的爷爷)节点为 G. 因此有以下的印象图:

第 0.0 种状况, N 为根节点, 直接 N->黑. over 第 0.1 种状况, N 的父节点为黑色, 这不违反红黑树的五种性质. over

第 1 种状况, N,P,U 都红(G 确定黑). 策略: G->红, N,P->黑. 此时, G 红, 若是 G 的父亲也是红, 性质又被破坏了, HACK: 能够将 GPUN 当作一个新的红色 N 节点, 如此递归调整下去; 特俗的, 若是碰巧将根节点染成了红色, 能够在算法的最后强制 root->黑.

第 2 种状况, P 为红, N 为 P 右孩子, N 为红, U 为黑或缺乏. 策略: 旋转变换, 从而进入下一种状况:

第 3 种状况, 可能由第二种变化而来, 但不是必定: P 为红, N 为 P 左孩子, N 为红. 策略: 旋转, 交换 P,G 颜色, 调整后, 由于 P 为黑色, 因此不怕 P 的父节点是红色的状况. over

红黑树的插入就为上面的三种状况. 你能够作镜像变换从而获得其余的状况.

红黑树的删除

假设 N 节点见上面普通二叉树删除中的定义, P 为 N 父节点, S 为 N 的兄弟节点, SL,SR 分别是 S 的左右子节点. 有以下印象图:

第 0.0 状况, N 为根节点. over 第 0.1 状况, 删除的节点为红. over 第 0.2 状况, 删除节点为黑, N 为红. 策略: N->黑, 从新平衡. over

第 1 状况, N,P,S,SR,SL 都黑. 策略: S->红. 经过 PN,PS 的黑色节点数量相同了, 但会比其余路径多一个, 解决的方法是在 P 上从状况 0 开始继续调整. 为何要这样呢? HANKS: 由于既然 PN,PS 路径上的黑节点数量相同并且比其余路径会少一个黑节点, 那何不将其总体当作了一个 N 节点! 这是递归原理.

第 2 状况, S 红, 根据红黑树性质 P,SL,SR 必定黑. 策略: 旋转, 交换 P,S 颜色. 处理后关注的范围缩小, 下面的状况对应下面的框图, 算法从框图从新开始, 进入下一个状况:

第 2.1 状况, S,SL,SR 都黑. 策略: P->黑. S->红, 由于经过 N 的路径多了一个黑节点, 经过 S 的黑节点个数不变, 因此维持了性质 5. over. 将看到, sgi stl map 源代码中将第 2.1 和第 1 状况合并成一种状况, 下节展开.

第 2.2.1 状况, S,SR 黑, SL 红. 策略: 旋转, 变换 SL,S 颜色. 从而又进入下一种状况:

第 2.2.2 状况, S 黑, SR 红. 策略: 旋转, 交换 S,P 颜色, SR->黑色, 从新得到平衡.

上面状况标号 X.X.X 并非说这些关系是嵌套的, 只是这样展开容易理解. 此时, 解释三个地方:

总结

因此, 插入的状况只有三种, 删除的状况只有两种. 上面的分析, 作镜像处理, 就能获得插入删除的所有算法, 脑补吧. 从上面的分析来看, 红黑树具备如下特性: 插入删除操做都是 0(lnN), 且最多旋转三次.

红黑树并无咱们想象的那么难(下)

红黑树并无咱们想象的那么难上、下两篇已经完成, 但愿能帮助到你们.

红黑树并无咱们想象的那么难(上): http://daoluan.net/blog/rbtree-is-not-difficult/
红黑树并无咱们想象的那么难(下): http://daoluan.net/blog/rbtree-is-not-difficult-2/

SGI STL map 实现概述

根据上一节的红黑树分析, 结合 sgi stl map 的实现, 看看红黑树的源码是如何实现的. 如下主要以代码的注释为主.

sgi stl map 底层实现是 _Rb_tree类, 为了方便管理, _Rb_tree 内置了 _M_header, 用于记录红黑树中的根节点, 最小节点和最大节点. 在插入删除中都会对其进行维护. 找到一副美艳的图片:

我只会展开插入和删除的代码. _Rb_tree 有 insert_unique() 和 insert_equal() 两种, 前者不容许有重复值, 后者能够. insert_unique() 判断是否有重复值的方法利用了二叉搜索树的性质. 细节请参看下面的代码.

为何选择红黑树做为底层实现

红黑树是一种类平衡树, 但它不是高度的平衡树, 但平衡的效果已经很好了. 补充说明另外一种 AVL 树, 我以前的博文: 《编程珠玑，字字珠玑》读书笔记完结篇——AVL树

用过 STL map 么, 你用过 linux 么(这个说大了), 他们都有红黑树的应用. 当你对搜索的效率要求较高，而且数据常常改动的情景，你能够用红黑树, 也就是 map.

至于, 为何不用 AVL 树做为底层实现, 那是由于 AVL 树是高度平衡的树, 而每一次对树的修改, 都要 rebalance, 这里的开销会比红黑树大. 红黑树插入只要两次旋转, 删除至多三次旋转. 但不能否认的是, AVL 树搜索的效率是很是稳定的. 选取红黑树, 我认为是一种折中的方案.

红黑树源代码剖析

// sgi stl _Rb_tree 插入算法 insert_equal() 实现.
// 策略概述: insert_equal() 在红黑树找到本身的位置,
// 而后交由 _M_insert() 来处理接下来的工做.
// _M_insert() 会将节点插入红黑树中, 接着调整红黑树,
// 维持性质.
template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
  ::insert_equal(const _Value& __v)
{
  // 在红黑树中有头结点和根节点的概念, 头结点位于根节点之上,
  // 头结点只为管理而存在, 根节点是真正存储数据的地方. 头结点和根节点互为父节点,
   // 是一种实现的技巧.
  _Link_type __y = _M_header; // 指向头结点
  _Link_type __x = _M_root(); // _M_header->_M_parent, 即指向根节点

  // 寻找插入的位置
  while (__x != 0) {
    __y = __x;

    // 小于当前节点要走左边, 大于等于当前节点走右边
    __x = _M_key_compare(_KeyOfValue()(__v), _S_key(__x)) ?
            _S_left(__x) : _S_right(__x);
  }
  // __x 为须要插入的节点的位置, __y 为其父节点
  return _M_insert(__x, __y, __v);
}

// sgi stl _Rb_tree 插入算法 insert_unique() 实现.
// 策略概述: insert_unique() 一样也在红黑树中找到本身的位置; 咱们知道,
// 若是小于等于当前节点会往右走, 因此遇到一个相同键值的节点后, 会往右走一步,
// 接下来一直往左走, 因此下面的实现会对往左走的状况作特殊的处理.
template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
pair<typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator,
     bool>
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
  ::insert_unique(const _Value& __v)
{
  _Link_type __y = _M_header; // 指向头结点
  _Link_type __x = _M_root(); // 指向根节点, 可能为空
  bool __comp = true;

  // 寻找插入的位置
  while (__x != 0) {
    __y = __x;
    __comp = _M_key_compare(_KeyOfValue()(__v), _S_key(__x));

    // 小于当前节点要走左边, 大于等于当前节点走右边
    __x = __comp ? _S_left(__x) : _S_right(__x);
  }

  iterator __j = iterator(__y); // 在 __y 上创建迭代器

  // 我认为下面判断树中是否有存在键值的状况有点绕,
  // 它充分利用了二叉搜索树的性质, 如此作很 hack, 但不易理解.
  // 要特别注意往左边插入的状况.

  // HACKS:
  // 下面的 if 语句是比 __x 小走左边的状况: 会发现, 若是插入一个已存在的键的话,
  // __y 最终会定位到已存在键的右子树的最左子树.
  // 譬如, 红黑树中已经存在一个键为 100 的节点, 其右孩子节点为 101,
  // 此时若是再插入键为 100 的节点, 由于 100<=100, 因此会往右走到达 101 节点,
  // 有 100<101, 继而往左走, 会一直往左走.你们稍微画一个例子就能理解.
  if (__comp)
    // 特殊状况, 若是 __j 指向了最左孩子, 那么确定要插入新节点.
    if (__j == begin())
      return pair<iterator,bool>(_M_insert(__x, __y, __v), true);
    // 其余状况, 这个时候也是往左边插入, 若是存在重复的键值,
    // 那么 --__j 能定位到此重复的键的节点.
    else
      --__j;

  // HACKS: 这里比较的是 __j 和 __v, 若是存在键值, 那么 __j == __v,
  // 会跳过 if 语句. 不然执行插入. 也就是说若是存在重复的键, 那么 __j
  // 的值确定是等于 __v
  if (_M_key_compare(_S_key(__j._M_node), _KeyOfValue()(__v)))
    return pair<iterator,bool>(_M_insert(__x, __y, __v), true);

  // 此时 __y.value = __v, 不容许插入, 返回键值所在位置
  return pair<iterator,bool>(__j, false);
}

// _M_insert() 是真正执行插入的地方.
// 策略概述: 插入策略已经在上篇中详述, 能够根据上篇文章的描述,
// 和下面代码的注释, 加深对红黑树插入算法里理解
template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
  ::_M_insert(_Base_ptr __x_, _Base_ptr __y_, const _Value& __v)
{
  _Link_type __x = (_Link_type) __x_; // 新节点插入的位置.
  // 关于 __x 的疑问:
  // 1. 它被放到下面的, 第一个 if 语句中, 我以为是没有必要的,
  // 由于从调用 _M_insert() 的函数来看, __x 老是为空.
  // 2. 既然 __x 是新节点插入的位置, 那么为何不直接在 __x 上建立节点,
  // 还要在下面经过比较来决定新节点是左孩子仍是右孩子;
  // 不如直接用指针的指针或者指针的引用来完成, 省去了下面的判断.

  _Link_type __y = (_Link_type) __y_; // 新节点的父节点
  _Link_type __z; // 新节点的位置

  if (__y == _M_header || __x != 0 ||
      _M_key_compare(_KeyOfValue()(__v), _S_key(__y))) {
  // 新节点应该为左孩子
    __z = _M_create_node(__v);
    _S_left(__y) = __z;               // also makes _M_leftmost() = __z
                                      //    when __y == _M_header
    if (__y == _M_header) {
      _M_root() = __z;
      _M_rightmost() = __z;
    }
    else if (__y == _M_leftmost())
      _M_leftmost() = __z;   // maintain _M_leftmost() pointing to min node
  }
  // 新节点应该为右孩子
  else {
    __z = _M_create_node(__v);
    _S_right(__y) = __z;
    if (__y == _M_rightmost())
      _M_rightmost() = __z;  // maintain _M_rightmost() pointing to max node
  }
  _S_parent(__z) = __y;
  _S_left(__z) = 0;
  _S_right(__z) = 0;

  // 从新调整
  _Rb_tree_rebalance(__z, _M_header->_M_parent);

  // 更新红黑树节点数
  ++_M_node_count;

  // 返回迭代器类型
  return iterator(__z);
}

// 插入新节点后, 可能会破坏红黑树性质, _Rb_tree_rebalance() 负责维持性质.
// 其中:
// __x 新插入的节点
// __root 根节点
// 策略概述: 红黑树插入从新调整的策略已经在上篇中讲述,
// 能够结合上篇文章和这里的代码注释,
// 理解红黑树的插入算法.
inline void
_Rb_tree_rebalance(_Rb_tree_node_base* __x, _Rb_tree_node_base*& __root)
{
  // 将新插入的节点染成红色
  __x->_M_color = _S_rb_tree_red;

  while (__x != __root && __x->_M_parent->_M_color == _S_rb_tree_red) {
    // __x 的父节点也是红色的状况. 提示: 若是是黑色节点, 不会破坏红黑树性质.

    if (__x->_M_parent == __x->_M_parent->_M_parent->_M_left) {
      // 叔父节点
      _Rb_tree_node_base* __y = __x->_M_parent->_M_parent->_M_right;

      if (__y && __y->_M_color == _S_rb_tree_red) {
        // 第 1 种状况, N,P,U 都红(G 确定黑).
        // 策略: G->红, N,P->黑. 此时, G 红, 若是 G 的父亲也是红, 性质又被破坏了,
        // HACK: 能够将 GPUN 当作一个新的红色 N 节点, 如此递归调整下去;
        // 特俗的, 若是碰巧将根节点染成了红色, 能够在算法的最后强制 root->红.
        __x->_M_parent->_M_color = _S_rb_tree_black;
        __y->_M_color = _S_rb_tree_black;
        __x->_M_parent->_M_parent->_M_color = _S_rb_tree_red;
        __x = __x->_M_parent->_M_parent;
      }
      else {

        if (__x == __x->_M_parent->_M_right) {
        // 第 2 种状况, P 为红, N 为 P 右孩子, U 为黑或缺乏.
        // 策略: 旋转变换, 从而进入下一种状况:
          __x = __x->_M_parent;
          _Rb_tree_rotate_left(__x, __root);
        }
        // 第 3 种状况, 可能由第二种变化而来, 但不是必定: P 为红, N 为红.
        // 策略: 旋转, 交换 P,G 颜色, 调整后, 由于 P 为黑色, 因此不怕
        // P 的父节点是红色的状况. over
        __x->_M_parent->_M_color = _S_rb_tree_black;
        __x->_M_parent->_M_parent->_M_color = _S_rb_tree_red;
        _Rb_tree_rotate_right(__x->_M_parent->_M_parent, __root);
      }
    }
    else { // 下面的代码是镜像得出的, 脑补吧.
      _Rb_tree_node_base* __y = __x->_M_parent->_M_parent->_M_left;
      if (__y && __y->_M_color == _S_rb_tree_red) {
        __x->_M_parent->_M_color = _S_rb_tree_black;
        __y->_M_color = _S_rb_tree_black;
        __x->_M_parent->_M_parent->_M_color = _S_rb_tree_red;
        __x = __x->_M_parent->_M_parent;
      }
      else {
        if (__x == __x->_M_parent->_M_left) {
          __x = __x->_M_parent;
          _Rb_tree_rotate_right(__x, __root);
        }
        __x->_M_parent->_M_color = _S_rb_tree_black;
        __x->_M_parent->_M_parent->_M_color = _S_rb_tree_red;
        _Rb_tree_rotate_left(__x->_M_parent->_M_parent, __root);
      }
    }
  }
  __root->_M_color = _S_rb_tree_black;
}

// 删除算法, 直接调用底层的删除实现 _Rb_tree_rebalance_for_erase().
template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
inline void _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
  ::erase(iterator __position)
{
  _Link_type __y =
    (_Link_type) _Rb_tree_rebalance_for_erase(__position._M_node,
                                              _M_header->_M_parent,
                                              _M_header->_M_left,
                                              _M_header->_M_right);
  destroy_node(__y);
  --_M_node_count;
}

// 删除节点底层实现, 删除可能会破坏红黑树性质,
// _Rb_tree_rebalance()
// 负责维持性质. 其中:
// __z 须要删除的节点
// __root 根节点
// __leftmost 红黑树内部数据, 即最左子树
// __rightmost 红黑树内部数据, 即最右子树
// 策略概述: _Rb_tree_rebalance_for_erase() 会根据
// 删除节点的位置在红黑树中找到顶替删除节点的节点,
// 即无非是删除节点左子树的最大节点或右子树中的最小节点,
// 此处用的是有一种策略. 接着, 会调整红黑树以维持性质.
// 调整的算法已经在上篇文章中详述, 能够根据上篇文章的描述
// 和此篇的代码注释, 加深对红黑树删除算法的理解.
inline _Rb_tree_node_base*
_Rb_tree_rebalance_for_erase(_Rb_tree_node_base* __z,
                             _Rb_tree_node_base*& __root,
                             _Rb_tree_node_base*& __leftmost,
                             _Rb_tree_node_base*& __rightmost)
{
  // __z 是要删除的节点

  // __y 最终会指向要删除的节点
  _Rb_tree_node_base* __y = __z;
  // N 节点
  _Rb_tree_node_base* __x = 0;
  // 记录 N 节点的父节点
  _Rb_tree_node_base* __x_parent = 0;

  // 只有一个孩子或者没有孩子的状况
  if (__y->_M_left == 0)     // __z has at most one non-null child. y == z.
    __x = __y->_M_right;     // __x might be null.
  else
    if (__y->_M_right == 0)  // __z has exactly one non-null child. y == z.
      __x = __y->_M_left;    // __x is not null.

    // 有两个非空孩子
    else {                   // __z has two non-null children.  Set __y to
      __y = __y->_M_right;   //   __z's successor.  __x might be null.

      // __y 取右孩子中的最小节点, __x 记录他的右孩子(可能存在右孩子)
      while (__y->_M_left != 0)
        __y = __y->_M_left;
      __x = __y->_M_right;
    }

  // __y != __z 说明有两个非空孩子的状况,
  // 此时的删除策略就和文中提到的普通二叉搜索树删除策略同样:
  // __y 记录了 __z 右子树中最小的节点
  // __x 记录了 __y 的右孩子
  // 用 __y 顶替 __z 的位置, __x 顶替 __y 的位置, 最后用 __y 指向 __z,
  // 从而 __y 指向了要删除的节点
  if (__y != __z) {          // relink y in place of z.  y is z's successor

    // 将 __z 的记录转移至 __y 节点
    __z->_M_left->_M_parent = __y;
    __y->_M_left = __z->_M_left;

    // 若是 __y 不是 __z 的右孩子, __z->_M_right 有左孩子
    if (__y != __z->_M_right) {

      __x_parent = __y->_M_parent;

      // 若是 __y 有右孩子 __x, 必须有那个 __x 替换 __y 的位置
      if (__x)
        // 替换 __y 的位置
        __x->_M_parent = __y->_M_parent;

      __y->_M_parent->_M_left = __x;      // __y must be a child of _M_left
      __y->_M_right = __z->_M_right;
      __z->_M_right->_M_parent = __y;
    }
    // __y == __z->_M_right
    else
      __x_parent = __y;

    // 若是 __z 是根节点
    if (__root == __z)
      __root = __y;

    // __z 是左孩子
    else if (__z->_M_parent->_M_left == __z)
      __z->_M_parent->_M_left = __y;

    // __z 是右孩子
    else
      __z->_M_parent->_M_right = __y;

    __y->_M_parent = __z->_M_parent;
    // 交换须要删除节点 __z 和 替换节点 __y 的颜色
    __STD::swap(__y->_M_color, __z->_M_color);
    __y = __z;
    // __y now points to node to be actually deleted
  }
  // __y == __z 说明至多一个孩子
  else {                        // __y == __z
    __x_parent = __y->_M_parent;
    if (__x) __x->_M_parent = __y->_M_parent;

    // 将 __z 的父亲指向 __x
    if (__root == __z)
      __root = __x;
    else
      if (__z->_M_parent->_M_left == __z)
        __z->_M_parent->_M_left = __x;
      else
        __z->_M_parent->_M_right = __x;

    // __leftmost 和 __rightmost 是红黑树的内部数据, 由于 __z 多是
    // __leftmost 或者 __rightmost, 所以须要更新.
    if (__leftmost == __z)
      if (__z->_M_right == 0)        // __z->_M_left must be null also
        // __z 左右孩子都为空, 没有孩子
        __leftmost = __z->_M_parent;
    // makes __leftmost == _M_header if __z == __root
      else
        __leftmost = _Rb_tree_node_base::_S_minimum(__x);

    if (__rightmost == __z)
      if (__z->_M_left == 0)         // __z->_M_right must be null also
        __rightmost = __z->_M_parent;
    // makes __rightmost == _M_header if __z == __root
      else                      // __x == __z->_M_left
        __rightmost = _Rb_tree_node_base::_S_maximum(__x);

    // __y 一样已经指向要删除的节点
  }

  // __y 指向要删除的节点
  // __x 即为 N 节点
  // __x_parent 指向 __x 的父亲, 即 N 节点的父亲
  if (__y->_M_color != _S_rb_tree_red) {
    // __y 的颜色为黑色的时候, 会破坏红黑树性质

    while (__x != __root && (__x == 0 || __x->_M_color == _S_rb_tree_black))
      // __x 不为红色, 即为空或者为黑. 提示: 若是 __x 是红色, 直接将 __x 替换成黑色

      if (__x == __x_parent->_M_left) { // 若是 __x 是左孩子

        _Rb_tree_node_base* __w = __x_parent->_M_right; // 兄弟节点

        if (__w->_M_color == _S_rb_tree_red) {
          //第 2 状况, S 红, 根据红黑树性质P,SL,SR 必定黑.
          // 策略: 旋转, 交换 P,S 颜色.

          __w->_M_color = _S_rb_tree_black;
          __x_parent->_M_color = _S_rb_tree_red; // 交换颜色
          _Rb_tree_rotate_left(__x_parent, __root); // 旋转
          __w = __x_parent->_M_right; // 调整关系
        }

        if ((__w->_M_left == 0 ||
             __w->_M_left->_M_color == _S_rb_tree_black) &&
            (__w->_M_right == 0 ||
             __w->_M_right->_M_color == _S_rb_tree_black)) {
          // 提示: 这是 第 1 状况和第 2.1 状况的合并, 由于处理的过程是同样的.
          // 但他们的状况仍是要分门别类的. 已经在文章中详细支出,
          // 彷佛大多数的博文中没有提到这一点.

          // 第 1 状况, N,P,S,SR,SL 都黑.
          // 策略: S->红. 经过 PN,PS 的黑色节点数量相同了, 但会比其余路径多一个,
          // 解决的方法是在 P 上从状况 0 开始继续调整.
          // 为何要这样呢? HACKS: 由于既然 PN,PS
          // 路径上的黑节点数量相同并且比其余路径会少一个黑节点,
          // 那何不将其总体当作了一个 N 节点! 这是递归原理.

          // 第 2.1 状况, S,SL,SR 都黑.
          // 策略: P->黑. S->红, 由于经过 N 的路径多了一个黑节点,
          // 经过 S 的黑节点个数不变, 因此维持了性质 5. over

          // 可能你们会有疑问, 不对啊, 2.1 的状况,
          // 策略是交换父节点和兄弟节点的颜色, 此时怎么没有对父节点的颜色赋值呢?
          // HACKS: 这就是合并状况的好处, 由于就算此时父节点是红色,
          // 并且也将兄弟节点颜色改成红色, 你也能够将 PS,PN 当作一个红色的 N 节点,
          // 这样在下一个循环当中, 这个 N 节点也会变成黑色. 由于此函数最后有一句话:
          // if (__x) __x->_M_color = _S_rb_tree_black;
          // 合并状况, 节省代码量

          // 固然是能够分开写的

          // 兄弟节点染成红色
          __w->_M_color = _S_rb_tree_red;

          // 调整关系
          __x = __x_parent;
          __x_parent = __x_parent->_M_parent;
        } else {
          if (__w->_M_right == 0 ||
              __w->_M_right->_M_color == _S_rb_tree_black) {
            // 第 2.2.1 状况, S,SR 黑, SL 红.
            // 策略: 旋转, 变换 SL,S 颜色.

            if (__w->_M_left) __w->_M_left->_M_color = _S_rb_tree_black;
            __w->_M_color = _S_rb_tree_red;
            _Rb_tree_rotate_right(__w, __root);

            // 调整关系
            __w = __x_parent->_M_right;
          }

          // 第 2.2.2 状况, S 黑, SR 红.
          // 策略: 旋转, 交换 S,P 颜色, SR->黑色, 从新得到平衡.
          __w->_M_color = __x_parent->_M_color;
          __x_parent->_M_color = _S_rb_tree_black;
          if (__w->_M_right) __w->_M_right->_M_color = _S_rb_tree_black;
          _Rb_tree_rotate_left(__x_parent, __root);
          break;
        }                        // 下面的代码是镜像得出的, 脑补吧.
      } else {                  // same as above, with _M_right <-> _M_left.
        _Rb_tree_node_base* __w = __x_parent->_M_left;
        if (__w->_M_color == _S_rb_tree_red) {
          __w->_M_color = _S_rb_tree_black;
          __x_parent->_M_color = _S_rb_tree_red;
          _Rb_tree_rotate_right(__x_parent, __root);
          __w = __x_parent->_M_left;
        }
        if ((__w->_M_right == 0 ||
             __w->_M_right->_M_color == _S_rb_tree_black) &&
            (__w->_M_left == 0 ||
             __w->_M_left->_M_color == _S_rb_tree_black)) {
          __w->_M_color = _S_rb_tree_red;
          __x = __x_parent;
          __x_parent = __x_parent->_M_parent;
        } else {
          if (__w->_M_left == 0 ||
              __w->_M_left->_M_color == _S_rb_tree_black) {
            if (__w->_M_right) __w->_M_right->_M_color = _S_rb_tree_black;
            __w->_M_color = _S_rb_tree_red;
            _Rb_tree_rotate_left(__w, __root);
            __w = __x_parent->_M_left;
          }
          __w->_M_color = __x_parent->_M_color;
          __x_parent->_M_color = _S_rb_tree_black;
          if (__w->_M_left) __w->_M_left->_M_color = _S_rb_tree_black;
          _Rb_tree_rotate_right(__x_parent, __root);
          break;
        }
      }
    if (__x) __x->_M_color = _S_rb_tree_black;
  }
  return __y;
}

捣乱 2013-9-29

http://daoluan.net

《编程珠玑，字字珠玑》读书笔记完结篇——AVL树

概要

前面分别介绍红黑树的理论知识、红黑树的C语言和C++的实现。本章介绍红黑树的Java实现，若读者对红黑树的理论知识不熟悉，创建先学习红黑树的理论知识，再来学习本章。仍是那句老话，红黑树的C/C++/Java实现，原理同样，择其一了解便可。

红黑树(Red-Black Tree，简称R-B Tree)，它一种特殊的二叉查找树。
红黑树是特殊的二叉查找树，意味着它知足二叉查找树的特征：任意一个节点所包含的键值，大于等于左孩子的键值，小于等于右孩子的键值。
除了具有该特性以外，红黑树还包括许多额外的信息。

红黑树的每一个节点上都有存储位表示节点的颜色，颜色是红(Red)或黑(Black)。
红黑树的特性:
(1) 每一个节点或者是黑色，或者是红色。
(2) 根节点是黑色。
(3) 每一个叶子节点是黑色。 [注意：这里叶子节点，是指为空的叶子节点！]
(4) 若是一个节点是红色的，则它的子节点必须是黑色的。
(5) 从一个节点到该节点的子孙节点的全部路径上包含相同数目的黑节点。

关于它的特性，须要注意的是：
第一，特性(3)中的叶子节点，是只为空(NIL或null)的节点。
第二，特性(5)，确保没有一条路径会比其余路径长出俩倍。于是，红黑树是相对是接近平衡的二叉树。

红黑树的Java实现(代码说明)

红黑树的基本操做是添加、删除和旋转。在对红黑树进行添加或删除后，会用到旋转方法。为何呢？道理很简单，添加或删除红黑树中的节点以后，红黑树就发生了变化，可能不知足红黑树的5条性质，也就再也不是一颗红黑树了，而是一颗普通的树。而经过旋转，可使这颗树从新成为红黑树。简单点说，旋转的目的是让树保持红黑树的特性。
旋转包括两种：左旋和右旋。下面分别对红黑树的基本操做进行介绍。

RBTree是红黑树对应的类，RBTNode是红黑树的节点类。在RBTree中包含了根节点mRoot和红黑树的相关API。
注意：在实现红黑树API的过程当中，我重载了许多函数。重载的缘由，一是由于有的API是内部接口，有的是外部接口；二是为了让结构更加清晰。

将一个节点插入到红黑树中，须要执行哪些步骤呢？首先，将红黑树看成一颗二叉查找树，将节点插入；而后，将节点着色为红色；最后，经过"旋转和从新着色"等一系列操做来修正该树，使之从新成为一颗红黑树。详细描述以下：
第一步: 将红黑树看成一颗二叉查找树，将节点插入。
红黑树自己就是一颗二叉查找树，将节点插入后，该树仍然是一颗二叉查找树。也就意味着，树的键值仍然是有序的。此外，不管是左旋仍是右旋，若旋转以前这棵树是二叉查找树，旋转以后它必定仍是二叉查找树。这也就意味着，任何的旋转和从新着色操做，都不会改变它仍然是一颗二叉查找树的事实。
好吧？那接下来，咱们就来千方百计的旋转以及从新着色，使这颗树从新成为红黑树！

第二步：将插入的节点着色为"红色"。
为何着色成红色，而不是黑色呢？为何呢？在回答以前，咱们须要从新温习一下红黑树的特性：
(1) 每一个节点或者是黑色，或者是红色。
(2) 根节点是黑色。
(3) 每一个叶子节点是黑色。 [注意：这里叶子节点，是指为空的叶子节点！]
(4) 若是一个节点是红色的，则它的子节点必须是黑色的。
(5) 从一个节点到该节点的子孙节点的全部路径上包含相同数目的黑节点。
将插入的节点着色为红色，不会违背"特性(5)"！少违背一条特性，就意味着咱们须要处理的状况越少。接下来，就要努力的让这棵树知足其它性质便可；知足了的话，它就又是一颗红黑树了。o(∩∩)o...哈哈

第三步: 经过一系列的旋转或着色等操做，使之从新成为一颗红黑树。
第二步中，将插入节点着色为"红色"以后，不会违背"特性(5)"。那它到底会违背哪些特性呢？
对于"特性(1)"，显然不会违背了。由于咱们已经将它涂成红色了。
对于"特性(2)"，显然也不会违背。在第一步中，咱们是将红黑树看成二叉查找树，而后执行的插入操做。而根据二叉查找数的特色，插入操做不会改变根节点。因此，根节点仍然是黑色。
对于"特性(3)"，显然不会违背了。这里的叶子节点是指的空叶子节点，插入非空节点并不会对它们形成影响。
对于"特性(4)"，是有可能违背的！
那接下来，想办法使之"知足特性(4)"，就能够将树从新构形成红黑树了。

内部接口 -- insert(node)的做用是将"node"节点插入到红黑树中。
外部接口 -- insert(key)的做用是将"key"添加到红黑树中。

insertFixUp(node)的做用是对应"上面所讲的第三步"。它是一个内部接口。

将红黑树内的某一个节点删除。须要执行的操做依次是：首先，将红黑树看成一颗二叉查找树，将该节点从二叉查找树中删除；而后，经过"旋转和从新着色"等一系列来修正该树，使之从新成为一棵红黑树。详细描述以下：
第一步：将红黑树看成一颗二叉查找树，将节点删除。
这和"删除常规二叉查找树中删除节点的方法是同样的"。分3种状况：
① 被删除节点没有儿子，即为叶节点。那么，直接将该节点删除就OK了。
② 被删除节点只有一个儿子。那么，直接删除该节点，并用该节点的惟一子节点顶替它的位置。
③ 被删除节点有两个儿子。那么，先找出它的后继节点；而后把“它的后继节点的内容”复制给“该节点的内容”；以后，删除“它的后继节点”。在这里，后继节点至关于替身，在将后继节点的内容复制给"被删除节点"以后，再将后继节点删除。这样就巧妙的将问题转换为"删除后继节点"的状况了，下面就考虑后继节点。在"被删除节点"有两个非空子节点的状况下，它的后继节点不多是双子非空。既然"的后继节点"不可能双子都非空，就意味着"该节点的后继节点"要么没有儿子，要么只有一个儿子。若没有儿子，则按"状况① "进行处理；若只有一个儿子，则按"状况② "进行处理。

第二步：经过"旋转和从新着色"等一系列来修正该树，使之从新成为一棵红黑树。
由于"第一步"中删除节点以后，可能会违背红黑树的特性。因此须要经过"旋转和从新着色"来修正该树，使之从新成为一棵红黑树。

内部接口 -- remove(node)的做用是将"node"节点插入到红黑树中。
外部接口 -- remove(key)删除红黑树中键值为key的节点。

removeFixup(node, parent)是对应"上面所讲的第三步"。它是一个内部接口。

红黑树的Java实现(完整源码)

下面是红黑树实现的完整代码和相应的测试程序。
(1) 除了上面所说的"左旋"、"右旋"、"添加"、"删除"等基本操做以后，还实现了"遍历"、"查找"、"打印"、"最小值"、"最大值"、"建立"、"销毁"等接口。
(2) 函数接口大多分为内部接口和外部接口。内部接口是private函数，外部接口则是public函数。
(3) 测试代码中提供了"插入"和"删除"动做的检测开关。默认是关闭的，打开方法能够参考"代码中的说明"。建议在打开开关后，在草稿上本身动手绘制一下红黑树。

红黑树的Java测试程序

前面已经给出了红黑树的测试代码(RBTreeTest.java)，这里就再也不重复说明。下面是测试程序的运行结果：

AVL树、红黑树

1、AVL树的旋转规律

1. LL型

2. RR型

3. LR型

4. RL型

2、AVL树的基本操做

1.插入

2.删除

3.查找