public IComparable GetMaxKey()
{
OrderedTreeNode treeNode = rbTree;
if (treeNode == null || treeNode == sentinelNode)
{
throw(new InvalidOperationException("Tree is empty"));
}
while (treeNode.Right != sentinelNode)
{
treeNode = treeNode.Right;
}
lastNodeFound = treeNode;
return(treeNode.Key);
}
public void RotateRight(OrderedTreeNode x)
{
OrderedTreeNode y = x.Left;
x.Left = y.Right;
if (y.Right != sentinelNode)
{
y.Right.Parent = x;
}
if (y != sentinelNode)
{
y.Parent = x.Parent;
}
if (x.Parent != null)
{
if (x == x.Parent.Right)
{
x.Parent.Right = y;
}
else
{
x.Parent.Left = y;
}
}
else
{
rbTree = y;
}
y.Right = x;
if (x != sentinelNode)
{
x.Parent = y;
}
}
public void Reset()
{
pre = true;
stack.Clear();
if (ascending)
{
while (tnode != sentinelNode)
{
stack.Push(tnode);
tnode = tnode.Left;
}
}
else
{
while (tnode != sentinelNode)
{
stack.Push(tnode);
tnode = tnode.Right;
}
}
}
public bool ContainsKey(IComparable key)
{
OrderedTreeNode treeNode = rbTree;
int result = 0;
while (treeNode != sentinelNode)
{
result = key.CompareTo(treeNode.Key);
if (result == 0)
{
lastNodeFound = treeNode;
return(true);
}
if (result < 0)
{
treeNode = treeNode.Left;
}
else
{
treeNode = treeNode.Right;
}
}
return(false);
}
public void Add(IComparable key, object data)
{
if (key == null)
{
throw(new ArgumentNullException("Key is null"));
}
int result = 0;
OrderedTreeNode node = new OrderedTreeNode();
OrderedTreeNode temp = rbTree;
while (temp != sentinelNode)
{
node.Parent = temp;
result = key.CompareTo(temp.Key);
if (result == 0)
{
throw new ArgumentException("Key duplicated");
}
if (result > 0)
{
temp = temp.Right;
}
else
{
temp = temp.Left;
}
}
node.Key = key;
node.Data = data;
node.Left = sentinelNode;
node.Right = sentinelNode;
if (node.Parent != null)
{
result = node.Key.CompareTo(node.Parent.Key);
if (result > 0)
{
node.Parent.Right = node;
}
else
{
node.Parent.Left = node;
}
}
else
{
rbTree = node;
}
RestoreAfterInsert(node);
lastNodeFound = node;
intCount = intCount + 1;
}
public object NextElement()
{
if (stack.Count == 0)
{
throw new InvalidOperationException("Element not found");
}
OrderedTreeNode node = (OrderedTreeNode)stack.Peek();
if (ascending)
{
if (node.Right == sentinelNode)
{
OrderedTreeNode tn = (OrderedTreeNode)stack.Pop();
while (HasMoreElements() && ((OrderedTreeNode)stack.Peek()).Right == tn)
{
tn = (OrderedTreeNode)stack.Pop();
}
}
else
{
OrderedTreeNode tn = node.Right;
while (tn != sentinelNode)
{
stack.Push(tn);
tn = tn.Left;
}
}
}
else
{
if (node.Left == sentinelNode)
{
OrderedTreeNode tn = (OrderedTreeNode)stack.Pop();
while (HasMoreElements() && ((OrderedTreeNode)stack.Peek()).Left == tn)
{
tn = (OrderedTreeNode)stack.Pop();
}
}
else
{
OrderedTreeNode tn = node.Left;
while (tn != sentinelNode)
{
stack.Push(tn);
tn = tn.Right;
}
}
}
Key = node.Key;
Value = node.Data;
return(keys == true ? node.Key : node.Data);
}
public OrderedTreeEnumerator(OrderedTreeNode tnode, bool keys, bool ascending, OrderedTreeNode sentinelNode)
{
this.sentinelNode = sentinelNode;
stack = new Stack();
this.keys = keys;
this.ascending = ascending;
this.tnode = tnode;
Reset();
}
public void Clear()
{
rbTree = sentinelNode;
intCount = 0;
}
private void RestoreAfterDelete(OrderedTreeNode x)
{
OrderedTreeNode y;
while (x != rbTree && x.Color == OrderedTreeNode.BLACK)
{
if (x == x.Parent.Left)
{
y = x.Parent.Right;
if (y.Color == OrderedTreeNode.RED)
{
y.Color = OrderedTreeNode.BLACK;
x.Parent.Color = OrderedTreeNode.RED;
RotateLeft(x.Parent);
y = x.Parent.Right;
}
if (y.Left.Color == OrderedTreeNode.BLACK &&
y.Right.Color == OrderedTreeNode.BLACK)
{
y.Color = OrderedTreeNode.RED;
x = x.Parent;
}
else
{
if (y.Right.Color == OrderedTreeNode.BLACK)
{
y.Left.Color = OrderedTreeNode.BLACK;
y.Color = OrderedTreeNode.RED;
RotateRight(y);
y = x.Parent.Right;
}
y.Color = x.Parent.Color;
x.Parent.Color = OrderedTreeNode.BLACK;
y.Right.Color = OrderedTreeNode.BLACK;
RotateLeft(x.Parent);
x = rbTree;
}
}
else
{
y = x.Parent.Left;
if (y.Color == OrderedTreeNode.RED)
{
y.Color = OrderedTreeNode.BLACK;
x.Parent.Color = OrderedTreeNode.RED;
RotateRight(x.Parent);
y = x.Parent.Left;
}
if (y.Right.Color == OrderedTreeNode.BLACK &&
y.Left.Color == OrderedTreeNode.BLACK)
{
y.Color = OrderedTreeNode.RED;
x = x.Parent;
}
else
{
if (y.Left.Color == OrderedTreeNode.BLACK)
{
y.Right.Color = OrderedTreeNode.BLACK;
y.Color = OrderedTreeNode.RED;
RotateLeft(y);
y = x.Parent.Left;
}
y.Color = x.Parent.Color;
x.Parent.Color = OrderedTreeNode.BLACK;
y.Left.Color = OrderedTreeNode.BLACK;
RotateRight(x.Parent);
x = rbTree;
}
}
}
x.Color = OrderedTreeNode.BLACK;
}
private void Delete(OrderedTreeNode z)
{
OrderedTreeNode x = new OrderedTreeNode();
OrderedTreeNode y;
if (z.Left == sentinelNode || z.Right == sentinelNode)
{
y = z;
}
else
{
y = z.Right;
while (y.Left != sentinelNode)
{
y = y.Left;
}
}
if (y.Left != sentinelNode)
{
x = y.Left;
}
else
{
x = y.Right;
}
x.Parent = y.Parent;
if (y.Parent != null)
{
if (y == y.Parent.Left)
{
y.Parent.Left = x;
}
else
{
y.Parent.Right = x;
}
}
else
{
rbTree = x;
}
if (y != z)
{
z.Key = y.Key;
z.Data = y.Data;
}
if (y.Color == OrderedTreeNode.BLACK)
{
RestoreAfterDelete(x);
}
lastNodeFound = sentinelNode;
}
public object this[IComparable key] {
get {
return(GetData(key));
}
set {
if (key == null)
{
throw new ArgumentNullException("Key is null");
}
int result = 0;
OrderedTreeNode node = new OrderedTreeNode();
OrderedTreeNode temp = rbTree;
while (temp != sentinelNode)
{
node.Parent = temp;
result = key.CompareTo(temp.Key);
if (result == 0)
{
lastNodeFound = temp;
temp.Data = value;
return;
}
if (result > 0)
{
temp = temp.Right;
}
else
{
temp = temp.Left;
}
}
node.Key = key;
node.Data = value;
node.Left = sentinelNode;
node.Right = sentinelNode;
if (node.Parent != null)
{
result = node.Key.CompareTo(node.Parent.Key);
if (result > 0)
{
node.Parent.Right = node;
}
else
{
node.Parent.Left = node;
}
}
else
{
rbTree = node;
}
RestoreAfterInsert(node);
lastNodeFound = node;
intCount = intCount + 1;
}
}
