1、头文件 RBTree.h
- #ifndef RBTREE__JOHN__DMRC
- #define RBTREE__JOHN__DMRC
- /******************** Class Node **********************/
- template <typename T>
- class Node{
- public:
- Node() : red(false), exist(false), left(NULL), right(NULL), parent(NULL){}
- Node(T &t) : data(t), red(true), exist(true), left(NULL), right(NULL), parent(NULL){}
- //function
- // max & min
- Node<T>* maximum();
- Node<T>* minimum();
- // successor & predecessor
- Node<T>* successor();
- Node<T>* predecessor();
- // exist
- bool isExist() { return this ->exist; }
- bool isNULL() { return !this ->exist; }
- // red & black ( black = 0 & red = 1 )
- bool getColor() { return this ->red; }
- bool isRed(){ return this ->red; }
- bool isBlack() { return !this ->red; }
- void setColor(bool c) { this ->red = c; }
- void setRed() { this ->red = true; }
- void setBlack() { this ->red = false; }
- //varables
- T data;
- bool red;
- bool exist;
- Node<T>* left;
- Node<T>* right;
- Node<T>* parent;
- };
- /******************** Class RBTree ********************/
- template <typename T, typename E>
- class RBTree{
- public:
- RBTree() : root(NULL){}
- ~RBTree();
- bool Insert(T &);
- bool Delete(T &, E);
- // debug
- T get_head(){ return root ->data;}
- private:
- // delete_tree;
- void delete_tree(Node<T>*);
- // delete a node;
- bool delete_node(T&, Node<T>*);
- // rotates
- void left_rotate(Node<T>*);
- void right_rotate(Node<T>*);
- // fixups
- void insert_fixup(Node<T>*);
- void delete_fixup(Node<T>*);
- Node<T>* root;
- };
- #endif
2、实现 RBTree.cpp
- #include "RBTree.h"
- /******************** Class Node **********************/
- template <typename T>
- Node<T>* Node<T>::maximum(){
- Node<T>* x = this;
- while(x ->right ->isExist())
- x = x ->right;
- return x;
- }
- template <typename T>
- Node<T>* Node<T>::minimum(){
- Node<T>* x = this;
- while(x ->left ->isExist())
- x = x ->left;
- return x;
- }
- template <typename T>
- Node<T>* Node<T>::successor(){
- Node<T>* y;
- Node<T>* x;
- if(this ->right ->isExist())
- return this ->right ->minimum();
- x = this;
- y = x ->parent;
- while(y != NULL && x == y ->right){
- x = y;
- y = x ->parent;
- }
- return y;
- }
- template <typename T>
- Node<T>* Node<T>::predecessor(){
- Node<T>* y;
- Node<T>* x;
- if(this ->left ->isExist())
- return this ->left ->maximum();
- x = this;
- y = x ->parent;
- while(y != NULL && x == y ->left){
- x = y;
- y = x ->parent;
- }
- return y;
- }
- /******************* Class RBTree *********************/
- template <typename T, typename E>
- RBTree<T, E>::~RBTree(){
- this ->delete_tree(this ->root);
- }
- template <typename T, typename E>
- void RBTree<T, E>::delete_tree(Node<T>* p){
- if(p){
- if(p ->left)
- this ->delete_tree(p ->left);
- if(p ->right)
- this ->delete_tree(p ->right);
- delete p;
- }
- }
- // Insert & fixup
- template <typename T, typename E>
- bool RBTree<T, E>::Insert(T &t){
- if(this ->root == NULL || this ->root ->isNULL()){
- if(this ->root)
- delete this ->root;
- this ->root = new Node<T>(t);
- this ->root ->left = new Node<T>();
- this ->root ->left ->parent = this ->root;
- this ->root ->right = new Node<T>();
- this ->root ->right ->parent = this ->root;
- this ->root ->setBlack();
- return true;
- }
- Node<T>* p = this ->root;
- while(1){
- if(t == p ->data)
- return false;
- if(t < p ->data){
- if(p ->left ->isNULL()){
- delete p ->left;
- p ->left = new Node<T>(t);
- p ->left ->parent = p;
- p ->left ->left = new Node<T>();
- p ->left ->left ->parent = p ->left;
- p ->left ->right = new Node<T>();
- p ->left ->right ->parent = p ->left;
- this ->insert_fixup(p ->left);
- return true;
- }
- else
- p = p ->left;
- }
- else{
- if(p ->right ->isNULL()){
- delete p ->right;
- p ->right = new Node<T>(t);
- p ->right ->parent = p;
- p ->right ->left = new Node<T>();
- p ->right ->left ->parent = p ->left;
- p ->right ->right = new Node<T>();
- p ->right ->right ->parent = p ->left;
- this ->insert_fixup(p ->right);
- return true;
- }
- else
- p = p ->right;
- }
- }
- return false;
- }
- template <typename T, typename E>
- void RBTree<T, E>::insert_fixup(Node<T>* z){
- Node<T>* y;
- while(z ->parent && z ->parent ->isRed()){
- if(z ->parent == z ->parent ->parent ->left){
- y = z ->parent ->parent ->right;
- if(y ->isRed()){
- //case 1
- z ->parent ->setBlack();
- y ->setBlack();
- z ->parent ->parent ->setRed();
- z = z ->parent ->parent;
- }
- else{
- if(z == z ->parent ->right){
- // case 2 ( fall through to case 3 )
- z = z ->parent;
- this ->left_rotate(z);
- }
- // case 3
- z ->parent ->setBlack();
- z ->parent ->parent ->setRed();
- this ->right_rotate(z ->parent ->parent);
- }
- }
- else{
- y = z ->parent ->parent ->left;
- if(y ->isRed()){
- // case 4
- z ->parent ->setBlack();
- y ->setBlack();
- z ->parent ->parent ->setRed();
- z = z ->parent ->parent;
- }
- else{
- if(z == z ->parent ->left){
- // case 5 ( fall through to case 6 )
- z = z ->parent;
- this ->right_rotate(z);
- }
- // case 6
- z ->parent ->setBlack();
- z ->parent ->parent ->setRed();
- this ->left_rotate(z ->parent ->parent);
- }
- }
- }
- this ->root ->setBlack();
- }
- // delete & fixup
- template <typename T, typename E>
- bool RBTree<T, E>::Delete(T &t, E e){
- Node<T>* p = this ->root;
- while(p ->isExist()){
- if(p ->data == e)
- return this ->delete_node(t, p);
- else if(e < p ->data)
- p = p ->left;
- else
- p = p ->right;
- }
- return false;
- }
- template <typename T, typename E>
- bool RBTree<T, E>::delete_node(T& t, Node<T>* z){
- Node<T>* y;
- Node<T>* x;
- if(z ->left ->isNULL() || z ->right ->isNULL())
- y = z;
- else
- y = z ->successor();
- if(y ->left ->isExist()){
- x = y ->left;
- if(y ->right ->isNULL())
- delete y ->right;
- }
- else{
- x = y ->right;
- if(y ->left ->isNULL())
- delete y ->left;
- }
- x ->parent = y ->parent;
- if(y ->parent == NULL)
- this ->root = x;
- else if(y == y ->parent ->left)
- y ->parent ->left = x;
- else
- y ->parent ->right = x;
- if(y != z){
- T temp = z ->data;
- z ->data = y ->data;
- y ->data = temp;
- }
- if(y ->isBlack())
- this ->delete_fixup(x);
- t = y ->data;
- delete y;
- return true;
- }
- template <typename T, typename E>
- void RBTree<T, E>::delete_fixup(Node<T>* x){
- Node<T>* w;
- while(x != this ->root && x ->isBlack()){
- if(x == x ->parent ->left){
- w = x ->parent ->right;
- if(w ->isRed()){
- // case 1 ( fall through )
- w ->setBlack();
- x ->parent ->setRed();
- this ->left_rotate(x ->parent);
- w = x ->parent ->right;
- }
- if(w ->left ->isBlack() && w ->right ->isBlack()){
- // case 2 ( new circle with x's value changed )
- w ->setRed();
- x = x ->parent;
- }
- else{
- if(w ->right ->isBlack()){
- // case 3 ( fall through to case 4 )
- w ->left ->setBlack();
- w ->setRed();
- this ->right_rotate(w);
- w = x ->parent ->right;
- }
- // case 4 ( exit the while with x = root )
- w ->setColor(x ->parent ->getColor());
- x ->parent ->setBlack();
- w ->right ->setBlack();
- this ->left_rotate(x ->parent);
- x = this ->root;
- }
- }
- else{
- w = x ->parent ->left;
- if(w ->isRed()){
- // case 5 ( fall through )
- w ->setBlack();
- x ->parent ->setRed();
- this ->right_rotate(x ->parent);
- w = x ->parent ->left;
- }
- if(w ->left ->isBlack() && w ->right ->isBlack()){
- // case 6 ( new circle with x's value changed )
- w ->setRed();
- x = x ->parent;
- }
- else{
- if(w ->left ->isBlack()){
- // case 7 ( fall through to case 8 )
- w ->right ->setBlack();
- w ->setRed();
- this ->left_rotate(w);
- w = x ->parent ->left;
- }
- // case 8 ( exit the while with x = root)
- w ->setColor(x ->parent ->getColor());
- x ->parent ->setBlack();
- w ->left ->setBlack();
- this ->right_rotate(x ->parent);
- x = this ->root;
- }
- }
- }
- x ->setBlack();
- }
- // rotate
- template <typename T, typename E>
- void RBTree<T, E>::left_rotate(Node<T>* x){
- Node<T>* y = x ->right;
- // set beta
- x ->right = y ->left;
- if(y ->left)
- y ->left ->parent = x;
- // set parent
- y ->parent = x ->parent;
- if(x ->parent == NULL)
- this ->root = y;
- else{
- if(x == x ->parent ->left)
- x ->parent ->left = y;
- else
- x ->parent ->right = y;
- }
- // set relation
- y ->left = x;
- x ->parent = y;
- }
- template <typename T, typename E>
- void RBTree<T, E>::right_rotate(Node<T>* x){
- Node<T>* y = x ->left;
- // set beta
- x ->left = y ->right;
- if(y ->right)
- y ->right ->parent = x;
- // set parent
- y ->parent = x ->parent;
- if(x ->parent == NULL)
- this ->root = y;
- else{
- if(x == x ->parent ->left)
- x ->parent ->left = y;
- else
- x ->parent ->right = y;
- }
- // set relation
- y ->right = x;
- x ->parent = y;
- }
3、简单的应用 main.cpp
- #include <iostream>
- #include <string>
- template<typename T, typename E> class RBTree;
- using namespace std;
- int main(void){
- RBTree<int, int> s;
- int i, a[10] = { 1, 2, 3, 4, 6, 8, 0, 7, 5, 9};
- for(i = 0; i < 10; i ++){
- s.Insert(a[i]);
- cout << s.get_head() << endl;
- }
- return 0;
- }