二叉搜索树-红黑树

前面介绍了AVL树，虽然AVL树将二叉树的高度差保证在1，但是实现的太过复杂，因为要不断调整平衡因子。故而要来介绍另外一个用途比较广的结构-红黑树。

红黑树

先来看来红黑树的特性：

1、每个节点非红即黑

2、根节点为黑色

3、不能有连续的红节点

4、每条路径上的黑色节点数相等

5、空节点为黑色

先来想一个问题，红黑树的定义保证它最长路径不会超过最短路径的二倍，那么来想想为什么？

节点的结构

因为搜索结构在实际运用当中都是采用这种Key,Value模型，所以这里就先这样实现，后面对RBTree进行封装时，会做一些小的调整。

enum COLOUR{RED,BLACK};

template <class K,class V>
struct RBTreeNode
{
RBTreeNode<K, V>* _left;
RBTreeNode<K, V>* _right;
RBTreeNode<K, V>* _parent;//因为要涉及到调平衡，所以定义为三叉链
K _key;
V _value;
COLOUR _colour;//枚举类型的颜色属性，每一个节点非红即黑
};

插入

基本的插入和之前的普通搜索树，AVL树都是一样的，先找到待插入位置，然后进行插入即可，主要的不同就是在动态调整。

至于旋转的过程，红黑树和AVL树都是一样的。

插入时需要注意的是，第四条规则：每条路径上的黑色节点数相等，所以我们可以在初始化节点的时候直接默认是红色的节点，这样就可以避免冲突这条规则。

下面这段代码在实现普通搜索树，AVL树，红黑树都是一样的。

if (_root == NULL)//先判断空树的场景
{
Node* _root = new Node(key, value);
_root->_colour = BLACK;
return true;
}

Node* cur = _root;
Node* parent = NULL;
while (cur)
{
if (key < cur->_key)
{
parent = cur->_parent;
cur = cur->_left;
}
else if (key > cur->_key)
{
parent = cur;
cur = cur->_right;
}
else
{
assert(false);
}
}
//走到这里，找到待插入点
cur = new Node(key, value);
if (key < cur->_key)
{
parent->_left = cur;
cur->_parent = parent;
}
else if (key > cur->_key)
{
parent->_right = cur;
cur->_parent = parent;
}
//走到这里说明节点插入进入了，核心的思想就是下面要进行的动态调整

动态调整

下面图示中cur代表当前节点，parent/p代表父节点，uncle/u代表叔叔节点，grandfather/g代表祖父节点。

一共分三种情况：

一：叔叔存在且为红



如果是这种情况，直接将父节点和叔叔节点置为红色，也不需要进行旋转，至于为什么将祖父节点置为红色？

1、当前节点的祖父节点是根节点(程序的最后直接将整棵树的根置黑)

2、当前节点的祖父节点不是根

讨论不是根，如图：



二：叔叔不存在/存在为黑(cur为p的左)



这里的叔叔只要不是存在且为红，就不影响旋转。

以p为根进行一次右单旋(镜像式的左旋类似)，然后将p置为黑，g置为红

，因为以g为根的子树上的路径黑色节点个数并没有增加，故不用将旋转后的p在置为红继续向上调整。

三：叔叔不存在/存在为黑(cur为p的右)



仔细想一下，这里的第三种是先左旋转化为第二种，再进行左旋后，当前节点的cur和parent对应到第二种的结构中刚好是相反的，所以再进行左旋前/后，要将cur和parent两个节点进行swap，才能转化为第二种结构进行处理。

整个调整过程应该是一个循环来控制：

while(parent && parent->_color == RED);

再进行完动态调整后，最后直接了当将整棵树的根节点变为黑色，从而满足第一条性质。

如果对于旋转部分还不太了解可以先了解AVL树的实现部分，两部分的旋转逻辑一模一样

附上整个简单实现的代码：

#pragma once

#include<iostream>
#include<assert.h>
enum COLOUR{RED,BLACK};

template <class K,class V>
struct RBTreeNode
{
RBTreeNode(const K& key, const V& value)
: _left(NULL)
, _right(NULL)
, _parent(NULL)
, _key(key)
, _value(value)
, _colour(RED)
{}

RBTreeNode<K, V>* _left;
RBTreeNode<K, V>* _right;
RBTreeNode<K, V>* _parent;
K _key;
V _value;
COLOUR _colour;
};

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)
{
Node* _root = new Node(key, value);
_root->_colour = BLACK;
return true;
}

Node* cur = _root;
Node* parent = NULL;
while (cur)
{
if (key < cur->_key)
{
parent = cur->_parent;
cur = cur->_left;
}
else if (key > cur->_key)
{
parent = cur;
cur = cur->_right;
}
else
{
assert(false);
}
}
//走到这里，找到待插入点
cur = new Node(key, value);
if (key < cur->_key)
{
parent->_left = cur;
cur->_parent = parent;
}
else if (key > cur->_key)
{
parent->_right = cur;
cur->_parent = parent;
}

//动态调整节点
while (parent && parent->_colour == RED )
{
Node* grandfather = parent->_parent;
if (parent == grandfather->_left)
{
Node* uncle = grandfather->_right;
if (uncle && uncle->_colour == RED)
{
parent->_colour = uncle->_colour = BLACK;
grandfather->_colour = RED;

cur = grandfather;
parent = cur->_parent;
}
else
{
if (cur == parent->_right)
{
//BUG  第一次旋转后改变了parent和cur的位置，导致第二次旋转后颜色设置错误
std::swap(parent, cur);
RotateL(parent);
}
RotateR(grandfather);
grandfather->_colour = RED;
parent->_colour = BLACK;
break;
}
}
else
{
Node* uncle = grandfather->_left;
if (uncle && uncle->_colour == RED)
{
parent->_colour = uncle->_colour = BLACK;
grandfather->_colour = RED;

cur = grandfather;
parent = cur->_parent;
}
else
{
if (cur == parent->_left)
{
std::swap(parent, cur);
RotateR(parent);
}
RotateL(grandfather);
grandfather->_colour = RED;
parent->_colour = BLACK;
break;
}
}
}
_root->_colour = BLACK;
return true;
}

bool CheckBalance()
{
size_t k = 0;
if (NULL == _root)
return true;

if (RED == _root->_colour)
{
std::cout << "根节点为红" << " ";
return false;
}

size_t BlankCount = 0;
Node* cur = _root;
while (cur)
{
if (BLACK == cur->_colour)
{
BlankCount++;
cur = cur->_left;
}
}

_CheckBalance(_root,BlankCount,k);
}

void RotateL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_right;
Node* pparent = parent->_parent;

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

while (NULL == pparent)
{
_root = subR;
subR->_parent = NULL;
}
if (parent == pparent->_left)
pparent->_left = subR;
else if (parent == pparent->_right)
pparent->_right = subR;

subR->_parent = pparent;

parent = subR;
}

void RotateR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
Node* pparent = parent->_parent;

parent->_left = subLR;
if (subLR)
{
subLR->_parent = parent;
}
subL->_right = parent;
parent->_parent = subL;
while (NULL == pparent)
{
_root = subL;
subL->_parent = NULL;
}
if (parent == pparent->_left)
parent->_left = subL;
else if (parent == pparent->_right)
parent->_right = subL;

subL->_parent = pparent;
parent = subL;
}

bool _CheckBalance(Node* root, size_t BlankCount, size_t k)
{
if (NULL == root)
return true;
if (BLACK == root->_colour)
k++;
Node* parent = root->_parent;
if (root->_colour == RED && parent->_colour == RED)
{
std::cout << "相邻的红节点" << " ";
return false;
}

if (root->_left == NULL && root->_right == NULL)
{
if (k != BlankCount)
{
std::cout << "黑色数量不相等" << " ";
return false;
}

return true;
}

return (_CheckBalance(root->_left, BlankCount, k) && _CheckBalance(root->_right, BlankCount, k));
}
private:
Node* _root;
};