public void Test_Integration_2() { PriorityQueue <double> q = null; double[] items = { 82, 100, 9.3, 1.19, 10, 29, 12, 9.0006, 22, 20.9, 207, 13.56, 30, 2, 66 }; SortedList <double, double> monitor = new SortedList <double, double>(); q = new MaxPriorityQueue <double>(); for (int i = 0; i < items.Length; i++) { q.Enqueue(items[i]); monitor.Add(-1 * items[i], items[i]); if (i == 3) { q.Dequeue(); monitor.Remove(-100); } else if (i == 8) { q.Dequeue(); monitor.Remove(-82); } } foreach (double monitorItem in monitor.Values) { Assert.AreEqual(monitorItem, q.Dequeue()); } }
public void Test_Dequeue() { PriorityQueue <double> q = null; q = new MaxPriorityQueue <double>(); q.Enqueue(1); q.Enqueue(2); q.Enqueue(3); Assert.AreEqual(3, q.Dequeue()); Assert.AreEqual(2, q.Dequeue()); Assert.AreEqual(1, q.Dequeue()); }
public void PriorityQueue_Test() { var queue = new MaxPriorityQueue <int>(); queue.Enqueue(10); queue.Enqueue(9); queue.Enqueue(1); queue.Enqueue(21); Assert.AreEqual(queue.Dequeue(), 21); Assert.AreEqual(queue.Dequeue(), 10); Assert.AreEqual(queue.Dequeue(), 9); Assert.AreEqual(queue.Dequeue(), 1); }
public void Dequeue() { var queue = new MaxPriorityQueue<int>(5); queue.Enqueue(4); queue.Enqueue(5); queue.Enqueue(0); queue.Enqueue(6); Assert.Equal(6, queue.Dequeue()); Assert.Equal(3, queue.Count); Assert.Equal(5, queue.Dequeue()); Assert.Equal(2, queue.Count); }
public void Dequeue() { var queue = new MaxPriorityQueue <int>(5); queue.Enqueue(4); queue.Enqueue(5); queue.Enqueue(0); queue.Enqueue(6); Assert.Equal(6, queue.Dequeue()); Assert.Equal(3, queue.Count); Assert.Equal(5, queue.Dequeue()); Assert.Equal(2, queue.Count); }
public void MaxPriorityQueueMovesNextHighestPriorityItemToHeadAfterDequeueItem() { var priorityQueue = new MaxPriorityQueue <string, int>(50); List <Tuple <string, int> > items = new List <Tuple <string, int> > { new Tuple <string, int>("A_50", 50), new Tuple <string, int>("A_41", 41), new Tuple <string, int>("A_38", 38), new Tuple <string, int>("A_37", 37), new Tuple <string, int>("A_23", 23), new Tuple <string, int>("A_11", 11), new Tuple <string, int>("A_5", 5), new Tuple <string, int>("A_3", 3), }.Randomize() .ToList(); priorityQueue.EnqueueRange(items); priorityQueue.Dequeue(); string item = priorityQueue.Peek(); Assert.AreEqual("A_41", item); }
public void Test_Remove() { PriorityQueue <double> q = null; double[] items = { 5, 85, 43, 2, 28, 99, 67, 1.98, 33, 19, 17, 44 }; SortedList <double, double> monitor = new SortedList <double, double>(); q = new MaxPriorityQueue <double>(7); for (int i = 0; i < items.Length; i++) { q.Enqueue(items[i]); monitor.Add(-1 * items[i], items[i]); } q.Remove(1.98); monitor.Remove(-1.98); q.Remove(85); monitor.Remove(-85); foreach (double monitorItem in monitor.Values) { Assert.AreEqual(monitorItem, q.Dequeue()); } }
public void Test_Dequeue_EmptyQ() { PriorityQueue <double> q = null; q = new MaxPriorityQueue <double>(); Assert.AreEqual(default(double), q.Dequeue()); }
public void Dequeue_Should_Always_Return_The_Max_Value() { var pq = new MaxPriorityQueue <int>(); pq.Enqueue(6); pq.Enqueue(9); pq.Enqueue(8); pq.Enqueue(3); pq.Enqueue(5); pq.Enqueue(1); pq.Enqueue(3); pq.Count.Should().Be(7); pq.Dequeue().Should().Be(9); pq.Count.Should().Be(6); pq.Dequeue().Should().Be(8); pq.Count.Should().Be(5); pq.Dequeue().Should().Be(6); pq.Count.Should().Be(4); pq.Dequeue().Should().Be(5); pq.Count.Should().Be(3); pq.Dequeue().Should().Be(3); pq.Count.Should().Be(2); pq.Dequeue().Should().Be(3); pq.Count.Should().Be(1); pq.Dequeue().Should().Be(1); pq.Count.Should().Be(0); }
public void ReplacingMaxElementAndCheckingIfExtractedInSortedOrder() { var pq = new MaxPriorityQueue <int, 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) { pq.Enqueue(el, -el); addedElements++; el += i; } } if (pq.Count != addedElements) { Assert.Fail(); } pq.ReplaceFirst(int.MinValue, 0); pq.ReplaceFirst(int.MinValue, 0); pq.ReplaceFirst(int.MinValue, 0); int removedElements = 0; var max = pq.Peek(); while (!pq.IsEmpty) { var kvp = pq.Peek(); if (max.Key < kvp.Key) { Assert.Fail(); } max = pq.Dequeue(); removedElements++; } Assert.IsTrue(pq.IsEmpty && pq.Count == 0 && addedElements == removedElements); }
public void HeapifyUnsortedCollectionAndCheckIfExtractedInSortedOrder() { var pq = new MaxPriorityQueue <int, int>(); var unsortedList = new List <KeyValuePair <int, 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(new KeyValuePair <int, int>(el, -el)); addedElements++; el += i; } } pq.Heapify(unsortedList); if (pq.Count != addedElements) { Assert.Fail("1"); } int removedElements = 0; var max = pq.Peek(); while (!pq.IsEmpty) { var kvp = pq.Peek(); if (max.Key < kvp.Key) { Assert.Fail("2"); } max = pq.Dequeue(); removedElements++; } Assert.IsTrue(pq.IsEmpty && pq.Count == 0 && addedElements == removedElements); }
public void AddingElementsWithCustomComparerAndCheckingIfExtractedInSortedOrder() { //Creating heap with reversed comparer var pq = new MaxPriorityQueue <int, int>(Comparer <int> .Create( (x, y) => y.CompareTo(x))); 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) { pq.Enqueue(el, -el); addedElements++; el += i; } } if (pq.Count != addedElements) { Assert.Fail(); } int removedElements = 0; // because of the reversed comparer var min = pq.Peek(); while (!pq.IsEmpty) { var kvp = pq.Peek(); if (min.Key > kvp.Key) { Assert.Fail(); } min = pq.Dequeue(); removedElements++; } Assert.IsTrue(pq.IsEmpty && pq.Count == 0 && addedElements == removedElements); }
public void DequeueMaxValue() { var sut = new MaxPriorityQueue <int, int>(); for (var i = 0; i < 50000; i++) { sut.Enqueue(i, i); } for (var i = 49999; i >= 0; i--) { Assert.AreEqual(i, sut.Dequeue()); } }
public void PrioritizeInAFifoManner() { var sut = new MaxPriorityQueue <int, int>(Stability.Fifo); for (var i = 0; i < 10000; i++) { for (var j = 0; j < 5; j++) { sut.Enqueue(i, i * 5 + j); } } for (var i = 9999; i >= 0; i--) { for (var j = 0; j < 5; j++) { Assert.AreEqual(i * 5 + j, sut.Dequeue()); } } }
public void MaintainMaxHeap() { var sut = new MaxPriorityQueue <int, int>(); var random = new Random(); var sortedResults = new List <int>(); for (var i = 0; i < 50000; i++) { sortedResults.Add(random.Next(1000)); } sut.AddRange(sortedResults, x => x); sortedResults = sortedResults.OrderByDescending(x => x).ToList(); for (var i = 0; i < 50000; i++) { Assert.AreEqual(sut.Dequeue(), sortedResults[i]); } }
public void HandleUnsortedInput() { var sut = new MaxPriorityQueue <int, int>(); var random = new Random(); for (var i = 0; i < 50000; i++) { var randomValue = random.Next(1000); sut.Enqueue(randomValue, randomValue); } var results = new List <int>(); for (var i = 0; i < 50000; i++) { results.Add(sut.Dequeue()); } var sortedResults = new List <int>(results).OrderByDescending(x => x).ToList(); CollectionAssert.AreEqual(sortedResults, results); }
public void MaxPriorityQueueDequeuDoesRemoveItemFromQueue() { var priorityQueue = new MaxPriorityQueue <string, int>(50); List <Tuple <string, int> > items = new List <Tuple <string, int> > { new Tuple <string, int>("A_50", 50), new Tuple <string, int>("A_41", 41), new Tuple <string, int>("A_38", 38), new Tuple <string, int>("A_37", 37), new Tuple <string, int>("A_23", 23), new Tuple <string, int>("A_11", 11), new Tuple <string, int>("A_5", 5), new Tuple <string, int>("A_3", 3), }.Randomize() .ToList(); priorityQueue.EnqueueRange(items); priorityQueue.Dequeue(); Assert.AreEqual(7, priorityQueue.Count); }
public void MaxPriorityQueueDequeueReturnsItemWithHighestPriority() { var priorityQueue = new MaxPriorityQueue <string, int>(50); List <Tuple <string, int> > items = new List <Tuple <string, int> > { new Tuple <string, int>("A_50", 50), new Tuple <string, int>("A_41", 41), new Tuple <string, int>("A_38", 38), new Tuple <string, int>("A_37", 37), new Tuple <string, int>("A_23", 23), new Tuple <string, int>("A_11", 11), new Tuple <string, int>("A_5", 5), new Tuple <string, int>("A_3", 3), }.Randomize() .ToList(); priorityQueue.EnqueueRange(items); string item = priorityQueue.Dequeue(); Assert.AreEqual("A_50", item); }
public int[] ExtractKclusters(double K) //(D+D) O(D) { //( K Log V) for (int i = 0; i < K - 1; i++) // K { int root = mxpQ.Peek().Vertex; //O(1) mxpQ.Dequeue(); //O(Log V) Parent[root] = -1; //O(1) } for (int i = 0; i < Parent.Length; i++) //O(D) { if (Parent[i] == -1) //O(1) { tmp[i] = i; //O(1) } else { tmp[i] = find_parent(Parent[i]); //MAX O(D) ONE TIME } } return(tmp);//O(1) }
public void MergingTwoPriorityQueuesAndCheckingIfExtractedInSortedOrder() { var pq1 = new MaxPriorityQueue <int, int>(); var pq2 = new MaxPriorityQueue <int, 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) { pq1.Enqueue(el, -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) { pq2.Enqueue(el, -el); addedElementsInSecondHeap++; el += i; } } if (pq1.Count != addedElementsInFirstHeap) { Assert.Fail("first priority queue incorrect count"); } if (pq2.Count != addedElementsInSecondHeap) { Assert.Fail("second priority queue incorrect count"); } var oldHeap = new MaxPriorityQueue <int, int>(); oldHeap.Heapify(pq1.ToArray()); pq1.Merge(pq2); pq2.Merge(oldHeap); int mergedHeapElements = addedElementsInFirstHeap + addedElementsInSecondHeap; if (pq1.Count != mergedHeapElements) { Assert.Fail("merged first with second incorect count"); } if (pq2.Count != mergedHeapElements) { Assert.Fail("merged second with first incorrect count"); } var max1 = pq1.Peek(); var max2 = pq2.Peek(); if (max1.Key != max2.Key) { Assert.Fail("merged priority queues min element is different"); } int removedElements = 0; while (!pq1.IsEmpty && !pq2.IsEmpty) { var kvp1 = pq1.Peek(); var kvp2 = pq2.Peek(); if (max1.Key < kvp1.Key) { Assert.Fail(); } if (max2.Key < kvp2.Key) { Assert.Fail(); } max1 = pq1.Dequeue(); max2 = pq2.Dequeue(); removedElements++; if (max1.Key != max2.Key) { Assert.Fail("merged priority queues min element is different"); } } Assert.IsTrue(pq1.IsEmpty && pq2.IsEmpty && pq1.Count == 0 && pq2.Count == 0 && mergedHeapElements == removedElements); }
public void AddingAfterClearingHeap() { var pq = new MaxPriorityQueue <int, 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) { pq.Enqueue(el, -el); addedElements++; el += i; } } if (pq.Count != addedElements) { Assert.Fail(); } pq.Clear(); if (pq.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) { pq.Enqueue(el, -el); addedElements++; el += i; } } if (pq.Count != addedElements) { Assert.Fail(); } int removedElements = 0; var max = pq.Peek(); while (!pq.IsEmpty) { var kvp = pq.Peek(); if (max.Key < kvp.Key) { Assert.Fail(); } max = pq.Dequeue(); removedElements++; } Assert.IsTrue(pq.IsEmpty && pq.Count == 0 && addedElements == removedElements); }