public static void DoTest() { BinaryMinHeap <long> minHeap = new BinaryMinHeap <long>(Comparer <long> .Default); minHeap.Add(23); minHeap.Add(42); minHeap.Add(4); minHeap.Add(16); minHeap.Add(8); minHeap.Add(15); minHeap.Add(9); minHeap.Add(55); minHeap.Add(0); minHeap.Add(34); minHeap.Add(12); minHeap.Add(2); minHeap.Add(93); minHeap.Add(14); minHeap.Add(27); var array = minHeap.ToArray(); Assert.True(array.Length == minHeap.Count, "Wrong size."); var list = minHeap.ToList(); Assert.True(list.Count == minHeap.Count, "Wrong size."); array.HeapSortDescending(); var maxHeap = minHeap.ToMaxHeap(); Assert.True(maxHeap.Peek() == array[0], "Wrong maximum."); }
public static void DoTest () { BinaryMinHeap<long> minHeap = new BinaryMinHeap<long> (Comparer<long>.Default); minHeap.Add (23); minHeap.Add (42); minHeap.Add (4); minHeap.Add (16); minHeap.Add (8); minHeap.Add (15); minHeap.Add (9); minHeap.Add (55); minHeap.Add (0); minHeap.Add (34); minHeap.Add (12); minHeap.Add (2); minHeap.Add (93); minHeap.Add (14); minHeap.Add (27); var array = minHeap.ToArray (); Debug.Assert (array.Length == minHeap.Count, "Wrong size."); var list = minHeap.ToList (); Debug.Assert (list.Count == minHeap.Count, "Wrong size."); array.HeapSortDescending(); var maxHeap = minHeap.ToMaxHeap (); Debug.Assert (maxHeap.Peek() == array[0], "Wrong maximum."); }
public static bool IsRightOrderInHeap <T>(BinaryMinHeap <T> binaryMinHeap) where T : IComparable <T> { var array = binaryMinHeap.ToArray(); for (int i = 0; i * 2 + 1 < array.Length; ++i) { int leftChildIndex = i * 2 + 1; int rightChildIndex = leftChildIndex + 1; if (array[i].CompareTo(array[leftChildIndex]) > 0) { return(false); } if (rightChildIndex < array.Length && array[i].CompareTo(array[rightChildIndex]) > 0) { return(true); } } return(true); }
public void ConvertingToBinaryMaxHeap() { var minHeap = new BinaryMinHeap <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(); } // Binary min heap with reversed comparer. Have to be the same as the max heap var reversedMinHeap = new BinaryMinHeap <int>(Comparer <int> .Create( (x, y) => y.CompareTo(x))); reversedMinHeap.Heapify(minHeap.ToArray()); var maxHeap = minHeap.ToMaxHeap(); if (maxHeap.Count != reversedMinHeap.Count) { Assert.Fail(); } var max1 = reversedMinHeap.PeekMin(); var max2 = maxHeap.PeekMax(); int removedElements = 0; while (!reversedMinHeap.IsEmpty && !maxHeap.IsEmpty) { if (max1 < reversedMinHeap.PeekMin()) { Assert.Fail(); } if (max2 < maxHeap.PeekMax()) { Assert.Fail(); } max1 = reversedMinHeap.PopMin(); max2 = maxHeap.PopMax(); removedElements++; if (max1 != max2) { Assert.Fail(); } } Assert.IsTrue(reversedMinHeap.IsEmpty && maxHeap.IsEmpty && reversedMinHeap.Count == 0 && maxHeap.Count == 0 && addedElements == removedElements); }
public void MergingTwoHeapsAndCheckingIfExtractedInSortedOrder() { var heap1 = new BinaryMinHeap <int>(); var heap2 = new BinaryMinHeap <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 oldHeap = new BinaryMinHeap <int>(); oldHeap.Heapify(heap1.ToArray()); heap1.Merge(heap2); heap2.Merge(oldHeap); 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 min1 = heap1.PeekMin(); var min2 = heap2.PeekMin(); if (min1 != min2) { Assert.Fail("merged heaps min element is different"); } int removedElements = 0; while (!heap1.IsEmpty && !heap2.IsEmpty) { if (min1 > heap1.PeekMin()) { Assert.Fail(); } if (min2 > heap2.PeekMin()) { Assert.Fail(); } min1 = heap1.PopMin(); min2 = heap2.PopMin(); removedElements++; if (min1 != min2) { Assert.Fail("merged heaps min element is different"); } } Assert.IsTrue(heap1.IsEmpty && heap2.IsEmpty && heap1.Count == 0 && heap2.Count == 0 && mergedHeapElements == removedElements); }