private void InsertBalance(AvlNode <TKey, TValue> node, int balance)
{
while (node != null)
{
balance = (node.Balance += balance);
if (balance == 0)
{
return;
}
else if (balance == 2)
{
if (node.Left.Balance == 1)
{
RotateRight(node);
}
else
{
RotateLeftRight(node);
}
return;
}
else if (balance == -2)
{
if (node.Right.Balance == -1)
{
RotateLeft(node);
}
else
{
RotateRightLeft(node);
}
return;
}
AvlNode <TKey, TValue> parent = node.Parent;
if (parent != null)
{
balance = parent.Left == node ? 1 : -1;
}
node = parent;
}
}
public bool SearchLeftRight(TKey key, out TValue vleft, out TValue vright)
{
AvlNode <TKey, TValue> node = Root;
AvlNode <TKey, TValue> leftnode = null;
AvlNode <TKey, TValue> rightnode = null;
while (node != null)
{
if (_comparer.Compare(key, node.Key) < 0)
{
rightnode = node;
node = node.Left;
}
else if (_comparer.Compare(key, node.Key) > 0)
{
leftnode = node;
node = node.Right;
}
else
{
vleft = node.Value;
vright = node.Value;
return(true);
}
}
if (leftnode != null)
{
vleft = leftnode.Value;
}
else
{
vleft = default(TValue);
}
if (rightnode != null)
{
vright = rightnode.Value;
}
else
{
vright = default(TValue);
}
return(false);
}
private void InsertBalance(AvlNode <TKey, TValue> node, int balance)
{
while (true)
{
balance = (node.Balance += balance);
if (balance == 0)
{
return;
}
else if (balance == 2)
{
if (node.Left.Balance == 1)
{
RotateRight(node);
}
else
{
RotateLeftRight(node);
}
return;
}
else if (balance == -2)
{
if (node.Right.Balance == -1)
{
RotateLeft(node);
}
else
{
RotateRightLeft(node);
}
return;
}
AvlNode <TKey, TValue> parent = node.Parent;
if (parent == null)
{
return; //1 less compare per loop (was: also cmp in while(...))
}
balance = (parent.Left == node) ? 1 : -1;
node = parent;
}
}
public bool MoveNext()
{
switch (_action)
{
case Action.Right:
_current = _right;
while (_current.Left != null)
{
_current = _current.Left;
}
_right = _current.Right;
_action = _right != null ? Action.Right : Action.Parent;
return(true);
case Action.Parent:
while (_current.Parent != null)
{
AvlNode <TKey, TValue> previous = _current;
_current = _current.Parent;
if (_current.Left == previous)
{
_right = _current.Right;
_action = _right != null ? Action.Right : Action.Parent;
return(true);
}
}
_action = Action.End;
return(false);
default:
return(false);
}
}
private static void Replace(AvlNode <TKey, TValue> target, AvlNode <TKey, TValue> source)
{
AvlNode <TKey, TValue> left = source.Left;
AvlNode <TKey, TValue> right = source.Right;
target.Balance = source.Balance;
target.Key = source.Key;
target.Value = source.Value;
target.Left = left;
target.Right = right;
if (left != null)
{
left.Parent = target;
}
if (right != null)
{
right.Parent = target;
}
}
private void Replace_(AvlNode <TKey, TValue> target, AvlNode <TKey, TValue> source)
{ //!! changed surviving node
Node parent = target.Parent;
if (parent == null)
{
_root = source;
}
else
{
if (parent.Left == target)
{
parent.Left = source;
}
else
{
parent.Right = source;
}
}
source.Parent = parent;
}
public bool Delete(TKey key)
{
AvlNode <TKey, TValue> node = _root;
while (node != null)
{
if (_comparer.Compare(key, node.Key) < 0)
{
node = node.Left;
}
else if (_comparer.Compare(key, node.Key) > 0)
{
node = node.Right;
}
else
{
AvlNode <TKey, TValue> left = node.Left;
AvlNode <TKey, TValue> right = node.Right;
if (left == null)
{
if (right == null)
{
if (node == _root)
{
_root = null;
}
else
{
AvlNode <TKey, TValue> parent = node.Parent;
if (parent.Left == node)
{
parent.Left = null;
DeleteBalance(parent, -1);
}
else
{
parent.Right = null;
DeleteBalance(parent, 1);
}
}
}
else
{
Replace(node, right);
DeleteBalance(node, 0);
}
}
else if (right == null)
{
Replace(node, left);
DeleteBalance(node, 0);
}
else
{
AvlNode <TKey, TValue> successor = right;
if (successor.Left == null)
{
AvlNode <TKey, TValue> parent = node.Parent;
successor.Parent = parent;
successor.Left = left;
successor.Balance = node.Balance;
left.Parent = successor;
if (node == _root)
{
_root = successor;
}
else
{
if (parent.Left == node)
{
parent.Left = successor;
}
else
{
parent.Right = successor;
}
}
DeleteBalance(successor, 1);
}
else
{
while (successor.Left != null)
{
successor = successor.Left;
}
AvlNode <TKey, TValue> parent = node.Parent;
AvlNode <TKey, TValue> successorParent = successor.Parent;
AvlNode <TKey, TValue> successorRight = successor.Right;
if (successorParent.Left == successor)
{
successorParent.Left = successorRight;
}
else
{
successorParent.Right = successorRight;
}
if (successorRight != null)
{
successorRight.Parent = successorParent;
}
successor.Parent = parent;
successor.Left = left;
successor.Balance = node.Balance;
successor.Right = right;
right.Parent = successor;
left.Parent = successor;
if (node == _root)
{
_root = successor;
}
else
{
if (parent.Left == node)
{
parent.Left = successor;
}
else
{
parent.Right = successor;
}
}
DeleteBalance(successorParent, -1);
}
}
return(true);
}
}
return(false);
}
public void Reset()
{
_right = _root;
_action = _root == null ? Action.End : Action.Right;
}
public AvlNodeEnumerator(AvlNode <TKey, TValue> root)
{
_right = _root = root;
_action = _root == null ? Action.End : Action.Right;
}
public bool Insert(TKey key, TValue value)
{
AvlNode <TKey, TValue> node = Root;
while (node != null)
{
int compare = _comparer.Compare(key, node.Key);
if (compare < 0)
{
AvlNode <TKey, TValue> left = node.Left;
if (left == null)
{
node.Left = new AvlNode <TKey, TValue> {
Key = key, Value = value, Parent = node
};
InsertBalance(node, 1);
return(true);
}
else
{
node = left;
}
}
else if (compare > 0)
{
AvlNode <TKey, TValue> right = node.Right;
if (right == null)
{
node.Right = new AvlNode <TKey, TValue> {
Key = key, Value = value, Parent = node
};
InsertBalance(node, -1);
return(true);
}
else
{
node = right;
}
}
else
{
node.Value = value;
return(false);
}
}
Root = new AvlNode <TKey, TValue> {
Key = key, Value = value
};
_count++;
return(true);
}
public bool Insert(TKey key, TValue value)
{
if (_root == null) //moved up case
{
_root = new AvlNode <TKey, TValue> {
Key = key, Value = value
};
return(true);
}
AvlNode <TKey, TValue> node = _root;
while (true) //was: while(node != null) --- no need check each loop
{
int compare = _comparer.Compare(key, node.Key);
if (compare < 0)
{
AvlNode <TKey, TValue> left = node.Left;
if (left == null)
{
node.Left = new AvlNode <TKey, TValue> {
Key = key, Value = value, Parent = node
};
InsertBalance(node, 1);
return(true);
}
else
{
node = left;
}
}
else if (compare > 0)
{
AvlNode <TKey, TValue> right = node.Right;
if (right == null)
{
node.Right = new AvlNode <TKey, TValue> {
Key = key, Value = value, Parent = node
};
InsertBalance(node, -1);
return(true);
}
else
{
node = right;
}
}
else
{
node.Value = value;
return(false);
}
}
}
public bool Delete(TKey key)
{
AvlNode <TKey, TValue> node = _root;
while (node != null)
{
if (_comparer.Compare(key, node.Key) < 0)
{
node = node.Left;
}
else if (_comparer.Compare(key, node.Key) > 0)
{
node = node.Right;
}
else
{
AvlNode <TKey, TValue> left = node.Left;
AvlNode <TKey, TValue> right = node.Right;
if (left == null)
{
if (right == null)
{
AvlNode <TKey, TValue> parent = node.Parent; //moved
if (parent == null) //was: if(node == _root) --- slower
{
_root = null;
}
else
{
//(moved up) AvlNode<TKey, TValue> parent = node.Parent;
if (parent.Left == node)
{
parent.Left = null;
DeleteBalance(parent, -1);
}
else
{
parent.Right = null;
DeleteBalance(parent, 1);
}
}
}
else
{
Replace_(node, right);
DeleteBalance(right, 0);
}
}
else if (right == null)
{
Replace_(node, left);
DeleteBalance(left, 0);
}
else
{
AvlNode <TKey, TValue> successor = right;
if (successor.Left == null)
{
successor.Left = left;
successor.Balance = node.Balance;
left.Parent = successor;
Replace_(node, successor); //(new)
DeleteBalance(successor, 1);
}
else
{ //here: successor.Left != null
while (successor.Left != null) //as min 1 loop done
{
successor = successor.Left;
}
//here: successor is always Left child
AvlNode <TKey, TValue> successorParent = successor.Parent;
AvlNode <TKey, TValue> successorRight = successor.Right;
//was: always true condition
successorParent.Left = successorRight;
if (successorRight != null)
{
successorRight.Parent = successorParent;
}
node.Key = successor.Key;
node.Value = succesor.Value;
DeleteBalance(successorParent, -1);
}
}
return(true);
}
}
return(false);
}
