MyTinySTL的rb_tree源码分析

mystl项目地址为：https://github.com/Alinshans/MyTinySTL

原STL库十分庞大，父子类关系十分复杂。故借这个项目来研究原STL库的代码逻辑，对代码的理解都以注释的形式写在了注释里

参考博客: http://blog.csdn.net/v_JULY_v/article/details/6105630

红黑树

疑问：红黑树插入节点的时候，有两种形式。一种是允许重复节点的插入，另外一种是不允许重复节点的插入。
判断节点是否重复是一个我没有看明白的地方。具体函数体现在get_insert_unique_pos()。

性质

性质1. 结点是红色或黑色。
性质2. 根结点是黑色。
性质3. 所有叶子都是黑色。（叶子是NIL结点）
性质4. 每个红色结点的两个子结点都是黑色。（从每个叶子到根的所有路径上不能有两个连续的红色结点）
性质5. 从任一节结点到其每个叶子的所有路径都包含相同数目的黑色结点。

节点

//rb_tree_node_base中有如下数据
base_ptr   parent;  // 父节点    typedef rb_tree_node_base<T>* base_ptr;也就是指针类型
base_ptr   left;    // 左子节点
base_ptr   right;   // 右子节点
color_type color;   // 节点颜色
//真正的节点是rb_tree_node，继承自rb_tree_node_base
struct rb_tree_node :public rb_tree_node_base<T>
{
    ......
    T value;  // 节点值
    ......
}
//到这里，真正的节点内总共五个变量

迭代器

rb_tree_iterator_base继承自bidirectional_iterator_tag，是可向前向后的读写和输入的迭代器。

 //此函数主要是有一个变量，两个函数，用来被继承
struct rb_tree_iterator_base 
		:public mystl::iterator<mystl::bidirectional_iterator_tag, T>
{ //STL的迭代器有五种类型。  
  base_ptr node;  // 指向节点本身
  // 使迭代器前进，也就是下一个节点
  /*可以理解为：寻找节点的后继节点，我们先将整棵树进行一次中序遍历，得到一个序列。在此序列中，node的后继节点就是序列的下一个节点。可是在在原树中位置不是如此，需要分多种情况*/
  void inc()
  {
    if (node->right != nullptr){ //存在右子树，那么后继就是右子树的最左下节点 
      node = rb_tree_min(node->right);//此函数来寻找本树的最左下节点
    }
    else{  // 如果没有右子节点
      auto y = node->parent;
      while (y->right == node){//进行上溯查找node的父节点，也就是找最高层的父节点
        node = y;
        y = y->parent;
      }
      if (node->right != y)  // 应对“寻找根节点的下一节点，而根节点没有右子节点”的特殊情况
        node = y;
    }
  }
  // 使迭代器后退
  void dec(){
      //同inc逻辑
  }
}

真正的迭代器rb_tree_iterator继承自rb_tree_iterator_base

struct rb_tree_iterator :public rb_tree_iterator_base<T>
{
	//主要内容是构造函数和重载运算符，如++(重载是调用了inc()函数)
}

tree algorithm

rb_tree_min(NodePtr x)来寻找x的最左下节点
rb_tree_max(NodePtr x)来寻找x的最右下节点
还有一些变色的函数，很简单

template <class NodePtr>
NodePtr rb_tree_next(NodePtr node) noexcept //找前驱节点，有点像inc()函数
{
  if (node->right != nullptr) 
    return rb_tree_min(node->right);
  while (!rb_tree_is_lchild(node))//此函数判断本节点是不是某个父节点的左孩子，不知道特殊情况是什么
    node = node->parent;
  return node->parent;
}

旋转

树在经过左旋右旋之后，树的搜索性质保持不变，但树的红黑性质则被破坏了

/*---------------------------------------*\
|       p                         p       |
|      / \                       / \      |
|     x   d    rotate left      y   d     |
|    / \       ===========>    / \        |
|   a   y                     x   c       |
|      / \                   / \          |
|     b   c                 a   b         |
\*---------------------------------------*/
// 左旋，参数一为左旋点，参数二为根节点
/* 如上图，x-a和y-c是不需要变动的。
   首先将x的右孩子修改为b，然后将b的父节点修改为x，最后修改x，y的父节点。
   修改顺序可能造成成员丢失 */
template <class NodePtr>
void rb_tree_rotate_left(NodePtr x, NodePtr& root) noexcept
{
  auto y = x->right;  // y 为 x 的右子节点
  x->right = y->left;
  if (y->left != nullptr)/*y的左孩子如果为空，x的右孩子也为空。感觉可以不写这一句，不写这个if的只是重新给空指针又赋值一次空指针*/
    y->left->parent = x;
  y->parent = x->parent;

  if (x == root){ // 如果 x 为根节点，让 y 顶替 x 成为根节点
    root = y;
  }
  else if (rb_tree_is_lchild(x)){ // 如果 x 是左子节点
    x->parent->left = y;
  }
  else{ // 如果 x 是右子节点
    x->parent->right = y;
  }
  // 调整 x 与 y 的关系
  y->left = x;  
  x->parent = y;
}

右旋同理。

插入节点

插入节点共有五种情况：
1：根节点
2：父黑
3：父红叔红
4：父红叔黑NULL，父旋
5：父红叔黑NULL，祖父旋

在旋转的过程中，处理3后，情况变为4，处理4后情况变为5，处理5后，达到平衡。

具体解释：

// 插入节点后使 rb tree 重新平衡，参数一为新增节点，参数二为根节点
//
// case 1: 新增节点位于根节点，令新增节点为黑
// case 2: 新增节点的父节点为黑，没有破坏平衡，直接返回
// case 3: 父节点和叔叔；节点都为红，令父节点和叔叔节点为黑，祖父节点为红，
//         然后令祖父节点为当前节点，继续处理
// case 4: 父节点为红，叔叔节点为 NIL 或黑色，父节点为左（右）孩子，当前节点为右（左）孩子，
//         让父节点成为当前节点，再以当前节点为支点左（右）旋
// case 5: 父节点为红，叔叔节点为 NIL 或黑色，父节点为左（右）孩子，当前节点为左（右）孩子，
//         让父节点变为黑色，祖父节点变为红色，以祖父节点为支点右（左）旋
// https://blog.csdn.net/v_JULY_v/article/details/6105630 参考地址
template <class NodePtr>
void rb_tree_insert_rebalance(NodePtr x, NodePtr& root) noexcept
{
  rb_tree_set_red(x);  // 新增节点规定为红色
  while (x != root && rb_tree_is_red(x->parent)) 
  {
    if (rb_tree_is_lchild(x->parent)){ // 如果父节点是左子节点
      auto uncle = x->parent->parent->right; //叔叔节点
      if (uncle != nullptr && rb_tree_is_red(uncle)) { // case 3: 父节点和叔叔节点都为红
        rb_tree_set_black(x->parent);
        rb_tree_set_black(uncle);//父节点和叔节点都变为黑色
        x = x->parent->parent;
        rb_tree_set_red(x);//祖父节点为红色。继续处理体现在：x已经变为祖父节点且继续执行while上
      }
      else{ // 无叔叔节点或叔叔节点为黑
        if (!rb_tree_is_lchild(x)){ // case 4: 当前节点 x 为右子节点
          x = x->parent;
          rb_tree_rotate_left(x, root); //以x的父节点为支点左旋
        }
        // 都转换成 case 5： 当前节点为左子节点
        rb_tree_set_black(x->parent);
        rb_tree_set_red(x->parent->parent);
        rb_tree_rotate_right(x->parent->parent, root);
        break;
      }
    }
    else  {// 如果父节点是右子节点，对称处理 
      auto uncle = x->parent->parent->left;
      if (uncle != nullptr && rb_tree_is_red(uncle)) { // case 3: 父节点和叔叔节点都为红
        rb_tree_set_black(x->parent);
        rb_tree_set_black(uncle);
        x = x->parent->parent;
        rb_tree_set_red(x);
        // 此时祖父节点为红，可能会破坏红黑树的性质，令当前节点为祖父节点，继续处理
      }
      else { // 无叔叔节点或叔叔节点为黑
        if (rb_tree_is_lchild(x)) { // case 4: 当前节点 x 为左子节点
          x = x->parent;
          rb_tree_rotate_right(x, root);
        }
        // 都转换成 case 5： 当前节点为左子节点
        rb_tree_set_black(x->parent);
        rb_tree_set_red(x->parent->parent);
        rb_tree_rotate_left(x->parent->parent, root);
        break;//父节点变为黑色，祖父节点变为红色，以祖父节点为支点右旋
      }
    }
  }
  rb_tree_set_black(root);  // 根节点永远为黑
}

删除节点

删除节点分两个步骤进行：一是直接删除，二是调整红黑树(因为删除节点后，原红黑树可能发生改变)
删除z：
1，z是叶节点：直接删除
2，z只有一个儿子：那么将z的儿子取代z的位置
3，z左右孩子都有：左孩子的最右下节点(前驱)替代z，或者右孩子的最左下(后继)节点替代z。

调整：
1，如果删除的是红色节点，那么原红黑树的性质依旧保持，此时不用做修正操作。删红不变
2，如果删除的节点是黑色节点，原红黑树的性质可能会被改变，我们要对其做修正操作。 如果只是根节点，什么都不用做。
2.1，如果删除节点不是树唯一节点，那么删除节点的那一个支的到各叶节点的黑色节点数会发生变化，此时性质5被破坏。
2.2，如果被删节点的唯一非空子节点是红色，而被删节点的父节点也是红色，那么性质4被破坏。
2.3，如果被删节点是根节点，而它的唯一非空子节点是红色，则删除后新根节点将变成红色，违背性质2。

我们从被删节点后来顶替它的那个节点开始调整(即代码中的x节点)

此区域信息收集于博客，有较大修改
case 1：兄红。当前节点是黑且兄弟节点为红色。
解法：把父节点染成红色，把兄弟结点染成黑色，之后重新进入算法。
此变换后原红黑树性质5不变，而把问题转化为兄弟节点为黑色的情况
case 2：兄黑兄两儿黑。当前节点是黑且兄弟是黑色且兄弟节点的两个子节点全为黑色。
解法：令兄弟节点为红，父节点成为当前节点，重新进入算法。
case 3：兄黑兄左子红右子黑。
解法：把兄弟结点染红，兄弟左子节点染黑，之后再在兄弟节点为支点解右旋，之后重新进入算法。
case 4：兄黑兄左子任意，右子红。
解法：把兄弟节点染成当前节点父节点的颜色，把当前节点父节点染成黑色，兄弟节点右子染成黑色，之后以当前节点的父节点为支点进行左旋，此时算法结束，红黑树所有性质调整正确。

// 删除节点后使 rb tree重新平衡，参数一为要删除的节点，参数二为根节点，参数三为最小节点，参数四为最大节点

template <class NodePtr>
NodePtr rb_tree_erase_rebalance(NodePtr z, NodePtr& root, NodePtr& leftmost, 
                                NodePtr&rightmost)
{
  // y 是可能的替换节点，指向最终要删除的节点
  auto y = (z->left == nullptr || z->right == nullptr) ? z : rb_tree_next(z);
  // x 是 y 的一个独子节点或 NIL 节点
  auto x = y->left != nullptr ? y->left : y->right;
  // xp 为 x 的父节点
  NodePtr xp = nullptr;
  ......//这里主要是删除节点z
      
  // 此时，y 指向要删除的节点，x 为替代节点，从 x 节点开始调整。
  // 如果删除的节点为红色，树的性质没有被破坏，否则按照以下情况调整（x 为左子节点为例）：
  // case 1: 兄弟节点为红色，令父节点为红，兄弟节点为黑，以父亲作为支点进行左（右）旋，继续处理
  // case 2: 兄弟节点为黑色，且两个子节点都为黑色或 NIL，令兄弟节点为红，父节点成为当前节点，继续处理
  // case 3: 兄弟节点为黑色，左子节点为红色或 NIL，右子节点为黑色或 NIL，
  //         令兄弟节点为红，兄弟节点的左子节点为黑，以兄弟节点为支点右（左）旋，继续处理
  // case 4: 兄弟节点为黑色，右子节点为红色，令兄弟节点为父节点的颜色，父节点为黑色，兄弟节点的右子节点
  //         为黑色，以父节点为支点左（右）旋，树的性质调整完成，算法结束
  if (!rb_tree_is_red(y))
  { // x 为黑色时，调整，否则直接将 x 变为黑色即可
    while (x != root && (x == nullptr || !rb_tree_is_red(x)))
    {
      if (x == xp->left)
      { // 如果 x 为左子节点
        auto brother = xp->right;
        if (rb_tree_is_red(brother))
        { // case 1
          rb_tree_set_black(brother);
          rb_tree_set_red(xp);
          rb_tree_rotate_left(xp, root);
          brother = xp->right;
        }
        // case 1 转为为了 case 2、3、4 中的一种
        if ((brother->left == nullptr || !rb_tree_is_red(brother->left)) &&
            (brother->right == nullptr || !rb_tree_is_red(brother->right)))
        { // case 2
          rb_tree_set_red(brother);
          x = xp;
          xp = xp->parent;
        }
        else
        { 
          if (brother->right == nullptr || !rb_tree_is_red(brother->right))
          { // case 3
            if (brother->left != nullptr)
              rb_tree_set_black(brother->left);
            rb_tree_set_red(brother);
            rb_tree_rotate_right(brother, root);
            brother = xp->right;
          }
          // 转为 case 4
          brother->color = xp->color;
          rb_tree_set_black(xp);
          if (brother->right != nullptr)  
            rb_tree_set_black(brother->right);
          rb_tree_rotate_left(xp, root);
          break;
        }
      }
      else  {// x 为右子节点，对称处理
        ......
      }
    }
    if (x != nullptr)
      rb_tree_set_black(x);
  }
  return y;
}

rb_tree

在类rb_tree中，有三个数据

private:
  // 用以下三个数据表现 rb tree
  base_ptr    header_;      // 特殊节点，与根节点互为对方的父节点
  size_type   node_count_;  // 节点数，在empty()和size()起到重要作用
  key_compare key_comp_;    // 节点键值比较的准则
  // 以下三个函数用于取得根节点，最小节点和最大节点
  base_ptr& root()      const { return header_->parent; }
  base_ptr& leftmost()  const { return header_->left; }
  base_ptr& rightmost() const { return header_->right; }
//这里的header_的左孩子是最小节点，右孩子是最大节点，父节点指向root

析构函数：

 ~rb_tree() { clear(); } //调用clear(),clear()中调用erase_since()递归的删除每个节点

查找函数:

// 查找键值为 k 的节点，返回指向它的迭代器
find(const key_type& key)
{
  // key 小于等于 x 键值，向左走
  // key 大于 x 键值，向右走
}

插入函数：

插入的函数有emplace，insert相关的函数，insert又是调用的emplace，所以说，实际上是emplace。
插入有两种类型的函数，分别是emplace_unique(不允许键值重复)，emplace_multi(允许键值重复)

// 就地插入元素，键值允许重复
//get_insert_multi_pos()返回值是个pair：第一个元素是rb-tree迭代器指向新增结点；第二个表示成功与否
emplace_multi(Args&& ...args)
{
  THROW_LENGTH_ERROR_IF(node_count_ > max_size() - 1, "rb_tree<T, Comp>'s size too big");
  node_ptr np = create_node(mystl::forward<Args>(args)...); //创建一个节点
  auto res = get_insert_multi_pos(value_traits::get_key(np->value));//返回应该插入的位置
  return insert_node_at(res.first, np, res.second); //插入节点
}
// 在 x 节点处插入新的节点
// x 为插入点的父节点， node 为要插入的节点，add_to_left 表示是否在左边插入
insert_node_at(base_ptr x, node_ptr node, bool add_to_left) //1560
{
  ...... // 加入节点，维护header_等的三个数据
  rb_tree_insert_rebalance(base_node, root());  //调整结构
  ++node_count_;
  return iterator(node);
}

//不允许键值重复
emplace_unique(Args&& ...args)
{
  ......
  auto res = get_insert_unique_pos(value_traits::get_key(np->value));
    /*不允许键值的重复，主要是靠此函数来实现的*/
  ......
}
// get_insert_unique_pos 函数
rb_tree<T, Compare>::get_insert_unique_pos(const key_type& key)
{ /** 返回一个pair<pair,bool>,嵌套结构
  /*  第一个值为一个 pair，包含插入点的父节点和一个 bool 表示是否在左边插入，
  /*  第二个值为一个 bool，表示是否插入成功
  */
  ......
  //x是根节点，y是head_，add_to_left = true
  while (x != nullptr) {  //此循环寻找插入节点的位置
	y = x;
    add_to_left = key_comp_(key, value_traits::get_key(x->get_node_ptr()->value));
    x = add_to_left ? x->left : x->right;
  }
  iterator j = iterator(y);  // 此时 y 为插入点的父节点
  if (add_to_left){ //在左边添加
    if (y == header_ || j == begin()){ // 如果树为空树或插入点在最左节点处，肯定可以插入新的节点
      return mystl::make_pair(mystl::make_pair(y, true), true);
    }
    else{ // 否则，如果存在重复节点，那么 --j 就是重复的值
/* 没看懂，大概意思是说：迭代器已经重载了--，那么--j就是j的直接前驱。如果存在一样的数值，那么这个数值就是直接前驱。具体为什么不知道  */
      --j;
    }
  }
  if (key_comp_(value_traits::get_key(*j), key))  { // 表明新节点没有重复
    return mystl::make_pair(mystl::make_pair(y, add_to_left), true);
  }
  // 进行至此，表示新节点与现有节点键值重复
  return mystl::make_pair(mystl::make_pair(y, add_to_left), false);
}

另外，
emplace_multi_use_hint()就地插入元素，键值允许重复，当 hint 位置与插入位置接近时，插入操作的时间复杂度可以降低；
emplace_unique_use_hint()就地插入元素，键值不允许重复，当 hint 位置与插入位置接近时，插入操作的时间复杂度可以降低

键值：

底层使用pair

本文只是自己的理解，仅供学习。

如有错误，请指出。