public int Height(RBTreeNode <TKey> node)
{
if (node == null)
{
return(0);
}
int lHeight = Height(node.Left);
int rHeight = Height(node.Right);
if (lHeight > rHeight)
{
return(lHeight + 1);
}
else
{
return(rHeight + 1);
}
}
public void Delete(RBTreeNode <TKey> deleteNode)
{
RBTreeNode <TKey> linkedNode, workNode = deleteNode;
var workNodeOriginalColor = workNode.Color;
if (deleteNode.Left == Leaf)
{
linkedNode = deleteNode.Right;
Transplant(deleteNode, deleteNode.Right);
}
else if (deleteNode.Right == Leaf)
{
linkedNode = deleteNode.Left;
Transplant(deleteNode, deleteNode.Left);
}
else
{
workNode = Minimum(deleteNode.Right);
workNodeOriginalColor = workNode.Color;
linkedNode = workNode.Right;
if (workNode.Parent == deleteNode)
{
linkedNode.Parent = workNode;
}
else
{
Transplant(workNode, workNode.Right);
workNode.Right = deleteNode.Right;
workNode.Right.Parent = workNode;
}
Transplant(deleteNode, workNode);
workNode.Left = deleteNode.Left;
workNode.Left.Parent = workNode;
workNode.Color = deleteNode.Color;
}
if (workNode.Color == Black)
{
DeleteFixup(linkedNode);
}
}
public RBTreeNode <TKey> GetNode(TKey key)
{
try
{
int hashKey = key.GetHashCode();
RBTreeNode <TKey> node = Root;
do
{
if (node.HashKey == hashKey)
{
return(node);
}
node = hashKey < node.HashKey ? node.Left : node.Right;
} while (true);
}
catch (NullReferenceException)
{
throw new KeyNotFoundException("Key not found.");
}
}
private void Insert(RBTreeNode <TKey> node)
{
if (IsEmpty())
{
Root = node;
Root.Color = Black;
return;
}
else
{
var workNode = Leaf;
var currentNode = Root;
while (currentNode != Leaf)
{
workNode = currentNode;
currentNode = node.HashKey < currentNode.HashKey ? currentNode.Left : currentNode.Right;
}
node.Parent = workNode;
if (node.HashKey < workNode.HashKey)
{
workNode.Left = node;
}
else
{
workNode.Right = node;
}
node.Left = Leaf;
node.Right = Leaf;
node.Color = Red;
if (node.Parent.Parent == null)
{
return;
}
InsertFixup(node);
}
}
public void Add(TKey key)
{
RBTreeNode <TKey> newNode = RBTreeNode <TKey> .CreateNode(key, Red);
Insert(newNode);
}
private void DeleteFixup(RBTreeNode <TKey> linkedNode)
{
RBTreeNode <TKey> node;
while (linkedNode != Root && linkedNode.Color == Black)
{
if (linkedNode == linkedNode.Parent.Left)
{
node = linkedNode.Parent.Right;
if (node.Color == Red)
{
node.Color = Black;
linkedNode.Parent.Color = Red;
RotateLeft(linkedNode.Parent);
node = linkedNode.Parent.Right;
}
if (node.Left.Color == Black &&
node.Right.Color == Black)
{
node.Color = Red;
linkedNode = linkedNode.Parent;
}
else if (node.Right.Color == Black)
{
node.Left.Color = Black;
node.Color = Red;
RotateRight(node);
node = node.Parent.Right;
}
node.Color = linkedNode.Parent.Color;
node.Parent.Color = Black;
node.Right.Color = Black;
RotateLeft(linkedNode.Parent);
linkedNode = Root;
}
else
{
node = linkedNode.Parent.Left;
if (node.Color == Red)
{
node.Color = Black;
linkedNode.Parent.Color = Red;
RotateRight(linkedNode.Parent);
node = linkedNode.Parent.Left;
}
if (node.Right.Color == Black &&
node.Left.Color == Black)
{
node.Color = Red;
linkedNode = linkedNode.Parent;
}
else if (node.Left.Color == Black)
{
node.Right.Color = Black;
node.Color = Red;
RotateLeft(node);
node = node.Parent.Left;
node.Color = linkedNode.Parent.Color;
node.Parent.Color = Black;
node.Left.Color = Black;
RotateRight(linkedNode.Parent);
linkedNode = Root;
}
}
}
linkedNode.Color = Black;
}
public bool Contains(RBTreeNode <TKey> node)
{
return(ContainsKey(node.Key));
}
public RBTree()
{
Leaf = new RBTreeNode <TKey>();
Root = Leaf;
}
internal RBTreeNode()
{
Color = Black;
Parent = Left = Right = null;
}
