红黑树学习笔记

      从上学期就一直打算写出红黑树，但是由于能力太水，插入操作始终无法看明白，最近学习数据结构重新将红黑树的插入操作看了一遍，结合《算法导论》，《data structures and programing design in C++》 和侯捷的《STL源码》，终于弄清楚插入操作中保持树结构的几种情况，虽然这三本书在分类上有些许的差别，但本质的方法还是一样的。

我还是根据算法导论将其分为3种情况（STL是分为4种情况）：

首先必须明白的情况是：每次插入节点的都设为红条件，如果需要保持红黑树结构时，则必然是新增节点的父亲节点也是红色，而且祖父节点必须是黑色（因为未插入前是一棵符合要求的红黑树）

  1.叔父节点为红色---处理：将父亲节点和叔父节点同时设为黑色，祖父节点设为红色，此时必须考虑祖父节

                                      点的父亲节点是否为黑色，所以将指针然后向上移动两层，继续往上判断是否满足红黑树性质。

  2. 叔父节点为黑色且是外侧插入----处理：进行单旋转操作，单旋转操作与AVL树类似，但是在细节处理上

                                                        需要格外注意，因为RB_Node有指向父节点的parent指针；

  3. 叔父节点为黑色且是内测插入----处理： 进行双旋转操作，旋转后更改两个节点颜色即可，双旋转操作

                                                        其实可以分解为左右两次单旋转操作，所以算法导论中这种情况

                                                         是只进行单旋转操作转化为情况2，我这里将其合并。

删除操作比较复杂，，有时间再看。。贴上自己写的插入代码：

#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
enum Color {red, black};
template<class Record>
//树节点
struct RB_Node{
  Color color;
  Record data;
  RB_Node *left, *right, *parent;
  RB_Node() {left = right = parent = NULL; color = red;}
  RB_Node(RB_Node*subroot, Record& data_) {
    left = right = NULL;
    parent = subroot;
    color = red; data = data_;
  } 
};

template<class Record>
class RB_Tree {
 public:
   RB_Tree() {root == NULL;}
   bool insert(Record& data_);
   void Inorder();
 private:
   void fix_up(RB_Node<Record>* &T, RB_Node<Record>* &z);
   void Left_Rotate(RB_Node<Record>* &T, RB_Node<Record>* &x);
   void Right_Rotate(RB_Node<Record>* &T, RB_Node<Record>* &x);
   void recursive_inorder(RB_Node<Record>* subroot);
   RB_Node<Record>* root;
};

template<class Record>
bool RB_Tree<Record>::insert(Record& data_) {
  //插入新元素
  RB_Node<Record> *x = root, *y = NULL;
  while (x) {
    y = x;
    if ((x->data) > data_)  x = x->left;
    else                     x = x->right;
  }
  RB_Node<Record>* z = new RB_Node<Record>(y, data_);
  if (y == NULL) {
    root = z; root->color = black; return true;
  } else if (data_ < y->data) {
    y->left = z;
  } else {
    y->right = z;
  }
  fix_up(root, z); //保持树结构
  return true;
}
template<class Record>
void RB_Tree<Record>::fix_up(RB_Node<Record>* &T, RB_Node<Record>* &z) {
  while (z->parent && (z->parent)->color == red) {
    if ((z->parent)->parent->left == z->parent) { //父亲节点位于祖父节点的左侧
      RB_Node<Record>* y = (z->parent)->parent->right;
      if (y && y->color == red) {   //case 1: 叔父节点为红色节点（注意若为nil是黑色节点）
        y->color = black;
        z->parent->color = black;
        (z->parent)->parent->color = red;
        z = (z->parent)->parent;
      } else  {                    
        if (z == z->parent->right) {   //case 2: 叔父节点为黑色且节点为内侧插入
          z = z->parent;
          Left_Rotate(T, z);
        }
        (z->parent)->color = black;   //case 3:叔父节点为黑色且节点为外侧插入
        (z->parent)->parent->color = red;
        z = (z->parent)->parent;
        Right_Rotate(T, z);
      }
    } else {                                 //父亲节点位于祖父节点右侧，与上面类似
      RB_Node<Record>* y = (z->parent)->parent->left;
      if (y && y->color == red) {
        y->color = black;
        z->parent->color = black;
        (z->parent)->parent->color = red;
        z = (z->parent)->parent;
      } else {
        if (z == (z->parent)->left) {
          z = z->parent;
          Right_Rotate(T, z);
        }
        (z->parent)->color = black;
        ((z->parent)->parent)->color = red;
        z = (z->parent)->parent;
        Left_Rotate(T, z);
      }
    }
  }
  if (z->parent == NULL) z->color = black;
}
template<class Record>  //旋转操作时应特别注意NULL的情况，需要考虑三对关系：1.x与y->left 2.x->parent 与y 3. x与y
void RB_Tree<Record>::Left_Rotate(RB_Node<Record>* &T, RB_Node<Record>* &x) {
  RB_Node<Record>* y = x->right;
  x->right = y->left;
  if (y->left != NULL) (y->left)->parent = x;
  y->parent = x->parent;
  if (x->parent == NULL) {
    T = y;
  } else if ((x->parent)->right == x){
    (x->parent)->right = y;
  } else {
    (x->parent)->left = y;
  }
  y->left = x;
  x->parent = y;
}
template<class Record> //The same as Left_rotate
void RB_Tree<Record>::Right_Rotate(RB_Node<Record>* &T, RB_Node<Record>* &x) {
  RB_Node<Record>* y = x->left;
  x->left = y->right;
  if (y->right != NULL) (y->right)->parent = x;
  y->parent = x->parent;
  if (x->parent == NULL) {
    T = y;
  } else if ((x->parent)->right == x) {
    (x->parent)->right = y;
  } else {
    (x->parent)->left = y;
  }
  y->right = x;
  x->parent = y;
}

//test inorder_traversal
template<class Record>
void RB_Tree<Record>::Inorder() {
  recursive_inorder(root);
}
template<class Record>
void RB_Tree<Record>::recursive_inorder(RB_Node<Record>* subroot) {
  if (subroot != NULL) {
    recursive_inorder(subroot->left);
    cout << subroot->data << endl;
    recursive_inorder(subroot->right);
  }
}

int main() {
  RB_Tree<int> rb;
  for (int i = 0; i < 10; i++) {
      int u;
    cin >> u;
    rb.insert(u);
    rb.Inorder();
    cout << endl;
  }
 // rb.Inorder();
  return 0;
}