public void InOrderPredecessor_RootLeft()
{
RedBlackNode<int> rootLeft = new RedBlackNode<int>(50)
{
Left = new RedBlackNode<int>(25)
};
Assert.AreEqual<int>(25, rootLeft.InOrderPredecessor.Value);
}
public void InOrderPredecessor_RootRight()
{
RedBlackNode<int> rootRight = new RedBlackNode<int>(50)
{
Right = new RedBlackNode<int>(75)
};
Assert.IsNull(rootRight.InOrderPredecessor);
}
internal static RedBlackNode LeftBalance(object key, object val, RedBlackNode insert, RedBlackNode right)
{
if (insert is RedNode && insert.Left is RedNode)
{
return(MakeRed(insert.Key, insert.Value, insert.Left.Blacken(), MakeBlack(key, val, insert.Right, right)));
}
else if (insert is RedNode && insert.Right is RedNode)
{
return(MakeRed(insert.Right.Key, insert.Right.Value,
MakeBlack(insert.Key, insert.Value, insert.Left, insert.Right.Left),
MakeBlack(key, val, insert.Right.Right, right)));
}
else
{
return(MakeBlack(key, val, insert, right));
}
}
internal static BlackNode MakeBlack(object key, object val, RedBlackNode left, RedBlackNode right)
{
if (left is null && right is null)
{
if (val is null)
{
return(new BlackNode(key));
}
return(new BlackValueNode(key, val));
}
if (val is null)
{
return(new BlackBranchNode(key, left, right));
}
return(new BlackBranchValueNode(key, val, left, right));
}
///<summary>
/// RotateRight
/// Rebalance the tree by rotating the nodes to the right
///</summary>
private void RotateRight(RedBlackNode <TKey, TValue> x)
{
// pushing node x down and to the Right to balance the tree. x's Left child (y)
// replaces x (since x < y), and y's Right child becomes x's Left child
// (since it's < x but > y).
RedBlackNode <TKey, TValue> y = x.Left; // get x's Left node, this becomes y
// set x's Right link
x.Left = y.Right; // y's Right child becomes x's Left child
// modify parents
if (y.Right != sentinelNode)
{
y.Right.Parent = x; // sets y's Right Parent to x
}
if (y != sentinelNode)
{
y.Parent = x.Parent; // set y's Parent to x's Parent
}
if (x.Parent != null) // null=rbTree, could also have used rbTree
{ // determine which side of it's Parent x was on
if (x == x.Parent.Right)
{
x.Parent.Right = y; // set Right Parent to y
}
else
{
x.Parent.Left = y; // set Left Parent to y
}
}
else
{
rbTree = y; // at rbTree, set it to y
}
// link x and y
y.Right = x; // put x on y's Right
if (x != sentinelNode) // set y as x's Parent
{
x.Parent = y;
}
x.Count = x.Left.Count + x.Right.Count + 1;
y.Count = y.Left.Count + y.Right.Count + 1;
}
private void InsertNode(T value, RedBlackNode current)
{
if (value.CompareTo(current.NodeValue) == -1)
{
if (current.LeftNode == null)
{
var node = new RedBlackNode(value)
{
Color = NodeColor.Red,
ParentNode = current,
};
current.LeftNode = node;
_nodeCount++;
}
else
{
InsertNode(value, current.LeftNode);
return;
}
}
else if (value.CompareTo(current.NodeValue) == 1)
{
if (current.RightNode == null)
{
var node = new RedBlackNode(value)
{
Color = NodeColor.Red,
ParentNode = current,
};
current.RightNode = node;
_nodeCount++;
}
else
{
InsertNode(value, current.RightNode);
return;
}
}
// Make sure we didn't violate the rules of a red/black tree.
CheckNode(current);
// Automatically make sure the root node is black.
_rootNode.Color = NodeColor.Black;
}
private void FixChildColors(RedBlackNode current)
{
if (current.Color == RedBlackNode.NodeColor.RED)
{
if (current.LeftNode != null &&
current.LeftNode.Color == RedBlackNode.NodeColor.BLACK)
{
current.LeftNode.Color = RedBlackNode.NodeColor.RED;
current.Color = RedBlackNode.NodeColor.BLACK;
}
else if (current.RightNode != null &&
current.RightNode.Color == RedBlackNode.NodeColor.BLACK)
{
current.RightNode.Color = RedBlackNode.NodeColor.RED;
current.Color = RedBlackNode.NodeColor.BLACK;
}
}
}
private static RedBlackNode initialInsertRepair(RedBlackNode current)
{
// considering the specific of our insertion - if current not black (in this case we have to do nothing)
// current and current.Brother were red leafs before last insert, so we can make start already from
// case 3 in https://ru.wikipedia.org/wiki/%D0%9A%D1%80%D0%B0%D1%81%D0%BD%D0%BE-%D1%87%D1%91%D1%80%D0%BD%D0%BE%D0%B5_%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE
if (current.NodeColor == RedBlackNode.Color.Red)
{
current.NodeColor = RedBlackNode.Color.Black;
current.Brother.NodeColor = RedBlackNode.Color.Black;
current.Parent.NodeColor = RedBlackNode.Color.Red;
return(repairAfterInsert(current.Parent));
}
else
{
return(recountToUp(current));
}
}
private static int Verify <T>(RedBlackNode <T> tree) where T : RedBlackNode <T>
{
if (tree == null)
{
return(0);
}
if (tree is IComparable <T> comp)
{
if (tree.Left != null)
{
Assert.IsTrue(comp.CompareTo(tree.Left) > 0, "Order Violation");
}
if (tree.Right != null)
{
Assert.IsTrue(comp.CompareTo(tree.Right) < 0, "Order Violation");
}
}
if (tree.Left != null)
{
Assert.IsTrue(tree.Left.Parent == tree, "Parent Child ref Mismatch");
}
if (tree.Right != null)
{
Assert.IsTrue(tree.Right.Parent == tree, "Parent Child ref Mismatch");
}
if (tree.Red)
{
Assert.IsTrue(IsBlack(tree.Left) && IsBlack(tree.Right), "Red Violation");
}
int height;
Assert.AreEqual(height = Verify(tree.Left), Verify(tree.Right), "Black Violation");
if (tree.Black)
{
height++;
}
return(height);
}
///<summary>
/// GetMinKey
/// Returns the minimum key value
///<summary>
public TKey GetMinKey()
{
RedBlackNode <TKey, TValue> treeNode = rbTree;
if (treeNode == null || treeNode == sentinelNode)
{
throw (new Exception("RedBlack tree is empty"));
}
// traverse to the extreme left to find the smallest key
while (treeNode.Left != sentinelNode)
{
treeNode = treeNode.Left;
}
lastNodeFound = treeNode;
return(treeNode.Key);
}
protected internal override RedBlackNode BalanceRight(RedBlackNode parent)
{
if (this._right is RedNode)
{
return(SortedMap.MakeRed(this._key, Value,
SortedMap.MakeBlack(parent.Key, parent.Value, parent.Left, this._left),
this._right.Blacken()));
}
else if (this._left is RedNode)
{
return(SortedMap.MakeRed(this._left.Key, this._left.Value,
SortedMap.MakeBlack(parent.Key, parent.Value, parent.Left, this._left.Left),
SortedMap.MakeBlack(this._key, Value, this._left.Right, this._right)));
}
else
{
return(base.BalanceRight(parent));
}
}
/// <summary>
/// 为了实现LL/RR 最后一句 node = p 预期实现的效果
/// </summary>
/// <param name="oldp">老的节点node(就是LL/RR 传递时候的node)</param>
/// <param name="newp">新的节点node(就是LL/RR 执行完成之后的node)</param>
/// <param name="path"></param>
private void ReLink(RedBlackNode oldp, RedBlackNode newp, ref Stack <RedBlackNode> path)
{
if (path.Count == 0)
{
root = newp;
}
else
{
RedBlackNode grandfather = path.Peek();
if (grandfather.left == oldp)
{
grandfather.left = newp;
}
else
{
grandfather.right = newp;
}
}
}
internal static RedBlackNode BalanceLeftDelete(object key, object val, RedBlackNode del, RedBlackNode right)
{
if (del is RedNode)
{
return(MakeRed(key, val, del.Blacken(), right));
}
else if (right is BlackNode)
{
return(RightBalance(key, val, del, right.Redden()));
}
else if (right is RedNode && right.Left is BlackNode)
{
return(MakeRed(right.Left.Key, right.Left.Value,
MakeBlack(key, val, del, right.Left.Left),
RightBalance(right.Key, right.Value, right.Left.Right, right.Right.Redden())));
}
throw new InvalidOperationException("Invariant violation");
}
private void FixChildColors(RedBlackNode current)
{
// If a node is red, both children must be black,switch if necessary.
if (current.Color == NodeColor.Red)
{
if (current.LeftNode != null &&
current.LeftNode.Color == NodeColor.Black)
{
current.LeftNode.Color = NodeColor.Red;
current.Color = NodeColor.Black;
}
else if (current.RightNode != null &&
current.RightNode.Color == NodeColor.Black)
{
current.RightNode.Color = NodeColor.Red;
current.Color = NodeColor.Black;
}
}
}
/// <summary>
/// Insert a new object into the RB Tree
/// </summary>
/// <param name="item"></param>
public void Insert(int item)
{
RedBlackNode newItem = new RedBlackNode(item);
if (root == null)
{
root = newItem;
root.colour = Color.Black;
return;
}
RedBlackNode Y = null;
RedBlackNode X = root;
while (X != null)
{
Y = X;
if (newItem.data < X.data)
{
X = X.left;
}
else
{
X = X.right;
}
}
newItem.parent = Y;
if (Y == null)
{
root = newItem;
}
else if (newItem.data < Y.data)
{
Y.left = newItem;
}
else
{
Y.right = newItem;
}
newItem.left = null;
newItem.right = null;
newItem.colour = Color.Red; //colour the new node red
InsertFixUp(newItem); //call method to check for violations and fix
}
/// <summary>
/// Inserts the specified key/value pair to the tree.
/// </summary>
/// <param name="key">The key of the element to insert.</param>
/// <param name="value">The value of the element to insert. The value can be <c>null</c> for reference types.</param>
/// <exception cref="System.ArgumentNullException">The key is null.</exception>
/// <exception cref="System.ArgumentException">An element with the same key already exists in the tree.</exception>
public override void Insert(TKey key, TValue value)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
if (this.root == null)
{
this.root = new RedBlackNode {
Key = key, Value = value, Color = NodeColor.Black
};
this.nodeCount++;
this.version++;
return;
}
RedBlackNode node = this.SearchNodeForInsertion(key) as RedBlackNode;
if (node == null)
{
throw new ArgumentException(CollectionMessages.KeyExists, nameof(key));
}
if (this.Comparer.Compare(key, node.Key) < 0)
{
node.LeftChild = new RedBlackNode {
Key = key, Value = value, Parent = node, Color = NodeColor.Red
};
this.BalanceInsert(node.LeftChild as RedBlackNode);
}
else
{
node.RightChild = new RedBlackNode {
Key = key, Value = value, Parent = node, Color = NodeColor.Red
};
this.BalanceInsert(node.RightChild as RedBlackNode);
}
this.nodeCount++;
this.version++;
}
/// <summary>
/// Inserts the specified key/value pair to the tree.
/// </summary>
/// <param name="key">The key of the element to insert.</param>
/// <param name="value">The value of the element to insert. The value can be <c>null</c> for reference types.</param>
/// <exception cref="System.ArgumentNullException">The key is null.</exception>
/// <exception cref="System.ArgumentException">An element with the same key already exists in the tree.</exception>
public override void Insert(TKey key, TValue value)
{
if (key == null)
{
throw new ArgumentNullException("key", "The key is null.");
}
if (_root == null)
{
_root = new RedBlackNode {
Key = key, Value = value, Color = NodeColor.Black
};
_nodeCount++;
_version++;
return;
}
RedBlackNode node = SearchNodeForInsertion(key) as RedBlackNode;
if (node == null)
{
throw new ArgumentException("An element with the same key already exists in the tree.", "key");
}
if (_comparer.Compare(key, node.Key) < 0)
{
node.LeftChild = new RedBlackNode {
Key = key, Value = value, Parent = node, Color = NodeColor.Red
}
}
;
else
{
node.RightChild = new RedBlackNode {
Key = key, Value = value, Parent = node, Color = NodeColor.Red
}
};
BalanceInsert(node);
_nodeCount++;
_version++;
}
private void InsertNode(T value, RedBlackNode current)
{
if (value.CompareTo(current.NodeValue) == -1)
{
if (current.LeftNode == null)
{
var node = new RedBlackNode(value)
{
Color = RedBlackNode.NodeColor.RED,
ParentNode = current,
};
current.LeftNode = node;
_nodeCount++;
}
else
{
InsertNode(value, current.LeftNode);
return;
}
}
else if (value.CompareTo(current.NodeValue) == 1)
{
if (current.RightNode == null)
{
var node = new RedBlackNode(value)
{
Color = RedBlackNode.NodeColor.RED,
ParentNode = current,
};
current.RightNode = node;
_nodeCount++;
}
else
{
InsertNode(value, current.RightNode);
return;
}
}
CheckNode(current);
_rootNode.Color = RedBlackNode.NodeColor.BLACK;
}
public void Insert(T value)
{
if (_rootNode == null)
{
// In this case we are inserting the root node.
var node = new RedBlackNode(value)
{
ParentNode = null,
Color = NodeColor.Black
};
_rootNode = node;
_nodeCount++;
}
else
{
// The root already exists, so traverse the tree to figure out
// where to put the node.
InsertNode(value, _rootNode);
}
}
// 1) The root is black
// 2) All leaves are black
// 3) Every red node must have two black child nodes
// 4) Every path from a given node to any of its descendant leaves must contain an equal number of black nodes
private void CheckNode(RedBlackNode <T> node)
{
RedBlackNode <T> left = (RedBlackNode <T>)node.Left;
RedBlackNode <T> right = (RedBlackNode <T>)node.Right;
if (left.BlackHeight != right.BlackHeight)
{
// rotate
// make left node red and checknode
// make right node red and checknode
}
if (node.Color.Equals(NodeColors.Red))
{
if (node.Equals(this.Root) || left.Color.Equals(NodeColors.Red) || right.Color.Equals(NodeColors.Red))
{
node.Color = NodeColors.Black;
}
}
}
private static IEnumerable <T> InOrderTraversal(RedBlackNode node)
{
if (node.LeftNode != null)
{
foreach (T nodeVal in InOrderTraversal(node.LeftNode))
{
yield return(nodeVal);
}
}
yield return(node.NodeValue);
if (node.RightNode != null)
{
foreach (T nodeVal in InOrderTraversal(node.RightNode))
{
yield return(nodeVal);
}
}
}
internal static RedBlackNode BalanceRightDelete(object key, object val, RedBlackNode left, RedBlackNode del)
{
if (del is RedNode)
{
return(MakeRed(key, val, left, del.Blacken()));
}
else if (left is BlackNode)
{
return(LeftBalance(key, val, left.Redden(), del));
}
else if (left is RedNode && left.Right is BlackNode)
{
return(MakeRed(left.Right.Key, left.Right.Value,
LeftBalance(left.Key, left.Value, left.Left.Redden(), left.Right.Left),
MakeBlack(key, val, left.Right.Right, del)));
}
else
{
throw new InvalidOperationException("Invariant violation");
}
}
static RedBlackNode Append(RedBlackNode left, RedBlackNode right)
{
if (left is null)
{
return(right);
}
if (right is null)
{
return(left);
}
else if (left is RedNode)
{
if (right is RedNode)
{
var app = Append(left.Right, right.Left);
return(app is RedNode
? MakeRed(app.Key, app.Value,
MakeRed(left.Key, left.Value, left.Left, app.Left),
MakeRed(right.Key, right.Value, app.Right, right.Right))
: MakeRed(left.Key, left.Value, left.Left, MakeRed(right.Key, right.Value, app, right.Right)));
}
else
{
return(MakeRed(left.Key, left.Value, left.Left, Append(left.Right, right)));
}
}
else if (right is RedNode)
{
return(MakeRed(right.Key, right.Value, Append(left, right.Left), right.Right));
}
else
{
var app = Append(left.Right, right.Left);
return((app is RedNode)
? MakeRed(app.Key, app.Value,
MakeBlack(left.Key, left.Value, left.Left, app.Left),
MakeBlack(right.Key, right.Value, app.Right, right.Right))
: BalanceLeftDelete(left.Key, left.Value, left.Left, MakeBlack(right.Key, right.Value, app, right.Right)));
}
}
private void RotateRight(RedBlackNode <TKey, TValue> x)
{
RedBlackNode <TKey, TValue> 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;
}
x.Count = x.Left.Count + x.Right.Count + 1;
y.Count = y.Left.Count + y.Right.Count + 1;
}
public void RotateRight_FullTree()
{
RedBlackNode <int> node = new RedBlackNode <int>(100);
node.Left = new RedBlackNode <int>(50);
node.Right = new RedBlackNode <int>(150);
node.Left.Left = new RedBlackNode <int>(25);
node.Left.Right = new RedBlackNode <int>(75);
node.Right.Left = new RedBlackNode <int>(125);
node.Right.Right = new RedBlackNode <int>(175);
node.ResetHeight();
node.Left.ResetHeight();
node.Right.ResetHeight();
node.Left.Left.ResetHeight();
node.Left.Right.ResetHeight();
node.Right.Left.ResetHeight();
node.Right.Right.ResetHeight();
node = node.RotateRight() as RedBlackNode <int>;
Assert.AreEqual <int>(50, node.Value);
Assert.AreEqual <int>(25, node.Left.Value);
Assert.AreEqual <int>(100, node.Right.Value);
Assert.AreEqual <int>(75, node.Right.Left.Value);
Assert.AreEqual <int>(150, node.Right.Right.Value);
Assert.AreEqual <int>(125, node.Right.Right.Left.Value);
Assert.AreEqual <int>(175, node.Right.Right.Right.Value);
Assert.AreEqual <int>(3, node.Height);
Assert.AreEqual <int>(0, node.Left.Height);
Assert.AreEqual <int>(2, node.Right.Height);
Assert.AreEqual <int>(1, node.Right.Right.Height);
Assert.AreEqual <int>(0, node.Right.Left.Height);
Assert.AreEqual <int>(0, node.Right.Right.Right.Height);
Assert.AreEqual <int>(0, node.Right.Right.Left.Height);
}
internal static RedBlackNode NodeAt(System.Collections.IComparer comp, RedBlackNode tree, object key)
{
var t = tree;
while (t != null)
{
int c = comp.Compare(key, t.Key);
if (c == 0)
{
return(t);
}
else if (c < 0)
{
t = t.Left;
}
else
{
t = t.Right;
}
}
return(t);
}
/// <summary>
/// Adds a node.
/// </summary>
/// <param name="key">Key of the node.</param>
/// <param name="value">Value of the node. </param>
public void Add(TKey key, TValue value)
{
RedBlackNode newNode = new RedBlackNode(key, value);
if (this.rootNode == null)
{
this.rootNode = newNode;
this.rootNode.Color = NodeColor.BLACK;
nodeCount++;
isModfied = true;
return;
}
RecursiveAdd(newNode, this.rootNode);
this.RepairTree(newNode);
this.nodeCount++;
isModfied = true;
this.rootNode.Color = NodeColor.BLACK;
return;
}
internal static RedBlackNode Add(System.Collections.IComparer comp, RedBlackNode t, object key, object val, Box found)
{
if (t is null)
{
return(val is null ? new RedNode(key) : new RedValueNode(key, val));
}
int c = comp.Compare(key, t.Key);
if (c == 0)
{
found.Value = t;
return(null);
}
var insert = c < 0 ? Add(comp, t.Left, key, val, found) : Add(comp, t.Right, key, val, found);
if (insert is null)
{
return(null);
}
return(c < 0
? t.AddLeft(insert)
: t.AddRight(insert));
}
public static void Main()
{
var c = new RedBlackNode <int>
{
Key = "1",
Value = 1,
Left = new RedBlackNode <int>
{
Key = "11",
Value = 11
},
Right = new RedBlackNode <int>
{
Key = "12",
Value = 12
}
};
foreach (var pair in RedBlackNode <int> .GetPairs(c))
{
System.Console.WriteLine(pair.Key + " - " + pair.Value);
}
}
/// <summary>
/// Find item in the tree
/// </summary>
/// <param name="key"></param>
public RedBlackNode Find(int key)
{
bool isFound = false;
RedBlackNode temp = root;
RedBlackNode item = null;
while (!isFound)
{
if (temp == null)
{
break;
}
if (key < temp.data)
{
temp = temp.left;
}
if (key > temp.data)
{
temp = temp.right;
}
if (key == temp.data)
{
isFound = true;
item = temp;
}
}
if (isFound)
{
Console.WriteLine("{0} was found", key);
return(temp);
}
else
{
Console.WriteLine("{0} not found", key);
return(null);
}
}
private static void PrintRedBlackNode(RedBlackNode node, IComparable parentKey)
{
Console.Write(
"Key:{0}\t" + " Data:{1}\t",
node.Key,
node.Value);
Console.Write(" Color:");
if (node.Color == Color.BLACK)
{
Console.BackgroundColor = ConsoleColor.White;
Console.ForegroundColor = ConsoleColor.Black;
Console.Write(node.Color);
Console.ResetColor();
}
else
{
Console.BackgroundColor = ConsoleColor.White;
Console.ForegroundColor = ConsoleColor.Red;
Console.Write(node.Color);
Console.ResetColor();
}
Console.WriteLine("\t Parent Key:{0}", parentKey);
}
public void ToString_RootRight()
{
RedBlackNode<int> node = new RedBlackNode<int>(50)
{
Right = new RedBlackNode<int>(75),
};
Assert.AreEqual<string>("50,Red; Left=null; Right=75", node.ToString());
}
public void RotateRight_FullTree()
{
RedBlackNode<int> node = new RedBlackNode<int>(100);
node.Left = new RedBlackNode<int>(50);
node.Right = new RedBlackNode<int>(150);
node.Left.Left = new RedBlackNode<int>(25);
node.Left.Right = new RedBlackNode<int>(75);
node.Right.Left = new RedBlackNode<int>(125);
node.Right.Right = new RedBlackNode<int>(175);
node.ResetHeight();
node.Left.ResetHeight();
node.Right.ResetHeight();
node.Left.Left.ResetHeight();
node.Left.Right.ResetHeight();
node.Right.Left.ResetHeight();
node.Right.Right.ResetHeight();
node = node.RotateRight() as RedBlackNode<int>;
Assert.AreEqual<int>(50, node.Value);
Assert.AreEqual<int>(25, node.Left.Value);
Assert.AreEqual<int>(100, node.Right.Value);
Assert.AreEqual<int>(75, node.Right.Left.Value);
Assert.AreEqual<int>(150, node.Right.Right.Value);
Assert.AreEqual<int>(125, node.Right.Right.Left.Value);
Assert.AreEqual<int>(175, node.Right.Right.Right.Value);
Assert.AreEqual<int>(3, node.Height);
Assert.AreEqual<int>(0, node.Left.Height);
Assert.AreEqual<int>(2, node.Right.Height);
Assert.AreEqual<int>(1, node.Right.Right.Height);
Assert.AreEqual<int>(0, node.Right.Left.Height);
Assert.AreEqual<int>(0, node.Right.Right.Right.Height);
Assert.AreEqual<int>(0, node.Right.Right.Left.Height);
}
public void RotateRight_CheckColours()
{
RedBlackNode<int> node = new RedBlackNode<int>(100);
node.Left = new RedBlackNode<int>(50);
node = node.RotateRight() as RedBlackNode<int>;
Assert.IsFalse(node.IsRed);
Assert.IsTrue(node.Right.IsRed);
}
public void AssertValidTree_InvalidChildren()
{
var root = new RedBlackNode<int>(100);
root.Left = new RedBlackNode<int>(150);
RedBlackTree<int> bst = new RedBlackTree<int>();
bst.Root = root;
bst.AssertValidTree();
}
public void ResetHeight()
{
RedBlackNode<int> node = new RedBlackNode<int>(20);
Assert.AreEqual<int>(0, node.Height);
node.Left = new RedBlackNode<int>(10);
Assert.AreEqual<int>(0, node.Height);
node.ResetHeight();
Assert.AreEqual<int>(1, node.Height);
}
public void IsLeaf_True()
{
RedBlackNode<int> node = new RedBlackNode<int>(50);
Assert.IsTrue(node.IsLeaf);
}
public void AssertValidTree_Invalid_BlackMismatch_Left()
{
RedBlackNode<int> root = new RedBlackNode<int>(100, Colour.Black);
root.Left = new RedBlackNode<int>(50, Colour.Red);
root.Right = new RedBlackNode<int>(150, Colour.Red);
root.Left.Left = new RedBlackNode<int>(40, Colour.Red);
RedBlackTree<int> bst = new RedBlackTree<int>();
bst.Root = root;
bst.AssertValidTree();
}
public void InOrderSuccessor_RootLeft()
{
RedBlackNode<int> rootLeft = new RedBlackNode<int>(50)
{
Left = new RedBlackNode<int>(25)
};
Assert.IsNull(rootLeft.InOrderSuccessor);
}
public void AssertValidTree_Invalid_DoubleRed_Right()
{
RedBlackNode<int> root = new RedBlackNode<int>(100, Colour.Black);
root.Left = new RedBlackNode<int>(50, Colour.Red);
root.Right = new RedBlackNode<int>(150, Colour.Red);
root.Right.Right = new RedBlackNode<int>(160, Colour.Red);
RedBlackTree<int> bst = new RedBlackTree<int>();
bst.Root = root;
bst.AssertValidTree();
}
// Removes the specified name+value from the tree, and returns a new tree.
// Sets fMissing if name cannot be found.
public ValueTree RemoveItem(ref bool fMissing, string name)
{
Contracts.AssertValue(name);
return(new ValueTree(RedBlackNode <EquatableObject> .RemoveItem(ref fMissing, _root, name, _hashCodeCache)));
}
public void InOrderSuccessor_Leaf()
{
RedBlackNode<int> leaf = new RedBlackNode<int>(50);
Assert.IsNull(leaf.InOrderSuccessor);
}
public void IsLeaf_False_Left()
{
var node = new RedBlackNode<int>(50);
node.Left = new RedBlackNode<int>(20);
Assert.IsFalse(node.IsLeaf);
}
public void InOrderSuccessor_RootRight()
{
RedBlackNode<int> rootRight = new RedBlackNode<int>(50)
{
Right = new RedBlackNode<int>(75)
};
Assert.AreEqual<int>(75, rootRight.InOrderSuccessor.Value);
}
public void IsLeaf_False_Right()
{
var node = new RedBlackNode<int>(50);
node.Right = new RedBlackNode<int>(70);
Assert.IsFalse(node.IsLeaf);
}
