高效的平衡搜索树——红黑树

红黑树是每个节点都带有颜色属性的二叉查找树，颜色或红色或黑色。在二叉查找树强制一般要求以外，对于任何有效的红黑树我们增加了如下的额外要求:

性质1. 节点是红色或黑色。

性质2. 根节点是黑色。

性质3 每个叶节点是黑色的。

性质4 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点)

红黑树的插入分为以下三种情况

第一种情况：

cur为红节点，parent为红节点，grandfather为黑节点，uncle存在且为红
变换:将parent改为黑节点，grandfather改为红节点，然后把grandfather当成cur，并且向上调整



第二种情况:

cur为红节点，parent为红节点，grandfather为黑节点，uncle不存在/uncle为红节点
变换:（1）parent为grandfather的左孩子，cur为parent的左孩子，则进行右单旋转
（2）parent为grandfather的右孩子，cur为parent的右孩子，则进行左单旋转
最后，将parent变为黑节点，将grandfather变为红节点



第三种情况:

cur为红节点，parent为红节点，grandfather为黑节点，uncle不存在/uncle为黑节点
变换:（1）parent为grandfather的左孩子，cur为parent的右孩子，则针对parent进行左单旋转
（2）parent为grandfather的右孩子，cur为parent的左孩子，则针对parent进行右单旋转
此时情况变成了情况2，可以按照情况2的办法来处理



变色后出现的情况讨论



关于红黑树中用到的旋转图解





下面是代码分析：

"RBTree.h"

#pragma once

enum Colour
{
RED,
BLACK,
};

template<class K,class V>
class RBTreeNode
{
public:
RBTreeNode(const K& key,const V& value)
:_left(NULL)
,_right(NULL)
,_parent(NULL)
,_key(key)
,_value(value)
,_col(RED)
{}
public:
//定义一个三叉链
RBTreeNode<K,V>* _left;//左孩子
RBTreeNode<K,V>* _right;//右孩子
RBTreeNode<K,V>* _parent;//父亲

K _key;
V _value;
Colour _col;
};

template<class K,class V>
class RBTree
{
typedef RBTreeNode<K,V> Node;
public:
RBTree()
:_root(NULL)
{}
bool Insert(const K& key,const V& value)
{
if (_root == NULL)
{
_root = new Node(key,value);
//只有一个节点时是根节点，红黑树中根节点的颜色是黑色的
_root->_col = BLACK;
return true;
}

//插入节点，搜索二叉树节点的插入
Node* cur = _root;
Node* parent = NULL;
while (cur)
{
if (cur->_key > key)
{
parent = cur;
cur = cur->_left;
}
else if(cur->_key < key)
{
parent = cur;
cur = cur->_right;
}
else
{
return false;
}
}
cur = new Node(key,value);
if (parent->_key > key)
{
parent->_left = cur;
cur->_parent = parent;
}
else//parent->_key < key
{
parent->_right = cur;
cur->_parent = parent;
}

while ((cur != _root) && (parent->_col == RED))//保证了grandfher的存在
{
Node* grandfather = parent->_parent;
if (grandfather->_left == parent)
{
Node* uncle = grandfather->_right;
//情况1  见下图
if ((uncle) && (uncle->_col == RED))
{
parent->_col = uncle->_col = BLACK;
grandfather->_col = RED;
cur = grandfather;
parent = cur->_parent;
}
else
{
//情况3  见下图
if (cur == parent->_right)
{
_RotateL(parent);
swap(parent,cur);
}
//情况2   见下图
parent->_col = BLACK;
grandfather->_col = RED;
_RotateR(grandfather);

break;
}
}
else //grandfather->_right == parent
{
Node* uncle = parent->_left;
//情况1  见下图
if ((uncle) && (uncle->_col == RED))
{
parent->_col = uncle->_col = BLACK;
grandfather->_col = RED;
cur = grandfather;
parent = cur->_parent;
}
else
{
//情况3  见下图
if (parent->_left == cur)
{
_RotateR(parent);
swap(parent,cur);
}
//情况3
parent->_col = BLACK;
grandfather->_col = RED;
_RotateL(grandfather);

break;
}
}
_root->_col = BLACK;//记得每次调整完成后，整课二叉树的根节点的颜色要调成黑色
//此时才满足二叉树的性质
}
}
void InOrder()
{
_InOrder(_root);
cout<<endl;
}
bool IsBlance()
{
//满足一棵红黑树的性质
//1.根节点是黑色的
//2.没有连续的红节点
//3、每条路径上的黑色节点数目相同
//4、最长路径不超过最短路径的两倍

if (_root == NULL)
{
//空数也满足红黑树的性质
return true;
}
if (_root->_col == RED)
{
//违背了性质的第一条
return false;
}

int k = 0;
Node* cur = _root;
while (cur)
{
if (cur->_col == BLACK)
{
k++;
}
//求出任意一条路径的黑色节点数量
cur = cur->_left;
}
int count = 0;

return _IsBlance(_root,k,count);
}
private:
bool _IsBlance(Node* root,const int k,int count)
{
if (root == NULL)
{
//空树满足红黑树的性质
return true;
}
return _IsBlance(root->_left,k,count)
&& _IsBlance(root->_right,k,count);

if ((root->_col == RED) && (root->_parent->_col == RED))
{
cout<<root->_key<<"  有连续的红节点"<<endl;
return false;
}

if (root->_col == BLACK)
{
++count;
}

if ((root->_left == NULL)
&& (root->_right == NULL)
&& (k != count))
{
cout<<root->_key<<"  路径上的黑色节点数目不相同"<<endl;
return false;
}
}
void _RotateL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
Node* ppNode = parent->_parent;

parent->_right = subRL;
if (subRL)
{
subRL->_parent = parent;
}
subR->_left = parent;
parent->_parent = subR;

if (ppNode == NULL)
{
_root = subR;
subR->_parent = NULL;
}
else  //ppNode != NULL
{
if (ppNode->_left == parent)
{
ppNode->_left = subR;
}
else  //ppNode->_right == parent
{
ppNode->_right = subR;
}

subR->_parent = ppNode;
}
}
void _RotateR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
Node* ppNode = parent->_parent;

parent->_left = subLR;
if (subLR)
{
subLR->_parent = parent;
}
subL->_right = parent;
parent->_parent = subL;

if (ppNode == NULL)
{
_root = subL;
subL->_parent = NULL;
}
else
{
if (ppNode->_left == parent)
{
ppNode->_left = subL;
}
else //ppNode->_right == parent
{
ppNode->_right = subL;
}

subL->_parent = ppNode;
}
}
void _InOrder(Node* root)
{
if (root == NULL)
{
return;
}

_InOrder(root->_left);
cout<<root->_key<<" ";
_InOrder(root->_right);
}
private:
Node* _root;
};

"test.cpp"

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;
#include "RBTree.h"

void Test()
{
RBTree<int,int> rbt;
//int arr[] = {16,3,7,11,9,26,18,14,15};
int arr[] = {48,12,56,32,99,11,10,78,22};
int size = sizeof(arr)/sizeof(arr[0]);

for (int i = 0;i < size;i++)
{
rbt.Insert(arr[i],i);
cout<<"IsBlance? "<<rbt.IsBlance()<<endl;
}
rbt.InOrder();
cout<<"IsBlance? "<<rbt.IsBlance()<<endl;
}

int main()
{
Test();
system("pause");
return 0;
}