} //end-do-test /// <summary> /// Testing helper to assert that all items at every level of the tree has the same color and each level has different color than the other levels /// </summary> private static void AssetLevelsDifferentColors <TKey, TValue>(RedBlackTreeMap <TKey, TValue> redBlackTree) where TKey : IComparable <TKey> { var root = redBlackTree.Root; var height = GetMaxHeight(root); var levels = new List <List <RedBlackTreeMapNode <TKey, TValue> > >(); // Initialize the list for (var i = 0; i < height; ++i) { levels.Add(new List <RedBlackTreeMapNode <TKey, TValue> >()); } var levelsIndex = 0; var nodesInNextLevel = 0; var nodesInCurrentLevel = 1; var queue = new Queue <RedBlackTreeMapNode <TKey, TValue> >(); queue.Enqueue(root); while (queue.Count > 0) { var curr = queue.Dequeue(); nodesInCurrentLevel--; if (curr != null) { levels[levelsIndex].Add(curr); queue.Enqueue(curr.LeftChild); queue.Enqueue(curr.RightChild); nodesInNextLevel += 2; } if (nodesInCurrentLevel == 0) { levelsIndex++; nodesInCurrentLevel = nodesInNextLevel; nodesInNextLevel = 0; } } // [*] Assert that levels have different alternating colors: var color = RedBlackTreeColors.Black; for (var i = 0; i < levels.Count; ++i) { for (var j = 0; j < levels[i].Count; ++j) { Assert.True(levels[i][j].Color == color); //if (levels[i][j].Color != color) //Console.WriteLine(" [-] Level: {0}. Node Value: {1}. Node color: {2}. Expected color: {3}.", i, levels[i][j].Value, levels[i][j].Color, color.ToString()); } color = color == RedBlackTreeColors.Black ? RedBlackTreeColors.Red : RedBlackTreeColors.Black; } } //end-test-case
private void BasicMap() { const int Count = 1000; IOrderedMap <int, float> map; switch (args[0]) { default: throw new ArgumentException(); case "avl": map = new AVLTreeMap <int, float>(); break; case "redblack": map = new RedBlackTreeMap <int, float>(); break; case "splay": map = new SplayTreeMap <int, float>(); break; } BasicMapCore(map, Count); }
public void ContatinsValueBeforeAndAfterUpdatingValue() { var tree = new RedBlackTreeMap <int, int>(); int elementsCount = 1000; //Adding every seventh number, then every fifth number, //every third and at last all numbers for (int i = 7; i > 0; i -= 2) { int el = 0; while (el < elementsCount) { if (!tree.ContainsKey(el)) { tree.Add(el, el); } el += i; } } // Check if values are contained, make them negative and check again. Skip zero... for (int i = 1; i < elementsCount; i++) { if (!tree.ContainsValue(i)) { Assert.Fail(); } tree[i] = -i; if (tree.ContainsValue(i)) { Assert.Fail(); } if (!tree.ContainsValue(-i)) { Assert.Fail(); } } int last = -1; int count = 0; bool elementsAreSorted = true; foreach (var item in tree) { if (last > item.Key) { elementsAreSorted = false; } last = item.Key; count++; } Trace.WriteLine(tree.Count); Assert.IsTrue(tree.Count == elementsCount && elementsAreSorted && count == elementsCount); }
public RedBlackUniqueNonClusteredIndex(Expression <Func <TRow, TIndexKey> > keySelector, IComparer <TIndexKey>?comparer, bool allowNullKeys) { var selector = keySelector.Compile(); _keySelector = allowNullKeys ? selector : KeySelector.ThrowOnNullKey(selector); _map = new RedBlackTreeMap <TIndexKey, DataPage <TPrimaryKey, TRow> >(comparer); }
public void AddingOneMillionInts() { var tree = new RedBlackTreeMap <int, int>(); for (int i = 0; i < 1000000; i++) { tree.Add(i, i); } Assert.IsTrue(tree.Count == 1000000); }
public RedBlackNonUniqueNonClusteredIndex(Expression <Func <TRow, TIndexKey> > keySelector, IComparer <TIndexKey>?comparer, bool allowNullKeys, IComparer <TPrimaryKey> primaryKeyComparer) { _primaryKeyComparer = new AnonymousComparer <DataPage <TPrimaryKey, TRow>, TPrimaryKey>(k => k.PrimaryKey, primaryKeyComparer); var selector = keySelector.Compile(); _keySelector = allowNullKeys ? selector : KeySelector.ThrowOnNullKey(selector); _map = new RedBlackTreeMap <TIndexKey, Set <DataPage <TPrimaryKey, TRow> > >(comparer); }
public void CheckIfNodeIsInvalidatedAfterClearingAndAfterRemoval() { var tree = new RedBlackTreeMap <int, int>(); tree.Add(2, 2); tree.Add(1, 1); tree.Add(3, 3); // Tree looks like this: // 2 // / \ // 1 3 var node1 = tree.Root.Left; var node2 = tree.Root; var node3 = tree.Root.Right; tree.Remove(2); if (node2.Left != null || node2.Right != null) { Assert.Fail("2"); } tree.Remove(3); if (node3.Left != null || node3.Right != null) { Assert.Fail("3"); } tree.Remove(1); if (node1.Left != null || node1.Right != null) { Assert.Fail("1"); } tree.Add(2, 2); tree.Add(1, 1); tree.Add(3, 3); node1 = tree.Root.Left; node2 = tree.Root; node3 = tree.Root.Right; tree.Clear(); Assert.IsTrue(node1.Left == null && node1.Right == null && node2.Left == null && node2.Right == null && node3.Left == null && node3.Right == null && tree.Root == null && tree.Count == 0); }
public void SortedElementsAfterAddingAndRemoving() { var tree = new RedBlackTreeMap <int, int>(); int elementsCount = 100000; //Adding every seventh number, then every fifth number, //every third and at last all numbers for (int i = 7; i > 0; i -= 2) { int el = 0; while (el < elementsCount) { if (!tree.ContainsKey(el)) { tree.Add(el, el); } el += i; } } bool removedEverything = true; //Removing every second number for (int i = 0; i < elementsCount; i += 2) { if (!tree.Remove(i)) { removedEverything = false; } } int last = -1; int count = 0; bool elementsAreSorted = true; foreach (var item in tree) { if (last > item.Key) { elementsAreSorted = false; } last = item.Key; count++; } Assert.IsTrue(tree.Count == count && elementsAreSorted && removedEverything); }
public void RemoveRootEveryTimeUntilTreeElementsAreHalfed() { var tree = new RedBlackTreeMap <int, int>(); int elementsCount = 100000; //Adding every seventh number, then every fifth number, //every third and at last all numbers for (int i = 7; i > 0; i -= 2) { int el = 0; while (el < elementsCount) { if (!tree.ContainsKey(el)) { tree.Add(el, el); } el += i; } } bool removedEverything = true; while (tree.Count > elementsCount / 2) { if (!tree.Remove(tree.Root.Value)) { removedEverything = false; } } int last = -1; int count = 0; bool elementsAreSorted = true; foreach (var item in tree) { if (last > item.Key) { elementsAreSorted = false; } last = item.Key; count++; } Assert.IsTrue(tree.Count == count && elementsAreSorted && count == elementsCount / 2 && removedEverything); }
public void BalancingCheckWithRootRotation() { var tree = new RedBlackTreeMap <int, int>(); tree.Add(1, 1); tree.Add(2, 2); tree.Add(3, 3); /* * After balance the tree should look like this: * 2 * / \ * 1 3 */ Assert.IsTrue(tree.Root.Value == 2 && tree.Root.Left.Value == 1 && tree.Root.Right.Value == 3); }
private void EnumerateMap() { const int Count = 1000; IOrderedMap <int, float> map; switch (args[0]) { default: throw new ArgumentException(); case "avl": map = new AVLTreeMap <int, float>(); break; case "redblack": map = new RedBlackTreeMap <int, float>(); break; case "splay": map = new SplayTreeMap <int, float>(); break; } bool fast; switch (args[1]) { default: throw new ArgumentException(); case "fast": fast = true; break; case "robust": fast = false; break; } EnumerateCore(map, Count, fast); }
public void AddingElementsWithIndexer() { var tree = new RedBlackTreeMap <int, int>(); int elementsCount = 100000; //Adding every seventh number, then every fifth number, //every third and at last all numbers for (int i = 7; i > 0; i -= 2) { int el = 0; while (el < elementsCount) { if (!tree.ContainsKey(el)) { tree[el] = el; } el += i; } } int last = -1; int count = 0; bool elementsAreSorted = true; foreach (var item in tree) { if (last > item.Key) { elementsAreSorted = false; } last = item.Key; count++; } Assert.IsTrue(tree.Count == elementsCount && elementsAreSorted && count == elementsCount); }
public void RemoveAllExceptOne() { var tree = new RedBlackTreeMap <int, int>(); int elementsCount = 100000; //Adding every seventh number, then every fifth number, //every third and at last all numbers for (int i = 7; i > 0; i -= 2) { int el = 0; while (el < elementsCount) { if (!tree.ContainsKey(el)) { tree.Add(el, el); } el += i; } } bool removedEverything = true; for (int i = 0; i < elementsCount - 1; i++) { if (!tree.Remove(i)) { removedEverything = false; } } Assert.IsTrue(tree.Count == 1 && removedEverything && tree.Root.Value == elementsCount - 1 && tree.Root.Left == null && tree.Root.Right == null); }
/// <summary> /// Clears this instance. /// </summary> public void Clear() { _collection = new RedBlackTreeMap <TKey, TValue>(false); }
/// <summary> /// Constructor. /// </summary> public SortedDictionary() { _collection = new RedBlackTreeMap <TKey, TValue>(false); }
/// <summary> /// Constructor. /// </summary> public SortedDictionary() { _collection = new RedBlackTreeMap <TKey, TValue>(allowDuplicates: false); }
public static void DoTest() { // Red-Black Tree Map collection var redBlackTree = new RedBlackTreeMap <int, string>(allowDuplicates: false); // Testing data KeyValuePair <int, string>[] values = new KeyValuePair <int, string> [10]; // Prepare the values array for (int i = 1; i <= 10; ++i) { var keyValPair = new KeyValuePair <int, string>(i, String.Format("Integer: {0}", i)); values[i - 1] = keyValPair; } // Test singular insert for (int i = 0; i < 10; ++i) { redBlackTree.Insert(values[i].Key, values[i].Value); } Assert.True(redBlackTree.Count == values.Length, "Expected the same number of items."); Assert.True(redBlackTree.Height < redBlackTree.Count, "Fail! Tree doesn't rebalance against sorted elements!"); redBlackTree.Clear(); // Test collection insert redBlackTree.Insert(values); Assert.True(redBlackTree.Height < redBlackTree.Count, "Fail! Tree doesn't rebalance against sorted elements!"); // Test enumeration of key-value pairs is still in oreder var enumerator = redBlackTree.GetInOrderEnumerator(); for (int i = 0; i < 10; ++i) { if (enumerator.MoveNext()) { var curr = enumerator.Current; if (curr.Key != values[i].Key || curr.Value != values[i].Value) { throw new Exception(); } } } // Test against re-shuffled insertions (not like above order) redBlackTree = new RedBlackTreeMap <int, string>(allowDuplicates: false); redBlackTree.Insert(4, "int4"); redBlackTree.Insert(5, "int5"); redBlackTree.Insert(7, "int7"); redBlackTree.Insert(2, "int2"); redBlackTree.Insert(1, "int1"); redBlackTree.Insert(3, "int3"); redBlackTree.Insert(6, "int6"); //redBlackTree.Insert(0, "int0"); redBlackTree.Insert(8, "int8"); redBlackTree.Insert(10, "int10"); redBlackTree.Insert(9, "int9"); Assert.True(redBlackTree.Count == values.Length, "Expected the same number of items."); Assert.True(redBlackTree.Height < redBlackTree.Count, "Fail! Tree doesn't rebalance against sorted elements!"); // ASSERT INSERTING DUPLICATES WOULD BREAK var insert_duplicate_passed = true; try { // 2 already exists in tree redBlackTree.Insert(2, "int2"); insert_duplicate_passed = true; } catch { insert_duplicate_passed = false; } Assert.True(insert_duplicate_passed == false, "Fail! The tree doesn't allow duplicates"); // Test find Assert.True(redBlackTree.Find(5).Key == 5, "Wrong find result!"); Assert.True(redBlackTree.FindMin().Key == 1, "Wrong min!"); Assert.True(redBlackTree.FindMax().Key == 10, "Wrong max!"); // Assert find raises exception on non-existing elements bool threwKeyNotFoundError = false; try { redBlackTree.Find(999999999); threwKeyNotFoundError = false; } catch (KeyNotFoundException) { threwKeyNotFoundError = true; } Assert.True(true == threwKeyNotFoundError, "Expected to catch KeyNotFoundException."); // PRINT TREE //Console.WriteLine("********************"); //Console.WriteLine(" [*] RED-BLACK TREE:\r\n"); //Console.WriteLine("********************"); //Console.WriteLine(redBlackTree.DrawTree()); //Console.WriteLine("\r\n"); // Assert count Assert.True(redBlackTree.Count == 10); // Assert existence and nonexistence of some items Assert.True(redBlackTree.Contains(1) == true); Assert.True(redBlackTree.Contains(3) == true); Assert.True(redBlackTree.Contains(999) == false); // ASSERT THAT EACH LEVEL HAS A DIFFERENT COLOR // TODO: Wrong color element "int4" // AssetLevelsDifferentColors(redBlackTree); // Do some deletions redBlackTree.Remove(7); redBlackTree.Remove(1); redBlackTree.Remove(3); // Assert count Assert.True(redBlackTree.Count == 7); // Assert nonexistence of previously existing items Assert.True(redBlackTree.Contains(1) == false); Assert.True(redBlackTree.Contains(3) == false); // Remove root value var oldRootKey = redBlackTree.Root.Key; redBlackTree.Remove(redBlackTree.Root.Key); // Assert count Assert.True(redBlackTree.Count == 6); // Assert nonexistence of old root's key Assert.True(redBlackTree.Contains(oldRootKey) == false); //// PRINT TREE //Console.WriteLine("********************"); //Console.WriteLine(" [*] RED-BLACK TREE:\r\n"); //Console.WriteLine("********************"); //Console.WriteLine(redBlackTree.DrawTree(includeValues: true)); //Console.WriteLine("\r\n"); //Console.ReadLine(); }//end-do-test
public static IEnumerable <(TKey Key, TItem Value)> SeekMany <TKey, TItem>(this RedBlackTreeMap <TKey, TItem> source, IEnumerable <TKey> keys) { foreach (var key in keys)
/// <summary> /// Clears this instance. /// </summary> public void Clear() { _collection = new RedBlackTreeMap <TKey, TValue>(allowDuplicates: false); }
public void UpdatingElementsWithIndexerUsingTryGetValueMethodToGetValue() { var tree = new RedBlackTreeMap <int, int>(); int elementsCount = 100000; //Adding every seventh number, then every fifth number, //every third and at last all numbers for (int i = 7; i > 0; i -= 2) { int el = 0; while (el < elementsCount) { if (!tree.ContainsKey(el)) { tree.Add(el, el); } el += i; } } bool removedEverything = true; //Removing every second number for (int i = 0; i < elementsCount; i += 2) { if (!tree.Remove(i)) { removedEverything = false; } } // Make all values negative for (int i = 0; i < elementsCount; i++) { int value; if (tree.TryGetValue(i, out value)) { tree[value] = -value; } } int last = -1; int count = 0; bool elementsAreSorted = true; foreach (var item in tree) { if (item.Value > 0) { Assert.Fail(); } if (last > item.Key) { elementsAreSorted = false; } last = item.Key; count++; } Trace.WriteLine(tree.Count); Assert.IsTrue(tree.Count == count && elementsAreSorted && removedEverything); }
public RedBlackClusteredIndex(Expression <Func <TRow, TPrimaryKey> > keySelector, IComparer <TPrimaryKey>?comparer) { _keySelector = KeySelector.ThrowOnNullKey(keySelector.Compile()); _map = new RedBlackTreeMap <TPrimaryKey, DataPage <TPrimaryKey, TRow> >(comparer); }