C++红黑树

#ifndef _RBTREE_H_
#define _RBTREE_H_

const int nodeSize = 3;
class RBTree
{
private:
    typedef struct Node {
        int key;
        int color;    //0为红，1为黑
        Node * family[nodeSize];    //family[0]左节点，family[1]右节点，family[2]父节点
        Node(int k, int c);
    }* Pnode;
private:
    Pnode nil;
    Pnode root;
private:
    //返回k节点
    Pnode __GetNode(int k);
    //中序遍历
    void __ShowNode(Pnode n)const;
    //旋转节点，direction 为 0 左旋转，1右旋转
    void __Rotate(Pnode n, int direction);
    //修正插入后的红黑树
    void __InsertFixup(Pnode n);
    //修正删除后的红黑树
    void __DeleteFixup(Pnode delNode);
    //释放内存
    void __Clear(Pnode n);
    //返回当前节点(包含当前节点)下的所有节点个数.
    size_t __NodeSize(Pnode n);
    //返回节点n的前驱(direction = 0),后继(direction = 1)
    Pnode __GetNeighbor(Pnode n, int direction);
public:
    RBTree();
    bool IsExist(int k);
    size_t Size();
    //按从小到大打印所有节点的key值
    void ShowList()const;
    //按树的层次打印节点的key值和颜色(R,B)
    void ShowTree()const;
    //插入新节点
    void Insert(int k);
    //删除节点
    void Delete(int k);
    ~RBTree();
};

#endif

#include "RBTree.h"
#include <iostream>
#include <queue>

using namespace std;

RBTree::Node::Node(int k = 0x80000000, int c = 0) :key(k), color(c), family{} {}

RBTree::RBTree(): nil(new Node(0x80000000, 1)), root(nil){}

RBTree::~RBTree() 
{
    __Clear(root);
    delete nil;
}

void RBTree::__Clear(Pnode n)
{
    if (n == nil)
        return;
    __Clear(n->family[0]);
    __Clear(n->family[1]);
    delete n;
}

bool RBTree::IsExist(int k) 
{
    return __GetNode(k) != nil;
}

size_t RBTree::__NodeSize(Pnode n)
{
    if (n == nil)
        return 0;
    return 1 + __NodeSize(n->family[0]) + __NodeSize(n->family[1]);
}

void RBTree::__ShowNode(Pnode n) const
{
    if (n == nil)
        return;
    __ShowNode(n->family[0]);
    cout << n->key << " ";
    __ShowNode(n->family[1]);
}

void RBTree::ShowList() const
{
    __ShowNode(root);
    cout << endl;
}

void RBTree::ShowTree() const
{
    queue<Pnode> dn;
    if(root != nil)
        dn.push(root);
    int size = 0;
    while (!dn.empty())
    {
        size = dn.size();
        for (int i = 0; i < size; i++)
        {
            cout << dn.front()->key;
            if (dn.front()->color)
                cout << "B  ";
            else cout << "R  ";
            if (dn.front()->family[0] != nil)
                dn.push(dn.front()->family[0]);
            if (dn.front()->family[1] != nil)
                dn.push(dn.front()->family[1]);
            dn.pop();
        }
        cout << endl;
    }
}

RBTree::Pnode RBTree::__GetNeighbor(Pnode n, int direction)
{
    Pnode current{};
    if (n->family[direction] != nil)
    {
        current = n->family[direction];
        while (current->family[!direction] != nil)
            current = current->family[!direction];
    }
    else {
        current = n;
        while (current->family[2] != nil && current != current->family[2]->family[!direction])
            current = current->family[2];
        current = current->family[2];
    }
    return current;
}

RBTree::Pnode RBTree::__GetNode(int k)
{
    Pnode current = root;
    while (current != nil)
    {
        if (current->key == k)
            break;
        else
            current = current->family[k > current->key];
    } 
    return current;
}

//direction = 0 左转,1 右转
void RBTree::__Rotate(Pnode x, int direction)
{
    Pnode y = x->family[!direction];
    x->family[!direction] = y->family[direction];
    if (y->family[direction])
        y->family[direction]->family[2] = x;
    y->family[2] = x->family[2];
    if (x->family[2] == nil)
        root = y;
    else
        x->family[2]->family[x == x->family[2]->family[1]] = y;
    x->family[2] = y;
    y->family[direction] = x;
}

void RBTree::__InsertFixup(Pnode n)
{
    int plr = 0;
    //如果n的父节点不为空，且父节点颜色为红色
    while (!n->family[2]->color)
    {
        //如果n的父节点是祖父节点的左节点，则plr = 0,反之为1
        plr = (n->family[2] == n->family[2]->family[2]->family[0] ? 0 : 1);
        //如果存在叔节点，且叔节点颜色为红,则将父节点和叔结点颜色变黑，当前节点成为祖节点且颜色变红.
        if ((n->family[2]->family[2]->family[!plr]) &&
            !(n->family[2]->family[2]->family[!plr]->color))
        {
            n = n->family[2]->family[2];
            n->color = 0;
            n->family[plr]->color = 1;
            n->family[!plr]->color = 1;
        }
        else {
            //如果n是左节点,则lr为0,反之为1
            int lr = n == n->family[2]->family[0] ? 0 : 1;
            //如果n是左节点，其父为右节点；或者n是右节点，其父为左节点
            if (lr + plr == 1)
            {
                n = n->family[2];
                __Rotate(n, !lr);
                //旋转后，n变为原来反方向的节点
                lr = !lr;
            }
            n = n->family[2]->family[2];
            __Rotate(n, !lr);
            n->color = 0;
            n->family[2]->color = 1;
            break;        
        }
    }
    root->color = 1;
}

void RBTree::Insert(int k)
{
    Pnode current = root;
    Pnode prev = nil;
    while (current != nil)
    {
        prev = current;
        if (k < current->key)
            current = current->family[0];
        else if (k > current->key)
            current = current->family[1];
        else {
            cout << k << " is already exist!!!
";
            return;
        }
    }
    Pnode new_node = new Node(k);
    new_node->family[0] = new_node->family[1] = nil;
    new_node->family[2] = prev;
    if (root == nil)
        root = new_node;
    else if (k < prev->key)
        prev->family[0] = new_node;
    else prev->family[1] = new_node;
    __InsertFixup(new_node);
}


void RBTree::__DeleteFixup(Pnode delNode)
{
    Pnode bakNode = delNode;
    while (delNode != root && delNode->color)
    {
        //delNode如果是左孩子lr = 0, 反之lr = 1,为便于思考，假定lr=0,即delNode为左孩子.
        int lr = delNode == delNode->family[2]->family[1];
        Pnode brother = delNode->family[2]->family[!lr];
        //如果兄弟结点颜色为红色，则其父结点和兄弟孩子的颜色必为黑,以父节点为轴左旋转重新着色后，delNode新兄弟结点颜色为黑
        if (!brother->color) {
            delNode->family[2]->color = 0;
            brother->color = 1;
            __Rotate(delNode->family[2], lr);
            brother = delNode->family[2]->family[!lr];
        }
        //如果兄弟左右孩子都为黑色,兄弟结点着红色,将父结点成为当前节点
        if (brother->family[0]->color && brother->family[1]->color) {
            brother->color = 0;
            delNode = delNode->family[2];
        }
        else {
            //如果兄弟右孩子为黑色
            if (brother->family[!lr]->color) {
                brother->color = 0;
                brother->family[lr]->color = 1;
                __Rotate(brother, !lr);
                brother = brother->family[2];
            }
            brother->color = brother->family[2]->color;
            brother->family[!lr]->color = 1;
            brother->family[2]->color = 1;
            __Rotate(brother->family[2], lr);
            break;
        }
    }
    delNode->color = 1;
    //删除节点,释放内存
    if (bakNode == root)
        root = nil;
    else if (bakNode == bakNode->family[2]->family[0])
        bakNode->family[2]->family[0] = nil;
    else 
        bakNode->family[2]->family[1] = nil;
    delete bakNode;
}

void RBTree::Delete(int k)
{
    Pnode delNode = __GetNode(k);
    if (delNode == nil) {
        cout << k << "is not exist, delete failed!
";
        return;
    }
    //如果有双子节点,找后继节点successor,则successor没有左子节点
    if(delNode->family[0] != nil && delNode->family[1] != nil)
    {
        Pnode successor = __GetNeighbor(delNode, 0);
        delNode->key = successor->key;
        delNode = successor;
    }
    //如果没子节点
    if (delNode->family[0] == nil && delNode->family[1] == nil) {
        __DeleteFixup(delNode);
    }
    //如果仅有单子节点,那么delNode必为黑色,且其独生子女为红色
    else{
        int lr = delNode->family[0] == nil;
        delNode->key = delNode->family[lr]->key;
        delete delNode->family[lr];
        delNode->family[lr] = nil;
    }
}

size_t RBTree::Size()
{
    return __NodeSize(root);
}

#define CRTDBG_MAP_ALLOC    
#include "stdafx.h"
#include <crtdbg.h>    
#include "RBTree.h"
#include <iostream>
#include <ctime>

using namespace std;
const int ASIZE = 10;
void LoadArrayToTree(RBTree & t, int * arr, int n);
void GetRandomArray(int * arr, int n);
void ShowArray(int * arr, int n);
void Show(RBTree & t);
void DeleteTree(RBTree &t, int * arr, int n);

int main()
{
    {
        srand(size_t(time(0)));
        int arr[ASIZE]{11,26,35,14,5,26,57,8,39,10};
        //int arr[ASIZE]{};
        //GetRandomArray(arr, ASIZE);
        ShowArray(arr, ASIZE);
        RBTree t;
        LoadArrayToTree(t, arr, ASIZE);
        Show(t);
        DeleteTree(t, arr, ASIZE);
        Show(t);
    }
    //内存泄露测试
    _CrtDumpMemoryLeaks();
    return 0;
}

//main test method
void LoadArrayToTree(RBTree & t, int * arr, int n)
{
    for (int i = 0; i < n; i++)
        t.Insert(arr[i]);
}

void DeleteTree(RBTree & t, int * arr, int n)
{
    for (int i = 0; i < n; i++) 
        t.Delete(arr[i]);        
}

void GetRandomArray(int * arr, int n)
{
    for (int i = 0; i < n; i++)
    {
        arr[i] = rand()%50000+1;
        //不重复数组
        /*int num = rand() % 50000 + 1;
        int j = 0;
        for (j = 0; j < i; j++)
        {
            if (arr[j] == num)
                break;
        }
        if (j == i)
            arr[i] = num;
        else --i;*/
    }
}

void ShowArray(int * arr, int n)
{
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
    cout << endl;
}

void Show(RBTree & t)
{
    cout << "
t.Size() = " << t.Size() << endl;
    cout << "********************List**********************
";
    t.ShowList();
    cout << "********************Tree**********************
";
    t.ShowTree();
    cout << "********************End***********************
";
    cout << endl;
}
// end of main test

 

 

红黑树添加PPT图 

旧金山大学官网的红黑树可视化在线模拟器

http://www.cs.usfca.edu/~galles/visualization/RedBlack.html