private void adjustTreeColour(RBTNode <T> node)
{
if (node == root)
{
node.colour = true;
return;
}
if (node.parent != root)
{
RBTNode <T> p = node.parent;
RBTNode <T> u = (p.parent.left == p) ? p.parent.right : p.parent.left;
if (!p.colour)
{
if (u != null && !u.colour)
{
p.colour = true;
u.colour = true;
p.parent.colour = false;
adjustTreeColour(p.parent);
}
}
}
}
private void rotateRight(RBTNode <T> x)
{
// Create node y to be the right node of x (x and y will be the nodes being rotated left)
RBTNode <T> y = x.left;
x.left = y.right;
if (x.left != null)
{
x.left.parent = x;
}
y.parent = x.parent;
if (x.parent == null)
{
root = y;
}
else if (x.parent.left == x)
{
x.parent.left = y;
}
else
{
x.parent.right = y;
}
x.parent = y;
y.right = x;
}
public void delete(T data)
{
RBTNode <T> nodeToDelete = root;
while (nodeToDelete != null && nodeToDelete.data.CompareTo(data) != 0)
{
nodeToDelete = (nodeToDelete.data.CompareTo(data) == -1) ? nodeToDelete.left : nodeToDelete.right;
}
if (nodeToDelete == null)
{
return;
}
RBTNode <T> successor;
if (nodeToDelete.left == null && nodeToDelete.right == null)
{
successor = null;
}
else if (nodeToDelete.left != null && nodeToDelete.right != null)
{
successor = nodeToDelete.right;
while (successor.left != null)
{
successor = successor.left;
}
nodeToDelete.data = successor.data;
nodeToDelete = successor;
if (nodeToDelete.right == null)
{
successor = null;
}
else
{
successor = nodeToDelete.right;
}
}
else
{
successor = (nodeToDelete.left == null) ? nodeToDelete.right : nodeToDelete.left;
}
if (!successor.colour || !nodeToDelete.colour)
{
successor.colour = true;
}
if (successor != null)
{
successor.left = root.left;
successor.right = root.right;
}
nodeToDelete = successor;
if (nodeToDelete != root)
{
handleDoubleBlack(nodeToDelete);
}
}
private void doubleBlackRecolour(RBTNode <T> node)
{
RBTNode <T> s = (node.parent.left == node) ? node.parent.right : node.parent.left;
if (s.colour && s.left.colour && s.right.colour)
{
s.colour = false;
if (s.parent.colour)
{
doubleBlackRecolour(s.parent);
}
}
}
private void handleDoubleBlack(RBTNode <T> node)
{
RBTNode <T> s = (node.parent.left == node) ? node.parent.right : node.parent.left;
if (!s.colour)
{
if (node.parent.left == s)
{
rotateRight(node.parent);
}
else
{
rotateLeft(node.parent);
}
doubleBlackRecolour(node);
}//else if(s.colour)
}
public bool exists(T data)
{
RBTNode <T> curNode = root;
while (curNode != null)
{
if (data.CompareTo(curNode.data) == -1)
{
curNode = curNode.left;
}
else if (data.CompareTo(curNode.data) == 1)
{
curNode = curNode.right;
}
else if (data.CompareTo(curNode.data) == 0)
{
return(true);
}
}
return(false);
}
public void insert(T data)
{
RBTNode <T> node = new RBTNode <T>(data);
node.colour = false;
if (root == null)
{
root = node;
node.colour = true;
return;
}
RBTNode <T> curNode = root;
while (node < curNode && curNode.left != null || node > curNode && curNode.right != null)
{
curNode = (node < curNode) ? curNode.left : curNode.right;
}
if (node < curNode)
{
curNode.left = node;
}
else
{
curNode.right = node;
}
node.parent = curNode;
if (node.parent != root)
{
RBTNode <T> p = node.parent;
RBTNode <T> u = (p.parent.left == p) ? p.parent.right : p.parent.left;
if (u == null || u.colour)
{
if (node.parent.parent.left == node.parent)
{
if (node.parent.left == node)
{
leftLeftAdjust(node);
}
else
{
rotateLeft(p);
leftLeftAdjust(p);
}
}
else
if (node.parent.right == node)
{
rightRightAdjust(node);
}
else
{
rotateRight(p);
rightRightAdjust(p);
}
}
else
{
adjustTreeColour(node);
}
}
}
private void rightRightAdjust(RBTNode <T> node)
{
node.parent.colour = !node.parent.colour;
node.parent.parent.colour = !node.parent.parent.colour;
rotateLeft(node.parent.parent);
}
private void leftLeftAdjust(RBTNode <T> node)
{
node.parent.colour = !node.parent.colour;
node.parent.parent.colour = !node.parent.parent.colour;
rotateRight(node.parent.parent);
}
