红黑树的C++实现（1）

三年前磕磕盼盼用C语言写过红黑树，这段时间用C++重写了红黑树，修复了之前代码中的一些错误。记得以前的博客里面就写过使用C++写红黑树更容易些，因为可以重用二叉搜索树的C++代码。照例，首先实现二叉搜索树，然后再实现红黑树。

首先，定义二叉树结点的类，btnode.h：

#ifndef __BTNODE_H__
#define __BTNODE_H__
#include <stdexcept>
#include <typeinfo>

using std::logic_error;

template <typename T>
struct CBinaryTreeNode
{
enum eColor {
RED,
BLACK
};

CBinaryTreeNode(const T& val, CBinaryTreeNode<T>* parent = NULL, CBinaryTreeNode<T>* left = NULL, CBinaryTreeNode<T>* right = NULL, eColor color = RED);
virtual ~CBinaryTreeNode();

virtual bool operator==(const CBinaryTreeNode<T>& node);
virtual bool operator<(const CBinaryTreeNode<T>& node);
virtual bool operator>(const CBinaryTreeNode<T>& node);

T key;
CBinaryTreeNode<T> *parent;
CBinaryTreeNode<T> *left;
CBinaryTreeNode<T> *right;

eColor color;
};

template <typename T>
CBinaryTreeNode<T>::CBinaryTreeNode(const T& val, CBinaryTreeNode<T>* parent, CBinaryTreeNode<T>* left, CBinaryTreeNode<T>* right, eColor color)
{
key = val;
this->parent = parent;
this->left = left;
this->right = right;
this->color = color;
}

template<typename T>
CBinaryTreeNode<T>::~CBinaryTreeNode()
{

}

template <typename T>
bool CBinaryTreeNode<T>::operator==(const CBinaryTreeNode<T>& node)
{
if (typeid(*this) != typeid(node))
throw logic_error("diffrent type objects.");

return this->key == node.key;
}

template <typename T>
bool CBinaryTreeNode<T>::operator<(const CBinaryTreeNode<T>& node)
{
if (typeid(*this) != typeid(node))
throw logic_error("diffrent type objects.");

return this->key < node.key;
}

template <typename T>
bool CBinaryTreeNode<T>::operator>(const CBinaryTreeNode<T>& node)
{
if (typeid(*this) != typeid(node))
throw logic_error("diffrent type objects.");

return this->key > node.key;
}

#endif

然后，定义二叉搜索树的类，bst.h：

#ifndef __BST_H__
#define __BST_H__
#include <iostream>
#include "btnode.h"

using std::cout;
using std::endl;

template <typename T>
class CBinarySortTree
{
public:
CBinarySortTree();
~CBinarySortTree() {}

virtual CBinaryTreeNode<T>* Insert(const T& key);
virtual void Delete(CBinaryTreeNode<T>** del);
virtual CBinaryTreeNode<T>* Search(const T& key) const;
virtual CBinaryTreeNode<T>* Search(CBinaryTreeNode<T>* node, const T& key) const;
virtual void InorderWalk() const;

protected:
CBinaryTreeNode<T>* SearchMinOnRightChild(CBinaryTreeNode<T>* val);
CBinaryTreeNode<T>* Transplant(CBinaryTreeNode<T>* u, CBinaryTreeNode<T>* v);
void InorderWalk(const CBinaryTreeNode<T>* root) const;

CBinaryTreeNode<T>* root;
static CBinaryTreeNode<T> sentinel;
};

template <typename T>
CBinaryTreeNode<T> CBinarySortTree<T>::sentinel(0, &sentinel, &sentinel, &sentinel, CBinaryTreeNode<T>::BLACK);

template <typename T>
CBinarySortTree<T>::CBinarySortTree()
{
root = &sentinel;
root->parent = &sentinel;
root->left = &sentinel;
root->right = &sentinel;
}

template <typename T>
CBinaryTreeNode<T>* CBinarySortTree<T>::Insert(const T& key)
{
CBinaryTreeNode<T> *p = NULL;

if (root == &sentinel) {
p = new CBinaryTreeNode<T>(key, &sentinel, &sentinel, &sentinel);
root = p;
} else {
p = root;
CBinaryTreeNode<T> *parent = &sentinel;
CBinaryTreeNode<T> *node = new CBinaryTreeNode<T>(key, &sentinel, &sentinel, &sentinel);

while (p != &sentinel) {
parent = p;

if (*p < *node)
p = p->right;
else
p = p->left;
}

node->parent = parent;
if (*parent < *node)
parent->right = node;
else
parent->left = node;

p = node;
}

return p;
}

template <typename T>
CBinaryTreeNode<T>* CBinarySortTree<T>::SearchMinOnRightChild(CBinaryTreeNode<T>* node)
{
while (node->left != &sentinel)
node = node->left;

return node;
}

template <typename T>
CBinaryTreeNode<T>* CBinarySortTree<T>::Transplant(CBinaryTreeNode<T>* u, CBinaryTreeNode<T>* v)
{
CBinaryTreeNode<T>* d = NULL;

if (u->parent == &sentinel) {
d = root;
root = v;
} else {
d = u;
if (u == u->parent->left)
u->parent->left = v;
else
u->parent->right = v;
}

v->parent = u->parent;

return d;
}

template <typename T>
void CBinarySortTree<T>::Delete(CBinaryTreeNode<T>** del)
{
CBinaryTreeNode<T>* node = *del;
CBinaryTreeNode<T>* n = &sentinel;

if (node->left == &sentinel && node->right == &sentinel) {
CBinaryTreeNode<T>* parent = node->parent;

if (parent != &sentinel) {
if (parent->left == node)
parent->left = &sentinel;
else
parent->right = &sentinel;
} else {
*del = &sentinel;
root = &sentinel;
}

delete node;
} else if (node->left == &sentinel && node->right != &sentinel) {
n = Transplant(node, node->right);
delete n;
} else if (node->left != &sentinel && node->right == &sentinel) {
n = Transplant(node, node->left);
delete n;
} else {
n = SearchMinOnRightChild(node->right);

if (n->parent != node) {
Transplant(n, n->right);
n->right = node->right;
n->right->parent = n;
}

CBinaryTreeNode<T>* temp = Transplant(node, n);
n->left = node->left;
n->left->parent = n;

delete temp;
}
}

template <typename T>
CBinaryTreeNode<T>* CBinarySortTree<T>::Search(CBinaryTreeNode<T>* node, const T& key) const
{
if (node != &sentinel) {
CBinaryTreeNode<T> n(key);

if (*node < n)
return Search(node->right, key);
else if (*node > n)
return Search(node->left, key);
else
return node;
}

return NULL;
}

template <typename T>
CBinaryTreeNode<T>* CBinarySortTree<T>::Search(const T& key) const
{
return Search(root, key);
}

template <typename T>
void CBinarySortTree<T>::InorderWalk() const
{
InorderWalk(root);
}

template <typename T>
void CBinarySortTree<T>::InorderWalk(const CBinaryTreeNode<T>* node) const
{
const CBinaryTreeNode<T>* p = node;

if (p != &sentinel) {
InorderWalk(p->left);
cout << p->key << ' ';
InorderWalk(p->right);
}
}
#endif

测试二叉搜索树的代码，bst_test.cpp：

#include "bst.h"

int main(int argc, const char **argv)
{
int key[] = { 12, 1, 9, 2, 0, 11, 7, 19, 4, 15, 18, 5, 14, 13, 10, 16, 6, 3, 8, 17 };

CBinarySortTree<int> bst;

cout << "original key: ";
for (size_t i = 0; i < sizeof(key) / sizeof(int); ++i)
cout << key[i] << ' ';

cout << endl;
for (size_t i = 0; i < sizeof(key) / sizeof(int); ++i)
bst.Insert(key[i]);

cout << "after insertion: ";
bst.InorderWalk();
cout << endl;

for (size_t i = 0; i < sizeof(key) / sizeof(int); ++i) {
CBinaryTreeNode<int>* del = bst.Search(key[i]);
if (del) {
cout << "after " << i + 1 << " time(s) deletion: ";
bst.Delete(&del);
bst.InorderWalk();
cout << endl;
}
}

return 0;
}

红黑树重用了大多数二叉树的接口，将在下一篇介绍。