public void BinomialMaxHeap_Test() { int nodeCount = 1000 * 10; //insert test var tree = new BinomialMaxHeap <int>(); for (int i = 0; i <= nodeCount; i++) { tree.Insert(i); } for (int i = 0; i <= nodeCount; i++) { tree.IncrementKey(i, i + 1); } int max = 0; for (int i = nodeCount; i >= 0; i--) { max = tree.ExtractMax(); Assert.AreEqual(max, i + 1); } //IEnumerable tests. Assert.AreEqual(tree.Count, tree.Count()); var rnd = new Random(); var testSeries = Enumerable.Range(0, nodeCount - 1).OrderBy(x => rnd.Next()).ToList(); foreach (var item in testSeries) { tree.Insert(item); } for (int i = 0; i < testSeries.Count; i++) { var incremented = testSeries[i] + rnd.Next(0, 1000); tree.IncrementKey(testSeries[i], incremented); testSeries[i] = incremented; } testSeries = testSeries.OrderByDescending(x => x).ToList(); for (int i = 0; i < nodeCount - 2; i++) { max = tree.ExtractMax(); Assert.AreEqual(testSeries[i], max); } //IEnumerable tests. Assert.AreEqual(tree.Count, tree.Count()); }
public void HeapifyUnsortedCollectionAndCheckIfExtractedInSortedOrder() { var heap = new BinomialMaxHeap <int>(); var unsortedList = new List <int>(); int maxHeapElement = 50000; int minHeapElement = -50000; int addedElements = 0; //Adding every seventh number, then every fifth number, //every third and at last all numbers //NOTE: some items are added more than once for (int i = 7; i > 0; i -= 2) { int el = minHeapElement; while (el <= maxHeapElement) { unsortedList.Add(el); addedElements++; el += i; } } heap.Heapify(unsortedList); if (heap.Count != addedElements) { Assert.Fail("1"); } int removedElements = 0; var max = heap.PeekMax(); while (!heap.IsEmpty) { if (max < heap.PeekMax()) { Assert.Fail("2"); } max = heap.PopMax(); removedElements++; } Assert.IsTrue(heap.IsEmpty && heap.Count == 0 && addedElements == removedElements); }
public void ReplacingMinElementAndCheckingIfExtractedInSortedOrder() { var heap = new BinomialMaxHeap <int>(); int maxHeapElement = 50000; int minHeapElement = -50000; int addedElements = 0; //Adding every seventh number, then every fifth number, //every third and at last all numbers //NOTE: some items are added more than once for (int i = 7; i > 0; i -= 2) { int el = minHeapElement; while (el <= maxHeapElement) { heap.Add(el); addedElements++; el += i; } } if (heap.Count != addedElements) { Assert.Fail(); } heap.ReplaceMax(int.MinValue); heap.ReplaceMax(int.MinValue); heap.ReplaceMax(int.MinValue); int removedElements = 0; var max = heap.PeekMax(); while (!heap.IsEmpty) { if (max < heap.PeekMax()) { Assert.Fail(); } max = heap.PopMax(); removedElements++; } Assert.IsTrue(heap.IsEmpty && heap.Count == 0 && addedElements == removedElements); }
public void ConvertingToBinomialMaxHeap() { var minHeap = new BinomialMinHeap <int>(); int maxHeapElement = 50000; int minHeapElement = -50000; int addedElements = 0; //Adding every seventh number, then every fifth number, //every third and at last all numbers //NOTE: some items are added more than once for (int i = 7; i > 0; i -= 2) { int el = minHeapElement; while (el <= maxHeapElement) { minHeap.Add(el); addedElements++; el += i; } } if (minHeap.Count != addedElements) { Assert.Fail(); } // Binomial max heap heapified from the min heap. Has to be the same // as the converted max heap var hepifiedMaxHeap = new BinomialMaxHeap <int>(); hepifiedMaxHeap.Heapify(minHeap.ToArray()); var maxHeap = minHeap.ToMaxHeap(); if (maxHeap.Count != hepifiedMaxHeap.Count) { Assert.Fail(); } var max1 = hepifiedMaxHeap.PeekMax(); var max2 = maxHeap.PeekMax(); int removedElements = 0; while (!hepifiedMaxHeap.IsEmpty && !maxHeap.IsEmpty) { if (max1 < hepifiedMaxHeap.PeekMax()) { Assert.Fail(); } if (max2 < maxHeap.PeekMax()) { Assert.Fail(); } max1 = hepifiedMaxHeap.PopMax(); max2 = maxHeap.PopMax(); removedElements++; if (max1 != max2) { Assert.Fail(); } } Assert.IsTrue(hepifiedMaxHeap.IsEmpty && maxHeap.IsEmpty && hepifiedMaxHeap.Count == 0 && maxHeap.Count == 0 && addedElements == removedElements); }
public void MergingTwoHeapsAndCheckingIfExtractedInSortedOrder() { var heap1 = new BinomialMaxHeap <int>(); var heap2 = new BinomialMaxHeap <int>(); int maxElementInFirstHeap = 100000; int minElementInFirstHeap = 0; int addedElementsInFirstHeap = 0; //Adding every seventh number, then every fifth number, //every third and at last all numbers //NOTE: some items are added more than once for (int i = 7; i > 0; i -= 2) { int el = minElementInFirstHeap; while (el <= maxElementInFirstHeap) { heap1.Add(el); addedElementsInFirstHeap++; el += i; } } int maxElementInSecondHeap = 50000; int minElementInSecondHeap = -50000; int addedElementsInSecondHeap = 0; //Adding every seventh number, then every fifth number, //every third and at last all numbers //NOTE: some items are added more than once for (int i = 7; i > 0; i -= 2) { int el = minElementInSecondHeap; while (el <= maxElementInSecondHeap) { heap2.Add(el); addedElementsInSecondHeap++; el += i; } } if (heap1.Count != addedElementsInFirstHeap) { Assert.Fail("first heap incorrect count"); } if (heap2.Count != addedElementsInSecondHeap) { Assert.Fail("second heap incorrect count"); } var oldHeap1 = new BinomialMaxHeap <int>(); oldHeap1.Heapify(heap1.ToArray()); var oldHeap2 = new BinomialMaxHeap <int>(); oldHeap2.Heapify(heap2.ToArray()); heap1.Merge(heap2); heap2.Heapify(oldHeap2.ToArray()); heap2.Merge(oldHeap1); int mergedHeapElements = addedElementsInFirstHeap + addedElementsInSecondHeap; if (heap1.Count != mergedHeapElements) { Assert.Fail("merged first with second incorect count"); } if (heap2.Count != mergedHeapElements) { Assert.Fail("merged second with first incorrect count"); } var max1 = heap1.PeekMax(); var max2 = heap2.PeekMax(); if (max1 != max2) { Assert.Fail("merged heaps min element is different"); } int removedElements = 0; while (!heap1.IsEmpty && !heap2.IsEmpty) { if (max1 < heap1.PeekMax()) { Assert.Fail(); } if (max2 < heap2.PeekMax()) { Assert.Fail(); } max1 = heap1.PopMax(); max2 = heap2.PopMax(); removedElements++; if (max1 != max2) { Assert.Fail("merged heaps min element is different"); } } Assert.IsTrue(heap1.IsEmpty && heap2.IsEmpty && heap1.Count == 0 && heap2.Count == 0 && mergedHeapElements == removedElements); }
public void AddingAfterClearingHeap() { var heap = new BinomialMaxHeap <int>(); int maxHeapElement = 50000; int minHeapElement = -50000; int addedElements = 0; //Adding every seventh number, then every fifth number, //every third and at last all numbers //NOTE: some items are added more than once for (int i = 7; i > 0; i -= 2) { int el = minHeapElement; while (el <= maxHeapElement) { heap.Add(el); addedElements++; el += i; } } if (heap.Count != addedElements) { Assert.Fail(); } heap.Clear(); if (heap.Count != 0) { Assert.Fail(); } addedElements = 0; //Adding every seventh number, then every fifth number, //every third and at last all numbers //NOTE: some items are added more than once for (int i = 7; i > 0; i -= 2) { int el = minHeapElement; while (el < maxHeapElement) { heap.Add(el); addedElements++; el += i; } } if (heap.Count != addedElements) { Assert.Fail(); } int removedElements = 0; var max = heap.PeekMax(); while (!heap.IsEmpty) { if (max < heap.PeekMax()) { Assert.Fail(); } max = heap.PopMax(); removedElements++; } Assert.IsTrue(heap.IsEmpty && heap.Count == 0 && addedElements == removedElements); }
public void BinomialMaxHeap_Test() { int nodeCount = 1000 * 10; //insert test var tree = new BinomialMaxHeap <int>(); var nodePointers = new List <BinomialHeapNode <int> >(); for (int i = 0; i <= nodeCount; i++) { var node = tree.Insert(i); nodePointers.Add(node); var theoreticalTreeCount = Convert.ToString(i + 1, 2).Replace("0", "").Length; var actualTreeCount = tree.heapForest.Count(); Assert.AreEqual(theoreticalTreeCount, actualTreeCount); } for (int i = 0; i <= nodeCount; i++) { nodePointers[i].Value++; tree.IncrementKey(nodePointers[i]); } int max = 0; for (int i = nodeCount; i >= 0; i--) { max = tree.ExtractMax(); Assert.AreEqual(i + 1, max); } nodePointers.Clear(); var rnd = new Random(); var testSeries = Enumerable.Range(0, nodeCount - 1).OrderBy(x => rnd.Next()).ToList(); foreach (var item in testSeries) { nodePointers.Add(tree.Insert(item)); } max = tree.ExtractMax(); nodePointers = nodePointers.Where(x => x.Value != max).ToList(); var resultSeries = new List <int>(); for (int i = 0; i < nodePointers.Count; i++) { nodePointers[i].Value = nodePointers[i].Value + rnd.Next(0, 1000); tree.IncrementKey(nodePointers[i]); } foreach (var item in nodePointers) { resultSeries.Add(item.Value); } resultSeries = resultSeries.OrderByDescending(x => x).ToList(); for (int i = 0; i < nodeCount - 2; i++) { max = tree.ExtractMax(); Assert.AreEqual(resultSeries[i], max); } }