红黑树的C++实现

在实现之前网上浏览了一下,看到很多人都有自己的实现.主要的实现方式都是受了Introduction to Algorithm的影响.代码的结构和书中给出的伪码如出一辙,但是问题大都是1,没有深刻的理解FixUp和到底哪个节点需要. 2,忽略了Sentinel也就是哨兵节点的存在的意义.C/C++实现中的NULL在指代上还是出现了一点偏差.

这里我们比较关心插入和删除操作(查询和普通的BST没有差别,不赘述了)
现在我们来具体分析一下插入操作
1. 首先父亲节点如果是黑色节点的话,不需要处理了,多一个红色节点不会有任何影响.
2. 如果父亲节点是红色的,而叔父节点也是红色,那就是把父亲和叔父节点同时改成黑色,然后递归的向上传递.
3. 如果父亲节点是红色的,而叔父节点是黑色的. 后面的话比较拗口.父亲是祖父的左孩子.
(1)如果自己是父亲的左孩子,那么修改父亲和祖父的颜色然后右转祖父
(2)如果自己是父亲的有孩子,那么先做左转父亲,在把自己指向父亲,执行(1).
类似的描述很多地方都有,这个过程也是比较清晰,所以不存在什么错误.而且比较清楚的问题就是需要FixUp的就是当前新加入的节点.

问题呢集中体现在删除的地方.这个是网上看到的一个实现,这里一样,也遵循了算法导论中的命名方式:p,x,y分别有了自己的定义:
RBTreeNode *p = NULL; //指向查找到的节点(实际上可能并不删除它)
RBTreeNode *x = NULL; //指向欲删除的节点(可能和p一样)
RBTreeNode *y = NULL; //指向欲删除节点的子节点(欲删除节点只有一个子节点)
但是在很多情况下y都是NULL,(当然实际意义上是哨兵节点啦). 所以看到很多代码选择了FixUp X节点的父亲节点.但实际上
这个意义其实是完全不一样的 我们来看一个我碰到的具体的例子就很明白了,一棵树在插入了1-20以后呈现出这样的形态



比如我现在要删除10这个节点,那么显然p就是10这个节点,而x是什么的,x就是max(p->left)或者min(p->right).现在这个例子中就是9或者11,我们假定选择9.而y是什么呢就是9的子节点(也即是我们说的哨兵节点).那这个时候需要FixUp的节点是什么呢??



由网上的一些实现看来是
if (y != NULL)
{
DeleteFixup(y);
}
else
{
DeleteFixup(x->parent);
}
X的父亲,也就是10这个节点,这样的话,兄弟节点的右子节点为红色,直接进入了Delete Case4做改色(12改成黑色,16红色18黑色),然后左旋转12.这个时候我们发现,转了以后并不平衡,显然违反了红黑树的定义,在12-9-11这个分支上有连续3个黑色节点,显然多余了其他的12-14-13和12-14-15. 而造成这一切的元凶就是FixUp的错误的开始.



其实一样,我们还是应该按照定义来,还是从y开始更新,但是y表面上看起来是NULL,怎么FixUp呢?这个时候哨兵节点的作用得以体现,我们把每个叶子节点的left/right都指向一个哨兵节点,哨兵节点的颜色是黑色,而且left/right就是NULL,这样我们就可以用这个哨兵节点来做FixUp了.同时省去了在Fixup中冗余的NULL的判断,这里的指针就一直是有效的了.所以在这个case中我们实际上下一个w就是右边的黑色哨兵节点,所以x和w都是黑色,所以进入了deleteFixUp的case2,只有把11改成了红色之后才继续向上递归的FixUp.这个实现其实给我很多的感触.人的烦恼有很多,但无非是生活是复杂的,你把他想简单了,或者生活是简单的,你把他想复杂了:)

最后要说一点,在插入和删除操作有会有可能导致红黑树出现不平衡的情况,这个时候需要FixUp,但是最合理的实现是在操作结束后加入一段debug assert的代码用以检查平衡度的正确性,至少可以避免明显错误的尴尬:)
最后给出了所有的代码:

#pragma once
#ifdef MY_DEBUG
#include <queue>
#include "assert.h"
#endif //MY_DEBUG
namespace ScanbuyLib{
enum rg_color  { black, red } ;
enum e_balance { left_higher, equal_height, right_higher };
enum e_return  { e_success, e_fail, e_empty, e_duplicate, e_not_found };
enum e_order   { e_preorder, e_inorder, e_postorder };
template <class K, class V> class RBTreeNode
{
public:
RBTreeNode(rg_color color = black);
RBTreeNode(const K& key, const V& value, rg_color color= black);
public:
RBTreeNode<K,V>* m_pRChild;
RBTreeNode<K,V>* m_pLChild;
RBTreeNode<K,V>* m_pParent;
K key;
V value;
rg_color color;
};
template<class K, class V> RBTreeNode<K, V>::RBTreeNode(rg_color color)
{
m_pRChild = NULL;
m_pLChild = NULL;
m_pParent = NULL;
//		key = K(0);
//		value = V(0);
this->color = color;
}
template<class K, class V>RBTreeNode<K, V>::RBTreeNode(const K& key, const V& value, rg_color color)
{
m_pRChild = NULL;
m_pLChild = NULL;
m_pParent = NULL;
this->key = key;
this->value = value;
this->color = color;
}
template <class K, class V> class RedBlackTree
{
public:
RedBlackTree();
~RedBlackTree();
e_return insert(const K& key, const V& value);
e_return remove(const K& key);
e_return search(const K& key, V& value); // value as output
private:

void destroy(RBTreeNode<K, V>* pNode);
// make copy constructor and = operator private currently.
RedBlackTree(const RedBlackTree&);
RedBlackTree& operator = (const RedBlackTree& other);

RBTreeNode<K, V>* getGrandParent(RBTreeNode<K, V>* pNode);
RBTreeNode<K, V>* getUncle(RBTreeNode<K, V>* pNode);
RBTreeNode<K, V>* getSibling(RBTreeNode<K, V>* pNode);
#ifdef MY_DEBUG
bool checkCorrectNess();
#endif //MY_DEBUG
void insertFixup(RBTreeNode<K, V>* pNode);
void removeFixup(RBTreeNode<K, V>* pNode);
void rotateLeft (RBTreeNode<K, V>* pNode);
void rotateRight(RBTreeNode<K, V>* pNode);
RBTreeNode<K, V>* m_pRoot;
RBTreeNode<K, V>* m_pSentinel;
};

template <class K, class V>RedBlackTree<K, V>::RedBlackTree()
{
// first instantiate the sentinel node, then make it root as sentinel
m_pSentinel = new RBTreeNode<K,V>();
m_pSentinel->m_pLChild = NULL;
m_pSentinel->m_pRChild = NULL;
m_pSentinel->m_pParent = NULL;
m_pSentinel->color = black;
m_pRoot = m_pSentinel;
}
template <class K, class V>RedBlackTree<K, V>::~RedBlackTree()
{
// TODO, need to add it once really use it!!!!
destroy(m_pRoot);
if (m_pSentinel)
{
delete m_pSentinel;
m_pSentinel = NULL;
}
}

template <class K, class V>  void RedBlackTree<K, V>::destroy(RBTreeNode<K, V>* pNode)
{
if (pNode != NULL && pNode != m_pSentinel)
{
destroy(pNode->m_pLChild);
destroy(pNode->m_pRChild);
delete pNode;
pNode = NULL;
}
}
template <class K, class V>  RBTreeNode<K, V>* RedBlackTree<K, V>::getGrandParent(RBTreeNode<K, V>* pNode)
{
if (pNode && pNode->m_pParent)
return pNode->m_pParent->m_pParent;
else
return NULL;
}
template <class K, class V> RBTreeNode<K, V>* RedBlackTree<K, V>::getUncle(RBTreeNode<K, V>* pNode)
{
RBTreeNode<K, V>* pTemp = getGrandParent(pNode);
if (pTemp == NULL)
return NULL; // No grandparent means no uncle
if (pNode->m_pParent == pTemp->m_pLChild)
return pTemp->m_pRChild;
else
return pTemp->m_pLChild;
}
template<class K, class V> RBTreeNode<K, V>* RedBlackTree<K, V>::getSibling(RBTreeNode<K, V>* pNode)
{
if (pNode == NULL || pNode->m_pParent == NULL) return NULL;
if (pNode == pNode->m_pParent->m_pLChild)
return pNode->m_pParent->m_pRChild;
else
return pNode->m_pParent->m_pLChild;
}

template <class K, class V> void RedBlackTree<K, V>::rotateLeft(RBTreeNode<K, V>* pNode)
{
if (pNode == NULL || pNode->m_pRChild == NULL)
return;
else
{
RBTreeNode<K,V>* pTemp = pNode->m_pRChild;
pNode->m_pRChild = pTemp->m_pLChild;
if (pTemp->m_pLChild)
pTemp->m_pLChild->m_pParent = pNode;
if (pNode == m_pRoot)
{
m_pRoot = pTemp;
pTemp->m_pParent = NULL;
}
else
{
pTemp->m_pParent= pNode->m_pParent;
if (pNode == pNode->m_pParent->m_pLChild)
{
pNode->m_pParent->m_pLChild = pTemp;
}
else
{
pNode->m_pParent->m_pRChild = pTemp;
}
}
pTemp->m_pLChild = pNode;
pNode->m_pParent = pTemp;
}
}
template <class K, class V> void RedBlackTree<K, V>::rotateRight(RBTreeNode<K, V>* pNode)
{
if (pNode == NULL || pNode->m_pLChild == NULL)
return;
else
{
RBTreeNode<K,V>* pTemp = pNode->m_pLChild;
pNode->m_pLChild = pTemp->m_pRChild;
if (pTemp->m_pRChild)
pTemp->m_pRChild->m_pParent = pNode;
if (pNode == m_pRoot)
{
m_pRoot = pTemp;
pTemp->m_pParent = NULL;
}
else
{
//update the parent
pTemp->m_pParent= pNode->m_pParent;
if (pNode == pNode->m_pParent->m_pLChild)
{
pNode->m_pParent->m_pLChild = pTemp;
}
else
{
pNode->m_pParent->m_pRChild = pTemp;
}
}
pTemp->m_pRChild = pNode;
pNode->m_pParent = pTemp;
}
}
template <class K, class V> e_return RedBlackTree<K, V>::insert(const K& key, const V& value)
{
RBTreeNode<K, V>* pTemp = m_pRoot;
RBTreeNode<K, V>* pParent = NULL;
// init the new node here
RBTreeNode<K, V>* pNew = new RBTreeNode<K, V>(key, value);
pNew->color = red;
pNew->m_pLChild = m_pSentinel;
pNew->m_pRChild = m_pSentinel;
// find the insert point
while (pTemp != m_pSentinel)
{
pParent = pTemp;
if (pTemp->key == key)
{
delete pNew;
return e_duplicate;
}
pTemp = pTemp->key > key ? pTemp->m_pLChild: pTemp->m_pRChild;
}
if (m_pRoot == m_pSentinel)
{
m_pRoot = pNew;
m_pRoot->m_pParent = NULL;
}
else
{
pNew->m_pParent = pParent;
if ( pParent->key > key )
{
pParent->m_pLChild= pNew;
}
else
{
pParent->m_pRChild= pNew;
}
}
insertFixup(pNew);
//		insertCase1(pNew);
#ifdef MY_DEBUG
assert(checkCorrectNess());
#endif//MY_DEBUG
return e_success;
}
template <class K, class V> void RedBlackTree<K,V>::insertFixup(RBTreeNode<K, V>* pNode)
{
if (pNode == NULL) return; // impossible actually.
RBTreeNode<K,V>* pUncle = m_pSentinel;
RBTreeNode<K,V>* pGrandParent = NULL;
while (pNode != m_pRoot && red == pNode->m_pParent->color)
{
pUncle = getUncle(pNode);
pGrandParent = getGrandParent(pNode);
if (pUncle != m_pSentinel && pUncle->color == red)
{
pNode->m_pParent->color = black;
pUncle->color = black;
pGrandParent->color = red;
pNode = pGrandParent;
}
else
{
if (pNode->m_pParent == pGrandParent->m_pLChild)
{
if (pNode == pNode->m_pParent->m_pRChild)
{
pNode = pNode->m_pParent;
rotateLeft(pNode);
}
pNode->m_pParent->color = black;
pGrandParent->color = red;
rotateRight(pGrandParent);
}
else
{
if (pNode == pNode->m_pParent->m_pLChild)
{
pNode = pNode->m_pParent;
rotateRight(pNode);
}
pNode->m_pParent->color = black;
pGrandParent->color = red;
rotateLeft(pGrandParent);
}
}
}
m_pRoot->color = black;
}
template <class K, class V> e_return RedBlackTree<K,V>::remove(const K& key)
{
// currently we won't use the
if (!m_pRoot) return e_empty;
RBTreeNode<K,V>* pd = m_pRoot; // pd means pointer to the node deleted (with the same data with param:data)
while (pd != m_pSentinel)
{
if (pd->key > key)
pd = pd->m_pLChild;
else if (pd->key < key)
pd = pd->m_pRChild;
else
break; // equal so we find it!!!
}
if (pd == m_pSentinel) //haven't find it
return e_not_found;
// delete is not the real node to delete, but find a sub to replace and remove the sub
RBTreeNode<K,V>* pSub = NULL; // pSub is the really node to be sub
// we can either find the max left child or min right child to sub
// let's choose max left child here
if (pd->m_pLChild == m_pSentinel && pd->m_pRChild == m_pSentinel)
pSub = pd;
else if (pd->m_pLChild == m_pSentinel)
pSub = pd->m_pRChild;
else if (pd->m_pRChild == m_pSentinel)
pSub = pd->m_pLChild;
else
{
pSub = pd->m_pLChild;
// let's find the max left child
while (pSub->m_pRChild != m_pSentinel)
{
pSub = pSub->m_pRChild;
}
}
// replace the pd data with pSub's
if (pd != pSub)
{
pd->key = pSub->key;
pd->value = pSub->value;
}
// then find the child of sub and replace with sub
RBTreeNode<K,V>* pSubChild = pSub->m_pRChild != m_pSentinel ? pSub->m_pRChild: pSub->m_pLChild;
if (pSub->m_pParent)
{
if (pSub == pSub->m_pParent->m_pLChild)
pSub->m_pParent->m_pLChild = pSubChild;
else
pSub->m_pParent->m_pRChild = pSubChild;
}
else
{
m_pRoot = pSubChild;
}
//this may change the sentinel's parent to not-null value, will change to NULL later
pSubChild->m_pParent = pSub->m_pParent;
if (pSub->color == black)
removeFixup(pSubChild);
if (pSub)
{
delete pSub;
pSub = NULL;
}
// rollback sentinel's parent to NULL;
m_pSentinel->m_pParent = NULL;
#ifdef MY_DEBUG
assert(checkCorrectNess());
#endif //MY_DEBUG
return e_success;
}
template <class K, class V> void RedBlackTree<K,V>::removeFixup(RBTreeNode<K,V>* pNode)
{
RBTreeNode<K,V>* pSibling = NULL;
while ((pNode != m_pRoot) && (pNode->color == black))
{
pSibling = getSibling(pNode);
if (pNode == pNode->m_pParent->m_pLChild) // left child node
{
if (pSibling->color == red)
{
// case 1, can change to case 2, 3, 4
pNode->m_pParent->color = red;
pSibling->color = black;
rotateLeft(pNode->m_pParent);
// change to new sibling,
pSibling = pNode->m_pParent->m_pRChild;
}
// case 2;
if ((black == pSibling->m_pLChild->color) && (black == pSibling->m_pRChild->color))
{
pSibling->color = red;
pNode = pNode->m_pParent;
}
else
{
if (black == pSibling->m_pRChild->color)
{
pSibling->color = red;
pSibling->m_pLChild->color = black;
rotateRight(pSibling);
pSibling = pNode->m_pParent->m_pRChild;
}
pSibling->color = pNode->m_pParent->color;
pNode->m_pParent->color = black;
pSibling->m_pRChild->color = black;
rotateLeft(pNode->m_pParent);
break;
}
}
else
{
if (pSibling->color == red)
{
// case 1, can change to case 2, 3, 4
pNode->m_pParent->color = red;
pSibling->color = black;
rotateRight(pNode->m_pParent);
// change to new sibling,
pSibling = pNode->m_pParent->m_pLChild;
}
// case 2;
if ((black == pSibling->m_pLChild->color) && (black == pSibling->m_pRChild->color))
{
pSibling->color = red;
pNode = pNode->m_pParent;
}
else
{
if (black == pSibling->m_pLChild->color)
{
pSibling->color = red;
pSibling->m_pRChild->color = black;
rotateLeft(pSibling);
pSibling = pNode->m_pParent->m_pLChild;
}
pSibling->color = pNode->m_pParent->color;
pNode->m_pParent->color = black;
pSibling->m_pLChild->color = black;
rotateRight(pNode->m_pParent);
break;
}
}
}
pNode->color = black;
}

template <class K, class V> e_return RedBlackTree<K,V>::search(const K& key, V& value) // value as output
{
if (!m_pRoot) return e_empty;

RBTreeNode<K,V>* pTemp = m_pRoot;
while (pTemp != m_pSentinel)
{
if (pTemp->key < key)
pTemp = pTemp->m_pRChild;
else if (pTemp->key > key)
pTemp = pTemp->m_pLChild;
else
break;
}
if (pTemp != m_pSentinel)
{
//find it now!
value = pTemp->value;
return e_success;
}
else
{
return e_not_found;
}
}
#ifdef MY_DEBUG
template <class K, class V>bool RedBlackTree<K,V>::checkCorrectNess()
{
if (!m_pRoot)
return true;
bool bRet = true;
// check if the root color is black
if (m_pRoot && m_pRoot->color == red)
bRet = false;
// check red node with black child
std::queue< RBTreeNode<K,V>* > oQueue;
oQueue.push( m_pRoot );
int nCurLevelCount = 1;
int length = -1;
while (true)
{
int nNextLevelCount     = 0;
while (nCurLevelCount)
{
RBTreeNode<K,V>* pNode = oQueue.front();
nCurLevelCount -- ;
if(pNode->color == red)
{
// child color is black
if ((pNode->m_pLChild && pNode->m_pLChild->color == red) ||
(pNode->m_pRChild && pNode->m_pRChild->color == red))
{
bRet = false;
break;
}
}
if ( !pNode->m_pLChild && !pNode->m_pRChild)
{
// this is the leaf node, check the path root
int len = 0;
RBTreeNode<K,V>* pTemp = pNode;
while (pTemp->m_pParent)
{
if (pTemp->color == black)
len ++ ;
pTemp = pTemp->m_pParent;
}
if (length == -1)
length = len;
else
{
if (len != length)
{
bRet = false;
break;
}
}
}
if (pNode->m_pLChild)
{
oQueue.push( pNode->m_pLChild );
nNextLevelCount++;
}
if (pNode->m_pRChild)
{
oQueue.push( pNode->m_pRChild );
nNextLevelCount++;
}
oQueue.pop();
}
if (!bRet)
break;
nCurLevelCount = nNextLevelCount;
if (!nCurLevelCount)
break;
}
return bRet;
}
#endif //MY_DEBUG
}