红黑树 (Red-Black Tree)

　　一棵高度为 h 的二叉查找树可以实现任何一种基本的动态集合操作, 如 SEARCH, PREDECESOR, SUCCESSOR, MINIMUM, MAXIMUM, INSERT, DELETE 等, 其时间都是 O(h). 这样, 当树的高度较低时, 这些操作就会执行的较快; 但是, 当树的高度较高时, 这些操作的性能可能不比用链表好. 红黑树(red-black tree)是许多"平衡的"查找树中的一种, 它能保证在最坏情况下, 基本的动态集合操作的时间为 O(lg n). 

　　红黑树是一种二叉查找树, 但在每个基点上增加一个存储位表示结点的颜色, 可以说是 RED 或 BLACK. 通过对任何一条从跟到叶子的路径上各个结点着色方式的限制, 红黑树确保没有一条路径会比其他路径长出两倍, 因而是接近平衡的.

 

红黑树的性质:
1) 每个结点或是 红的, 或是 黑的.
2) 根结点是黑的.
3) 每个 叶结点(NIL)是黑的.
4) 如果一个 结点是红的, 则它的 两个儿子是黑的.
5) 对每个结点, 从该结点到子孙结点的所有路径上包含相 同数目的黑结点.

头文件:

// RBTree.h
//

#ifndef RBTree_H
#define RBTree_H

#include < cstddef >

class RBTree
{
public :
enum Color{RED, BLACK} ;
struct Node
{
Color c ;
Node * p, * l, * r ;
int key ;

Node()
{
c = RED ;
p = l = r = NULL ;
key = 0 ;
}
} ;
public :
RBTree() ;
virtual ~ RBTree() ;
private :
RBTree( const RBTree & other) ;
RBTree & operator = ( const RBTree & other) ;

public :
// Interface
void Insert( int key) ;
void Del( int key) ;
void Preorder() ;
void Inorder() ;
Node * Search( int key) ;
public :
// logic
void lr(Node * p) ;
void rr(Node * p) ;
Node * successor(Node * p) ;
Node * search(Node * p, int key) ;
void insert(Node * root, Node * p) ;
void insert_fixup(Node * p) ;
void del(Node * root, Node * p) ;
void del_fixup(Node * p) ;

void preorder(Node * p) ;
void inorder(Node * p) ;

private :
// data
Node * root ;
Node * guard ;
} ;

template < class T >
inline void EXCHANGE(T & a, T & b)
{
T c(a) ;
a = b ;
b = c ;
}

#endif // RBTree_H

源文件:

// RBTree.cpp
//

#include " RBTree.h "
#include < iostream >
#include < cassert >
#include < limits >
using namespace std ;

RBTree::RBTree()
{
guard = new Node ;
guard -> p = guard -> l = guard -> r = guard ;
guard -> c = BLACK ;
guard -> key = numeric_limits < int > ::min() ;

root = guard ;
}
RBTree:: ~ RBTree()
{
delete guard ;
guard = NULL ;
}

// Interface
void RBTree::Insert( int key)
{
Node * p = new Node ;
p -> p = p -> l = p -> r = guard ;
p -> c = RED ;
p -> key = key ;

insert(root, p) ;
}
void RBTree::Del( int key)
{
del(root, Search(key)) ;
}

void RBTree::Preorder()
{
preorder(root) ;
}
void RBTree::Inorder()
{
inorder(root) ;
}
RBTree::Node * RBTree::Search( int key)
{
return search(root, key) ;
}


// logic
void RBTree::lr(Node * p)
{
// We can't rotate a null pointer or a guard
if (NULL == p || guard == p)
{
return ;
} // if

// 'p' must has right child
assert(p -> r) ;

// 'rChild' will become new rotating root
Node * parent = p -> p ;
Node * rChild = p -> r ;

// Connect 'rChild' with 'parent'
if (guard == parent)
{
root = p -> r ;
}
else
{
(p == parent -> l ? parent -> l : parent -> r) = rChild ;
} // if
rChild -> p = parent ;
// 'p' should take 'rChild' 's left child as its right child
p -> r = rChild -> l ;
rChild -> l -> p = p ;
// Put 'p' as 'rChild' 's left child
p -> p = rChild ;
rChild -> l = p ;
}
void RBTree::rr(Node * p)
{
// We can't rotate a null pointer or a guard
if (NULL == p || guard == p)
{
return ;
} // if

// 'p' must has right child
assert(p -> r) ;

// I abstrct the root rotating procedure
// Of course, this may be confuse at first sight
// I'm sure after reading and thinking over, you'd must know it worth -- reconstitution
Node *& r_c = p -> l ; // 'r_c' is the storage of rotate's child
Node *& r_c_c = p -> l -> r ; // 'r_c_c' is the storage of rotate's child's child
Node * parent = p -> p ; // 'parent' is the address of 'p' 's parent
Node * child = r_c ; // 'child' is the address of the rotate

// Connect 'parent' and new rotating root
child -> p = parent ;
if (guard == parent)
{
// If 'p' is root, we must set 'root' point to new rotating root
root = child ;
}
else
{
// If 'p' is not root,
// we should set the storage which to store address of 'p' point to new rotating root
(p == parent -> l ? parent -> l : parent -> r) = child ;
} // if
// Set 'p' 's child point to 'child' 's child which need to connect with other parent
r_c = r_c_c ;
guard == r_c_c ? guard : r_c_c -> p = p ;
// Rotate 'p' and 'child'
r_c_c = p ;
p -> p = child ;
}

RBTree::Node * RBTree::successor(Node * p)
{
assert(NULL != p) ;
// guard has no successor
if (guard == p)
{
return guard ;
}

if (guard == p -> r)
{
Node * parent = p -> p ;
while (guard != parent && p == parent -> r)
{
p = parent ;
parent = parent -> p ;
} // while

p = parent ;
}
else // guard != p->r
{
p = p -> r ;
while (guard != p -> l)
{
p = p -> l ;
} // while
} // if

return p ;
}

RBTree::Node * RBTree::search(Node * p, int key)
{
while (guard != p && key != p -> key)
{
p = key > p -> key ? p -> r : p -> l ;
} // while

return p ;
}

void RBTree::insert(Node * root_, Node * p)
{
Node * parent = root_ -> p ;
Node * cur = root_ ;
while (guard != cur)
{
parent = cur ;
cur = p -> key > cur -> key ? cur -> r : cur -> l ;
guard -> p = parent ;
} // while

p -> p = parent ;
if (guard == parent)
{
p -> c = BLACK ;
root = p ;
guard -> p = guard -> l = guard -> r = root ;
}
else
{
(p -> key < parent -> key ? parent -> l : parent -> r) = p ;
} // if

if (RED == parent -> c)
{
insert_fixup(p) ;
} // if
}

void RBTree::insert_fixup(Node * p)
{
// 'p' is always the red child who has a red parent
while (RED == p -> c && RED == p -> p -> c)
{
// 'ancestor' must be black
Node * ancestor = p -> p -> p ;
Node * parent = p -> p ;
if (parent == ancestor -> l)
{
Node * uncle = ancestor -> r ;

if (RED == uncle -> c)
{
// If 'p' 's uncle is red
// we transport the color of black parent down to its two children
// and move 'p' to its ancestor for the next collision if 'ancestor' 's parent is red either
ancestor -> c = RED ;
ancestor -> l -> c = ancestor -> r -> c = BLACK ;
p = ancestor ;
}
else
{
// If 'p' 's uncle is black
// we'd use 'ancestor' as root to right rotate,
// 'parent' will become new root of the sub tree after rotating
// and swap the color of 'p' 's parent with its parent('ancestor')
// but we must consider if 'p' is right of its parent
// in this situation, we should right rotate 'p' 's parent before right rotating
// lastly, we know that 'p' is always the red child who has a red parent
// so we reset 'p' after each rotating
if (parent -> r == p)
{
// 'p' is right child of its parent
lr(parent) ;
// Reset 'p' and 'parent' to new position
p = parent ;
parent = parent -> p ;
} // if
EXCHANGE(ancestor -> c, parent -> c) ;
rr(ancestor) ;
// Reset 'p' to the red child of a red parent
p = parent ;
// Here exit loop
} // if
}
else
{
// There are three cases needs fixing
// a) 'parent' and 'uncle' are red, while 'ancestor' is black
// b) 'parent' are red, while 'uncle' and 'ancestor' is black, 'p' is left child of 'parent'
// c) 'parent' are red, while 'uncle' and 'ancestor' is black, 'p' is right child of 'parent'
Node * uncle = ancestor -> l ;

// 'ancestor' must be black if exists
if (RED == uncle -> c)
{
// If a black 'ancestor' has two red children,
// we just exchange 'ancestor' 's color with it's two children
// and reset 'p' to 'ancestor' to asking upper level for solution
ancestor -> c = RED ;
parent -> c = uncle -> c = BLACK ;
p = ancestor ;
}
else // RED == uncle->c
{
// If a black 'ancestor' has a red left child and a black right child
// we should exchange 'ancestor' 's color with 'parent'
// and then do right rotating to rebalance the tree
// after those two operations, we solve the collision without impacting black high
// If 'p' is left child of its parent, we need do right rotating to
// switch into another structure without any other effect
// the new structure is a prepare for left rotating of 'ancestor'
if (parent -> l == p)
{
rr(parent) ;
p = parent ;
parent = parent -> p ;
} // if

EXCHANGE(ancestor -> c, parent -> c) ;
lr(ancestor) ;
} // if RED == uncle->c
} // if parent == ancestor->l
} // while

root -> c = BLACK ;
}

void RBTree::del(Node * root, Node * p)
{
// Can't delete guard node
if (guard == p)
{
return ;
} // if

// 'toDel' is the real node which will delete at last
Node * toDel = p ;
// 'toFix' is the position where 'toDel' originally site
Node * toFix = guard == toDel -> l ? toDel -> r : toDel -> l ;

// If 'p' has two children, we should delete its successor
if (guard != p -> l && guard != p -> r)
{
toDel = successor(p) ;
} // if

// Disconnect 'toDel' and connect 'parent' and 'child'
Node * child = guard == toDel -> l ? toDel -> r : toDel -> l ;
Node * parent = toDel -> p ;
child -> p = parent ;
if (guard == parent)
{
root = child ;
}
else
{
(parent -> l == toDel ? parent -> l : parent -> r) = child ;
} // if

if (p != toDel)
{
p -> key = toDel -> key ;
} // if

if (BLACK == toDel -> c)
{
cout << " fixing " << endl ;
del_fixup(toFix) ;
} // if

delete toDel ;
// toDel = NULL ; // Meaningless
}
void RBTree::del_fixup(Node * p)
{
//
Node * parent = p -> p ;
Node * brother = guard ;
Node * nephew = guard ; // 'brother's' left child
Node * niece = guard ; // 'brother's' right child

while (root != p && BLACK == p -> c)
{
// Every time we rotating, we just need reset 'p' to build relationship
// because all relationship depend on 'p'
if (parent -> l == p)
{
// Every condition branch is a point where to enter.
// only b) and d) is Exit Model
// it means when enter case a) or c), we must try to transform into case b) or d)

parent = p -> p ;
brother = parent -> r ;
nephew = brother -> l ;
niece = brother -> r ;

// We divide all cases into four
// a) 'brother' is red, it means parent must black and both 'nephew' and 'niece' are black
// b) 'brother' is black, while both 'nephew' and 'niece' are black
// c) 'brother' is black, 'nephew' is black but 'niece' is red
// d) 'brother' is black, 'niece' is red, no mater 'nephew' 's color
if (RED == brother -> c)
{
// BLACK == 'parent->c'
// BLACK == 'nephew->c'
// BLACK == 'niece->c'
// If 'brother' is red, we try to turn it into black
// we can't change its childrens' color
EXCHANGE(parent -> c, brother -> c) ;
lr(parent) ;
}
else if (BLACK == niece -> c && BLACK == nephew -> c)
{
// BLACK == 'brother->c'
// We can't solve problem in this level,
// so we abstract one level black from 'p' and 'brother'
// now, 'p' has only one black level and 'brother' turn into red
// and then, move 'p' to it's parent to expect solution
brother -> c = RED ;
p = parent ;
}
else if (BLACK == niece -> c)
{
// BLACK == 'brother->c'
// RED == 'newphew->c'
// We need it's niece be red
EXCHANGE(brother -> c, nephew -> c) ;
rr(brother) ;
}
else
{
// BLACK == 'brother->c'
// RED == 'niece->c'
// This is we wanted model,
// and this is the exit of loop
lr(parent) ;
EXCHANGE(parent -> c, brother -> c) ;
parent -> c = niece -> c = BLACK ;

// The loop will break out
p = brother ;
} // RED == brother->c
}
else // p->l != p
{
// I process case c) and d) together, bacause case c) should transform to case d)
// so, now we have enter point

parent = p -> p ;
brother = parent -> l ;
nephew = brother -> l ;
niece = brother -> r ;

// There are four cases
// a) 'brother' is RED, we need turn it into BLACK
// b) 'brother' and its two children are all BLACK, this case we can abstract
// BLACK from 'p' and 'brother',
// turning 'p' to 'parent' ask upper level for solution if 'parent' is BLACK either
// otherwise, draw 'parent' to BLACK to solve the problem
// c) 'brother' is BLACK, 'nephew' is BLACK but 'niece' is RED, we should use
// Equivalent Conversion to change into case d)
// d) 'brother' is BLACK, 'nephew' is RED. This is Exit Model
if (RED == brother -> c)
{
// This is a non-Exit Model, we try to switch it to Exit Model
// Case a)
EXCHANGE(parent -> c, brother -> c) ;
rr(parent) ;
}
else // RED != brother->c
{
// This is Exit Model
// Now, 'brother' 's color is BLACK
if (BLACK == nephew -> c && BLACK == niece -> c)
{
// Case b)
// In this case, may cause loop
// We decrease a layer of BLACK from 'brother' and 'p'
// Now, 'brother' turn into RED while 'p' has only one level BLACK
brother -> c = RED ;
// We set 'p' to 'parent'
// to put the extra BLACK to parent in order to keep balance
p = parent ;
}
else
{
if (BLACK == nephew -> c)
{
// Case c)
// We can turn this case into case d) for solution
EXCHANGE(brother -> c, niece -> c) ;
lr(brother) ;
// Reset 'brother' and 'nephew' and 'niece'
brother = parent -> l ;
nephew = brother -> l ;
niece = brother -> r ;
} // if BLACK == nephew->c

// Case d)
// After this rotating, loop will exit!
rr(parent) ;
// Reset all relationship
p = parent ;
parent = brother ;
brother = parent -> l ;
nephew = brother -> l ;
niece = brother -> r ;
parent -> c = p -> c ;
brother -> c = p -> c = BLACK ;

// Here exit loop
p = parent ;
} // if BLACK == nephew->c && BLACK == niece->c
} // if RED == brother->c
} // if p->l == p
} // while

p -> c = BLACK ;
}

void RBTree::preorder(Node * p)
{
if (guard != p)
{
preorder(p -> l) ;
cout << p -> key << " : " ;
cout << (RED == p -> c ? " Red " : " Black " ) ;
cout << endl ;
preorder(p -> r) ;
} // if
}
void RBTree::inorder(Node * p)
{
if (guard != p)
{
cout << p -> key << " : " ;
cout << (RED == p -> c ? " Red " : " Black " ) ;
cout << endl ;
inorder(p -> l) ;
inorder(p -> r) ;
} // if
}

转载于:https://www.cnblogs.com/walfud/archive/2011/05/17/2048602.html