641 lines
14 KiB
C++
641 lines
14 KiB
C++
|
#include "RedBlackTree.h"
|
||
|
|
#include <limits>
|
||
|
|
#include "PtrList.h"
|
||
|
|
|
||
|
|
#ifdef min
|
||
|
|
#undef min
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#ifdef max
|
||
|
|
#undef max
|
||
|
|
#endif
|
||
|
|
|
||
|
|
void RedBlackTreeIterator::next()
|
||
|
|
{
|
||
|
|
if (node)
|
||
|
|
node = tree->GetSuccessorOf(node);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool RedBlackTreeIterator::get(RedBlackTreeIterator::val_t *val)
|
||
|
|
{
|
||
|
|
if (node)
|
||
|
|
{
|
||
|
|
*val = node->GetEntry();
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
RedBlackTreeNode::RedBlackTreeNode()
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
RedBlackTreeNode::RedBlackTreeNode(key_t _key, val_t newEntry)
|
||
|
|
: storedEntry(newEntry) , key(_key)
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
RedBlackTreeNode::~RedBlackTreeNode()
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
RedBlackTreeNode::val_t RedBlackTreeNode::GetEntry() const
|
||
|
|
{
|
||
|
|
return storedEntry;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
RedBlackTree::RedBlackTree()
|
||
|
|
{
|
||
|
|
nil = new RedBlackTreeNode;
|
||
|
|
nil->left = nil->right = nil->parent = nil;
|
||
|
|
nil->red = 0;
|
||
|
|
nil->key = std::numeric_limits<key_t>::min();
|
||
|
|
nil->storedEntry = NULL;
|
||
|
|
|
||
|
|
root = new RedBlackTreeNode;
|
||
|
|
root->parent = root->left = root->right = nil;
|
||
|
|
root->key = std::numeric_limits<key_t>::max();
|
||
|
|
root->red=0;
|
||
|
|
root->storedEntry = NULL;
|
||
|
|
|
||
|
|
numElements = 0;
|
||
|
|
}
|
||
|
|
RedBlackTreeIterator RedBlackTree::end()
|
||
|
|
{
|
||
|
|
RedBlackTreeIterator temp;
|
||
|
|
return temp;
|
||
|
|
}
|
||
|
|
|
||
|
|
RedBlackTreeIterator RedBlackTree::begin()
|
||
|
|
{
|
||
|
|
return RedBlackTreeIterator(root->left, this);
|
||
|
|
}
|
||
|
|
/***********************************************************************/
|
||
|
|
/* FUNCTION: LeftRotate */
|
||
|
|
/**/
|
||
|
|
/* INPUTS: the node to rotate on */
|
||
|
|
/**/
|
||
|
|
/* OUTPUT: None */
|
||
|
|
/**/
|
||
|
|
/* Modifies Input: this, x */
|
||
|
|
/**/
|
||
|
|
/* EFFECTS: Rotates as described in _Introduction_To_Algorithms by */
|
||
|
|
/* Cormen, Leiserson, Rivest (Chapter 14). Basically this */
|
||
|
|
/* makes the parent of x be to the left of x, x the parent of */
|
||
|
|
/* its parent before the rotation and fixes other pointers */
|
||
|
|
/* accordingly. */
|
||
|
|
/***********************************************************************/
|
||
|
|
|
||
|
|
void RedBlackTree::LeftRotate(RedBlackTreeNode* x)
|
||
|
|
{
|
||
|
|
RedBlackTreeNode* y;
|
||
|
|
|
||
|
|
/* I originally wrote this function to use the sentinel for */
|
||
|
|
/* nil to avoid checking for nil. However this introduces a */
|
||
|
|
/* very subtle bug because sometimes this function modifies */
|
||
|
|
/* the parent pointer of nil. This can be a problem if a */
|
||
|
|
/* function which calls LeftRotate also uses the nil sentinel */
|
||
|
|
/* and expects the nil sentinel's parent pointer to be unchanged */
|
||
|
|
/* after calling this function. For example, when DeleteFixUP */
|
||
|
|
/* calls LeftRotate it expects the parent pointer of nil to be */
|
||
|
|
/* unchanged. */
|
||
|
|
|
||
|
|
y=x->right;
|
||
|
|
x->right=y->left;
|
||
|
|
|
||
|
|
if (y->left != nil) y->left->parent=x; /* used to use sentinel here */
|
||
|
|
/* and do an unconditional assignment instead of testing for nil */
|
||
|
|
|
||
|
|
y->parent=x->parent;
|
||
|
|
|
||
|
|
/* instead of checking if x->parent is the root as in the book, we */
|
||
|
|
/* count on the root sentinel to implicitly take care of this case */
|
||
|
|
if (x == x->parent->left)
|
||
|
|
{
|
||
|
|
x->parent->left=y;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
x->parent->right=y;
|
||
|
|
}
|
||
|
|
y->left=x;
|
||
|
|
x->parent=y;
|
||
|
|
|
||
|
|
#ifdef CHECK_RB_TREE_ASSUMPTIONS
|
||
|
|
CheckAssumptions();
|
||
|
|
#elif defined(DEBUG_ASSERT)
|
||
|
|
Assert(!nil->red,"nil not red in RedBlackTree::LeftRotate");
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
/***********************************************************************/
|
||
|
|
/* FUNCTION: RighttRotate */
|
||
|
|
/**/
|
||
|
|
/* INPUTS: node to rotate on */
|
||
|
|
/**/
|
||
|
|
/* OUTPUT: None */
|
||
|
|
/**/
|
||
|
|
/* Modifies Input?: this, y */
|
||
|
|
/**/
|
||
|
|
/* EFFECTS: Rotates as described in _Introduction_To_Algorithms by */
|
||
|
|
/* Cormen, Leiserson, Rivest (Chapter 14). Basically this */
|
||
|
|
/* makes the parent of x be to the left of x, x the parent of */
|
||
|
|
/* its parent before the rotation and fixes other pointers */
|
||
|
|
/* accordingly. */
|
||
|
|
/***********************************************************************/
|
||
|
|
|
||
|
|
void RedBlackTree::RightRotate(RedBlackTreeNode* y)
|
||
|
|
{
|
||
|
|
RedBlackTreeNode* x;
|
||
|
|
|
||
|
|
/* I originally wrote this function to use the sentinel for */
|
||
|
|
/* nil to avoid checking for nil. However this introduces a */
|
||
|
|
/* very subtle bug because sometimes this function modifies */
|
||
|
|
/* the parent pointer of nil. This can be a problem if a */
|
||
|
|
/* function which calls LeftRotate also uses the nil sentinel */
|
||
|
|
/* and expects the nil sentinel's parent pointer to be unchanged */
|
||
|
|
/* after calling this function. For example, when DeleteFixUP */
|
||
|
|
/* calls LeftRotate it expects the parent pointer of nil to be */
|
||
|
|
/* unchanged. */
|
||
|
|
|
||
|
|
x=y->left;
|
||
|
|
y->left=x->right;
|
||
|
|
|
||
|
|
if (nil != x->right) x->right->parent=y; /*used to use sentinel here */
|
||
|
|
/* and do an unconditional assignment instead of testing for nil */
|
||
|
|
|
||
|
|
/* instead of checking if x->parent is the root as in the book, we */
|
||
|
|
/* count on the root sentinel to implicitly take care of this case */
|
||
|
|
x->parent=y->parent;
|
||
|
|
if (y == y->parent->left)
|
||
|
|
{
|
||
|
|
y->parent->left=x;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
y->parent->right=x;
|
||
|
|
}
|
||
|
|
x->right=y;
|
||
|
|
y->parent=x;
|
||
|
|
|
||
|
|
#ifdef CHECK_RB_TREE_ASSUMPTIONS
|
||
|
|
CheckAssumptions();
|
||
|
|
#elif defined(DEBUG_ASSERT)
|
||
|
|
Assert(!nil->red,"nil not red in RedBlackTree::RightRotate");
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
/***********************************************************************/
|
||
|
|
/* FUNCTION: TreeInsertHelp */
|
||
|
|
/**/
|
||
|
|
/* INPUTS: z is the node to insert */
|
||
|
|
/**/
|
||
|
|
/* OUTPUT: none */
|
||
|
|
/**/
|
||
|
|
/* Modifies Input: this, z */
|
||
|
|
/**/
|
||
|
|
/* EFFECTS: Inserts z into the tree as if it were a regular binary tree */
|
||
|
|
/* using the algorithm described in _Introduction_To_Algorithms_ */
|
||
|
|
/* by Cormen et al. This funciton is only intended to be called */
|
||
|
|
/* by the Insert function and not by the user */
|
||
|
|
/***********************************************************************/
|
||
|
|
|
||
|
|
void RedBlackTree::TreeInsertHelp(RedBlackTreeNode* z)
|
||
|
|
{
|
||
|
|
/* This function should only be called by RedBlackTree::Insert */
|
||
|
|
RedBlackTreeNode* x;
|
||
|
|
RedBlackTreeNode* y;
|
||
|
|
|
||
|
|
z->left=z->right=nil;
|
||
|
|
y=root;
|
||
|
|
x=root->left;
|
||
|
|
while (x != nil)
|
||
|
|
{
|
||
|
|
y=x;
|
||
|
|
if (x->key > z->key)
|
||
|
|
{
|
||
|
|
x=x->left;
|
||
|
|
}
|
||
|
|
else /* x->key <= z->key */
|
||
|
|
{
|
||
|
|
x=x->right;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
z->parent=y;
|
||
|
|
if ((y == root) ||
|
||
|
|
(y->key > z->key))
|
||
|
|
{
|
||
|
|
y->left=z;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
y->right=z;
|
||
|
|
}
|
||
|
|
|
||
|
|
#if defined(DEBUG_ASSERT)
|
||
|
|
Assert(!nil->red,"nil not red in RedBlackTree::TreeInsertHelp");
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
RedBlackTreeIterator RedBlackTree::Search(key_t key)
|
||
|
|
{
|
||
|
|
RedBlackTreeNode* x;
|
||
|
|
|
||
|
|
x=root->left;
|
||
|
|
while (x != nil)
|
||
|
|
{
|
||
|
|
if (x->key > key)
|
||
|
|
{
|
||
|
|
x=x->left;
|
||
|
|
}
|
||
|
|
else if (x->key < key)
|
||
|
|
{
|
||
|
|
x=x->right;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
return RedBlackTreeIterator(x, this);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return end();
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Before calling InsertNode the node x should have its key set */
|
||
|
|
|
||
|
|
/***********************************************************************/
|
||
|
|
/* FUNCTION: InsertNode */
|
||
|
|
/**/
|
||
|
|
/* INPUTS: newEntry is the entry to insert*/
|
||
|
|
/**/
|
||
|
|
/* OUTPUT: This function returns a pointer to the newly inserted node */
|
||
|
|
/* which is guarunteed to be valid until this node is deleted. */
|
||
|
|
/* What this means is if another data structure stores this */
|
||
|
|
/* pointer then the tree does not need to be searched when this */
|
||
|
|
/* is to be deleted. */
|
||
|
|
/**/
|
||
|
|
/* Modifies Input: tree */
|
||
|
|
/**/
|
||
|
|
/* EFFECTS: Creates a node node which contains the appropriate key and */
|
||
|
|
/* info pointers and inserts it into the tree. */
|
||
|
|
/***********************************************************************/
|
||
|
|
|
||
|
|
RedBlackTreeIterator RedBlackTree::Insert(key_t _key, val_t newEntry)
|
||
|
|
{
|
||
|
|
RedBlackTreeNode * y;
|
||
|
|
RedBlackTreeNode * x;
|
||
|
|
RedBlackTreeNode * newNode;
|
||
|
|
|
||
|
|
x = new RedBlackTreeNode(_key, newEntry);
|
||
|
|
TreeInsertHelp(x);
|
||
|
|
newNode = x;
|
||
|
|
x->red=1;
|
||
|
|
while (x->parent->red) /* use sentinel instead of checking for root */
|
||
|
|
{
|
||
|
|
if (x->parent == x->parent->parent->left)
|
||
|
|
{
|
||
|
|
y=x->parent->parent->right;
|
||
|
|
if (y->red)
|
||
|
|
{
|
||
|
|
x->parent->red=0;
|
||
|
|
y->red=0;
|
||
|
|
x->parent->parent->red=1;
|
||
|
|
x=x->parent->parent;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (x == x->parent->right)
|
||
|
|
{
|
||
|
|
x=x->parent;
|
||
|
|
LeftRotate(x);
|
||
|
|
}
|
||
|
|
x->parent->red=0;
|
||
|
|
x->parent->parent->red=1;
|
||
|
|
RightRotate(x->parent->parent);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else /* case for x->parent == x->parent->parent->right */
|
||
|
|
{
|
||
|
|
/* this part is just like the section above with */
|
||
|
|
/* left and right interchanged */
|
||
|
|
y=x->parent->parent->left;
|
||
|
|
if (y->red)
|
||
|
|
{
|
||
|
|
x->parent->red=0;
|
||
|
|
y->red=0;
|
||
|
|
x->parent->parent->red=1;
|
||
|
|
x=x->parent->parent;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (x == x->parent->left)
|
||
|
|
{
|
||
|
|
x=x->parent;
|
||
|
|
RightRotate(x);
|
||
|
|
}
|
||
|
|
x->parent->red=0;
|
||
|
|
x->parent->parent->red=1;
|
||
|
|
LeftRotate(x->parent->parent);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
root->left->red=0;
|
||
|
|
numElements++;
|
||
|
|
return RedBlackTreeIterator(newNode, this);
|
||
|
|
|
||
|
|
#ifdef CHECK_RB_TREE_ASSUMPTIONS
|
||
|
|
CheckAssumptions();
|
||
|
|
#elif defined(DEBUG_ASSERT)
|
||
|
|
Assert(!nil->red,"nil not red in RedBlackTree::Insert");
|
||
|
|
Assert(!root->red,"root not red in RedBlackTree::Insert");
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
RedBlackTree::~RedBlackTree()
|
||
|
|
{
|
||
|
|
RedBlackTreeNode * x = root->left;
|
||
|
|
nu::PtrList<RedBlackTreeNode> stuffToFree;
|
||
|
|
|
||
|
|
if (x != nil)
|
||
|
|
{
|
||
|
|
if (x->left != nil)
|
||
|
|
{
|
||
|
|
stuffToFree.push_back(x->left);
|
||
|
|
}
|
||
|
|
if (x->right != nil)
|
||
|
|
{
|
||
|
|
stuffToFree.push_back(x->right);
|
||
|
|
}
|
||
|
|
// delete x->storedEntry;
|
||
|
|
delete x;
|
||
|
|
while (!stuffToFree.empty())
|
||
|
|
{
|
||
|
|
x = stuffToFree.back();
|
||
|
|
stuffToFree.pop_back();
|
||
|
|
if (x->left != nil)
|
||
|
|
{
|
||
|
|
stuffToFree.push_back(x->left);
|
||
|
|
}
|
||
|
|
if (x->right != nil)
|
||
|
|
{
|
||
|
|
stuffToFree.push_back(x->right);
|
||
|
|
}
|
||
|
|
// delete x->storedEntry;
|
||
|
|
delete x;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
delete nil;
|
||
|
|
delete root;
|
||
|
|
}
|
||
|
|
|
||
|
|
void RedBlackTree::DeleteFixUp(RedBlackTreeNode* x)
|
||
|
|
{
|
||
|
|
RedBlackTreeNode * w;
|
||
|
|
RedBlackTreeNode * rootLeft = root->left;
|
||
|
|
|
||
|
|
while ((!x->red) && (rootLeft != x))
|
||
|
|
{
|
||
|
|
if (x == x->parent->left)
|
||
|
|
{
|
||
|
|
w=x->parent->right;
|
||
|
|
if (w->red)
|
||
|
|
{
|
||
|
|
w->red=0;
|
||
|
|
x->parent->red=1;
|
||
|
|
LeftRotate(x->parent);
|
||
|
|
w=x->parent->right;
|
||
|
|
}
|
||
|
|
if ((!w->right->red) && (!w->left->red))
|
||
|
|
{
|
||
|
|
w->red=1;
|
||
|
|
x=x->parent;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (!w->right->red)
|
||
|
|
{
|
||
|
|
w->left->red=0;
|
||
|
|
w->red=1;
|
||
|
|
RightRotate(w);
|
||
|
|
w=x->parent->right;
|
||
|
|
}
|
||
|
|
w->red=x->parent->red;
|
||
|
|
x->parent->red=0;
|
||
|
|
w->right->red=0;
|
||
|
|
LeftRotate(x->parent);
|
||
|
|
x=rootLeft; /* this is to exit while loop */
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else /* the code below is has left and right switched from above */
|
||
|
|
{
|
||
|
|
w=x->parent->left;
|
||
|
|
if (w->red)
|
||
|
|
{
|
||
|
|
w->red=0;
|
||
|
|
x->parent->red=1;
|
||
|
|
RightRotate(x->parent);
|
||
|
|
w=x->parent->left;
|
||
|
|
}
|
||
|
|
if ((!w->right->red) && (!w->left->red))
|
||
|
|
{
|
||
|
|
w->red=1;
|
||
|
|
x=x->parent;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (!w->left->red)
|
||
|
|
{
|
||
|
|
w->right->red=0;
|
||
|
|
w->red=1;
|
||
|
|
LeftRotate(w);
|
||
|
|
w=x->parent->left;
|
||
|
|
}
|
||
|
|
w->red=x->parent->red;
|
||
|
|
x->parent->red=0;
|
||
|
|
w->left->red=0;
|
||
|
|
RightRotate(x->parent);
|
||
|
|
x=rootLeft; /* this is to exit while loop */
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
x->red=0;
|
||
|
|
|
||
|
|
#ifdef CHECK_RB_TREE_ASSUMPTIONS
|
||
|
|
CheckAssumptions();
|
||
|
|
#elif defined(DEBUG_ASSERT)
|
||
|
|
Assert(!nil->red,"nil not black in RedBlackTree::DeleteFixUp");
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
void RedBlackTree::Delete(RedBlackTree::key_t key)
|
||
|
|
{
|
||
|
|
RedBlackTreeIterator itr = Search(key);
|
||
|
|
DeleteNode(itr.node);
|
||
|
|
}
|
||
|
|
|
||
|
|
/***********************************************************************/
|
||
|
|
/* FUNCTION: DeleteNode */
|
||
|
|
/**/
|
||
|
|
/* INPUTS: tree is the tree to delete node z from */
|
||
|
|
/**/
|
||
|
|
/* OUTPUT: returns the RedBlackEntry stored at deleted node */
|
||
|
|
/**/
|
||
|
|
/* EFFECT: Deletes z from tree and but don't call destructor */
|
||
|
|
/**/
|
||
|
|
/* Modifies Input: z */
|
||
|
|
/**/
|
||
|
|
/* The algorithm from this function is from _Introduction_To_Algorithms_ */
|
||
|
|
/***********************************************************************/
|
||
|
|
|
||
|
|
RedBlackTree::val_t RedBlackTree::DeleteNode(RedBlackTreeNode * z)
|
||
|
|
{
|
||
|
|
RedBlackTreeNode* y;
|
||
|
|
RedBlackTreeNode* x;
|
||
|
|
val_t returnValue = z->storedEntry;
|
||
|
|
|
||
|
|
y= ((z->left == nil) || (z->right == nil)) ? z : GetSuccessorOf(z);
|
||
|
|
x= (y->left == nil) ? y->right : y->left;
|
||
|
|
if (root == (x->parent = y->parent)) /* assignment of y->p to x->p is intentional */
|
||
|
|
{
|
||
|
|
root->left=x;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (y == y->parent->left)
|
||
|
|
{
|
||
|
|
y->parent->left=x;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
y->parent->right=x;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (y != z) /* y should not be nil in this case */
|
||
|
|
{
|
||
|
|
|
||
|
|
#ifdef DEBUG_ASSERT
|
||
|
|
Assert((y!=nil),"y is nil in DeleteNode \n");
|
||
|
|
#endif
|
||
|
|
/* y is the node to splice out and x is its child */
|
||
|
|
|
||
|
|
y->left=z->left;
|
||
|
|
y->right=z->right;
|
||
|
|
y->parent=z->parent;
|
||
|
|
z->left->parent=z->right->parent=y;
|
||
|
|
if (z == z->parent->left)
|
||
|
|
{
|
||
|
|
z->parent->left=y;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
z->parent->right=y;
|
||
|
|
}
|
||
|
|
if (!(y->red))
|
||
|
|
{
|
||
|
|
y->red = z->red;
|
||
|
|
DeleteFixUp(x);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
y->red = z->red;
|
||
|
|
delete z;
|
||
|
|
#ifdef CHECK_RB_TREE_ASSUMPTIONS
|
||
|
|
CheckAssumptions();
|
||
|
|
#elif defined(DEBUG_ASSERT)
|
||
|
|
Assert(!nil->red,"nil not black in RedBlackTree::Delete");
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (!(y->red)) DeleteFixUp(x);
|
||
|
|
delete y;
|
||
|
|
#ifdef CHECK_RB_TREE_ASSUMPTIONS
|
||
|
|
CheckAssumptions();
|
||
|
|
#elif defined(DEBUG_ASSERT)
|
||
|
|
Assert(!nil->red,"nil not black in RedBlackTree::Delete");
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
numElements--;
|
||
|
|
return returnValue;
|
||
|
|
}
|
||
|
|
|
||
|
|
size_t RedBlackTree::size() const
|
||
|
|
{
|
||
|
|
return numElements;
|
||
|
|
}
|
||
|
|
|
||
|
|
/***********************************************************************/
|
||
|
|
/* FUNCTION: GetPredecessorOf */
|
||
|
|
/**/
|
||
|
|
/* INPUTS: x is the node to get predecessor of */
|
||
|
|
/**/
|
||
|
|
/* OUTPUT: This function returns the predecessor of x or NULL if no */
|
||
|
|
/* predecessor exists. */
|
||
|
|
/**/
|
||
|
|
/* Modifies Input: none */
|
||
|
|
/**/
|
||
|
|
/* Note: uses the algorithm in _Introduction_To_Algorithms_ */
|
||
|
|
/***********************************************************************/
|
||
|
|
|
||
|
|
RedBlackTreeNode *RedBlackTree::GetPredecessorOf(RedBlackTreeNode * x) const
|
||
|
|
{
|
||
|
|
RedBlackTreeNode* y;
|
||
|
|
|
||
|
|
if (nil != (y = x->left)) /* assignment to y is intentional */
|
||
|
|
{
|
||
|
|
while (y->right != nil) /* returns the maximum of the left subtree of x */
|
||
|
|
{
|
||
|
|
y=y->right;
|
||
|
|
}
|
||
|
|
return(y);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
y=x->parent;
|
||
|
|
while (x == y->left)
|
||
|
|
{
|
||
|
|
if (y == root) return(nil);
|
||
|
|
x=y;
|
||
|
|
y=y->parent;
|
||
|
|
}
|
||
|
|
return(y);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/***********************************************************************/
|
||
|
|
/* FUNCTION: GetSuccessorOf */
|
||
|
|
/**/
|
||
|
|
/* INPUTS: x is the node we want the succesor of */
|
||
|
|
/**/
|
||
|
|
/* OUTPUT: This function returns the successor of x or NULL if no */
|
||
|
|
/* successor exists. */
|
||
|
|
/**/
|
||
|
|
/* Modifies Input: none */
|
||
|
|
/**/
|
||
|
|
/* Note: uses the algorithm in _Introduction_To_Algorithms_ */
|
||
|
|
/***********************************************************************/
|
||
|
|
|
||
|
|
RedBlackTreeNode *RedBlackTree::GetSuccessorOf(RedBlackTreeNode * x) const
|
||
|
|
{
|
||
|
|
RedBlackTreeNode* y;
|
||
|
|
|
||
|
|
if (nil != (y = x->right)) /* assignment to y is intentional */
|
||
|
|
{
|
||
|
|
while (y->left != nil) /* returns the minium of the right subtree of x */
|
||
|
|
{
|
||
|
|
y=y->left;
|
||
|
|
}
|
||
|
|
return(y);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
y=x->parent;
|
||
|
|
while (x == y->right) /* sentinel used instead of checking for nil */
|
||
|
|
{
|
||
|
|
x=y;
|
||
|
|
y=y->parent;
|
||
|
|
}
|
||
|
|
if (y == root) return(nil);
|
||
|
|
return(y);
|
||
|
|
}
|
||
|
|
}
|