红黑树

做过简单的测试，应该没什么大问题。想想算法导论这部分看了很久，又撸过AVL写起来还是有点小迷糊，也在迷糊中学了点东西。总之继续吧

Rb_tree.h

#pragma once

#include <iostream>

enum color{RED,BLACK};

template<class T>
struct node {
    node* p;
    node *left, *right;
    T key;
    color c;
    int siz;
    
    node(){}
    node(T key):p(0),left(0),right(0), key(key){}
};

template<class T>
class RbTree {
private:
    //typedef struct node node;
    node<T>* Root;
    node<T>* Nil;//代表本树的nullptr，主要方便去除后的平衡调整
public:
    RbTree() :Nil(new node<T>()), Root(0) {
        Root = Nil;
        Nil->c = BLACK;//叶节点
        Nil->siz = 0;
    }
    ~RbTree() {
        destroy(Root); 
        delete Nil;
    }
    
    void preorder() { _preorder(Root); }
    void insert(T key) {
        node<T>* xixi = new node<T>(key);
        if (xixi == 0) {//申请内存失败
            std::cerr << "new node fail!" << endl;
            return;
        }

        _insert(xixi);
    }
    void remove(T key) {
        _remove(key);
    }
    //找到第i顺序统计量对应的关键字
    T os_select(int i) { return (select(Root, i))->key; }
    //确定关键字key的顺序统计量
    int os_rank(T key) { return rank(find(key)); }

private:
    void _preorder(node<T>* u);
    void destroy(node<T>* u);
    void _insert(node<T>* u);
    void _remove(T key);
    void leftrotate(node<T>* u);
    void rightrotate(node<T>* u);
    void transplant(node<T>* u, node<T>* v);
    void rb_delete_fixup(node<T>* x);
    void rb_insert_fixup(node<T>* x);
    node<T>* minimum(node<T>* u);
    node<T>* find(T key);
    void size_fixup(node<T>* x,int dealta_siz);//添加第二个参数可以给delete和Insert一起用
    //找到顺序统计量i的节点
    node<T>* select(node<T>* root, int i);
    //确定u的顺序统计量
    int rank(node<T>* u);
};
template<class T>
node<T>* RbTree<T>::select(node<T>* root, int i) {
    if (root->left->siz + 1 == i)return root;
    //else
    if (i - 1 < root->left->siz)return select(root->left, i);
    else return select(root->right, i - 1 - root->left->siz);
}

template<class T>
int RbTree<T>::rank(node<T>* u) {
    int r = u->left->siz + 1;
    while (u != Root) {
        if (u == u->p->right)
            r += u->p->left->siz + 1;
        u = u->p;
    }
    return r;
}

template<class T>
void RbTree<T>::size_fixup(node<T>* x, int delta_siz) {
    while (x->p != Nil) {
        x = x->p;
        x->siz += delta_siz;
    }
}

template<class T>
void RbTree<T>::rb_delete_fixup(node<T>* x) {
    size_fixup(x, -1);//沿简单路径向上修改siz属性

    while (x != Root&&x->c == BLACK) {
        node<T>* w;
        if (x == x->p->left) {
            w = x->p->right;
            if (w->c == RED) {//case 1
                w->c = BLACK;
                x->p->c = RED;
                leftrotate(x->p);
                w = x->p->right;//重置
            }
            //case 2 3 4,对应w节点颜色为黑色
                if (w->left->c == BLACK&&w->right->c == BLACK) {
                    w->c = RED;
                    x = x->p;//上移
                }
                else {
                    if (w->right->c == BLACK) {
                        w->c = RED;
                        w->left->c = BLACK;
                        rightrotate(w);
                        w = x->p->right;
                    }
                    w->c = x->p->c;
                    x->p->c = BLACK;
                    w->right->c = BLACK;
                    leftrotate(x->p);
                    x = Root;//退出循环
                }        
        }
        else {//
            w = x->p->left;
            if (w->c == RED) {
                x->p->c = RED;
                w->c = BLACK;
                rightrotate(x->p);
                w = x->p->left;
            }
            if (w->right->c == BLACK&&w->left->c == BLACK) {
                w->c = RED;
                x = x->p;
            }
            else {
                if (w->left->c == BLACK) {
                    w->c = RED;
                    w->right->c = BLACK;
                    leftrotate(w);
                    w = x->p->left;
                }//case 4
                w->c = x->p->c;
                x->p->c = BLACK;
                w->left->c = BLACK;
                rightrotate(x->p);
                x = Root;
            }
        }
    }

    x->c = BLACK;
}

template<class T>
node<T>* RbTree<T>::minimum(node<T>* u) {
    if (u == Nil)return Nil;
    while (u->left != Nil)
        u = u->left;
    return u;
}

template<class T>
node<T>* RbTree<T>::find(T key) {
    node<T>* u = Root;
    while (u != Nil&&u->key != key) {
        if (u->key > key)
            u = u->left;
        else u = u->right;
    }
    if (u == Nil) 
        std::cout << "找不到key值为" << key << "的节点" << std::endl;
    return u;
}

template<class T>
void RbTree<T>::_remove(T key) {
    node<T>* z = find(key);
    if (z == Nil)return;//找不到要删除的节点
    node<T>* y = z;
    node<T>* x;
    color original_c = y->c;
    if (z->left == Nil) {
        x = z->right;
        transplant(z, z->right);
    }
    else if (z->right == Nil) {
        x = z->left;
        transplant(z, z->left);
    }
    else {
        y = minimum(z->right);//后继点，用于代替z
        original_c = y->c;
        x = y->right;
        if (y == z->right)
            x->p = y;
        else {
            y->right = z->right;
            y->right->p = y;
            transplant(y, x);//顺序很重要，x可能是空结点
        }

        transplant(z, y);
        y->left = z->left;
        y->left->p = y;
        y->c = z->c;
    }
    if (original_c == BLACK)
        rb_delete_fixup(x);

    delete z;
}

template<class T>
void RbTree<T>::rb_insert_fixup(node<T>* x) {
    size_fixup(x, 1);

    while (x->p->c == RED) {//此条件可保证x->p->必定存在
        if (x->p == x->p->p->left) {//x的父节点在x的爷爷的左侧
            node<T>* y = x->p->p->right;//叔节点哦
            if (y->c == RED) {//case 1
                y->c = BLACK;
                x->p->c = BLACK;
                x->p->p->c = RED;
                x = x->p->p;//节点上移
            }
            else{
                if (x == x->p->right){//case 2
                    x = x->p;
                    leftrotate(x);
                }
                x->p->c = BLACK;
                x->p->p->c = RED;
                rightrotate(x->p->p);
            }
        }
        else {//x->p==x->p->p->right
            node<T>* y = x->p->p->left;
            if (y->c == RED) {//case 1
                y->c = BLACK;
                x->p->c = BLACK;
                x->p->p->c = RED;
                x = x->p->p;
            }
            else {//叔节点y为黑色 分两种情况，其中case2可转化为case3
                if (x == x->p->left) {//case 2
                    x = x->p;
                    rightrotate(x);
                }//case 3
                x->p->c = BLACK;
                x->p->p->c = RED;
                leftrotate(x->p->p);
            }
        }
//while循环
    }
    Root->c = BLACK;
}

template<class T>
void RbTree<T>::_insert(node<T>* u) {
    node<T>* y = Nil;
    node<T>* x = Root;
    while (x != Nil) {
        y = x;
        if (u->key < x->key)
            x = x->left;
        else x = x->right;
    }

    u->p = y;
    if (y == Nil)Root = u;//原树为空
    else if (u->key < y->key)
        y->left = u;
    else
        y->right = u;

    u->left = Nil;
    u->right = Nil;
    u->c = RED;
    u->siz = 1;

    rb_insert_fixup(u);
}

template<class T>
void RbTree<T>::transplant(node<T>* u, node<T>* v) {//建立u->p和v的联系
    if (u->p == Nil)
        Root = v;
    else if (u == u->p->left)
        u->p->left = v;
    else 
        u->p->right = v;

    v->p = u->p;//对v是Nil的情况不做特殊讨论

}

template<class T>
void RbTree<T>::rightrotate(node<T>* u) {//调用该函数默认左孩子不为Nil
    node<T>* lc = u->left;
    lc->p = u->p;
    if (u->p == Nil)
        Root = lc;
    else if (u == u->p->left)
        u->p->left = lc;
    else
        u->p->right = lc;

    u->left = lc->right;
    if (lc->right != Nil)u->left->p = u;

    lc->right = u;
    u->p = lc;
    //change the size
    u->siz = u->left->siz + u->right->siz + 1;
    lc->siz = lc->left->siz + lc->right->siz + 1;
}

template<class T>
void RbTree<T>::leftrotate(node<T>* u) {//调用该函数默认右孩子不为Nil
    node<T>* rc = u->right;
    rc->p = u->p;
    if (u->p == Nil)
        Root = rc;
    else if (u == u->p->left)
        u->p->left = rc;
    else
        u->p->right = rc;

    u->right = rc->left;
    if (rc->left != Nil)u->right->p = u;

    rc->left = u;
    u->p = rc;
    //change the size
    u->siz = u->left->siz + u->right->siz + 1;
    rc->siz = rc->left->siz + rc->right->siz + 1;
}

template<class T>
void RbTree<T>::destroy(node<T>* u) {
    if (u == Nil)return;
    destroy(u->left);
    destroy(u->right);

    delete u;
}

template<class T>
void RbTree<T>::_preorder(node<T>* u) {
    if (u == Nil)return;

    if (u->p == Nil)std::cout << u->key << "是树根哦" << std::endl;
    else if (u == u->p->left)std::cout << u->key << "是" << u->p->key << "的左孩子" << std::endl;
    else std::cout << u->key << "是" << u->p->key << "的右孩子" << std::endl;
    std::cout << "颜色为" << (u->c == RED ? "红色" : "黑色") << std::endl;
    std::cout << "大小为" << u->siz << endl;
    _preorder(u->left);
    _preorder(u->right);
}

test.cpp

#include <iostream>
#include "RB_tree.h"

using namespace std;

int main(void) {
    RbTree<int> xixi;
    xixi.insert(11);
    xixi.insert(2);
    //xixi.insert(1);
    xixi.insert(1);
    xixi.insert(7);
    xixi.insert(5);
    xixi.insert(8);
    xixi.insert(4);
    xixi.insert(14);
    xixi.insert(15);
    //xixi.remove(14);
    //xixi.remove(11);
    //xixi.remove(2);

    xixi.preorder();
    int i;

    //cout << "请输入一个合法顺序统计量" << endl;
    /*while (cin >> i) {
        if (i <= 0)break;
        cout << "关键字为" << xixi.os_select(i) << endl;
        cout << "请输入一个合法顺序统计量" << endl;
    }*/

    cout << "请输入一个合法关键字" << endl;
    while (cin >> i) {
        cout << "该关键字顺序统计量为" << xixi.os_rank(i) << endl;
        cout << "请输入一个合法关键字" << endl;
    }

    return 0;
}