public void Test_IsEmpty_FilledQ() { PriorityQueue <double> q = null; q = new MaxPriorityQueue <double>(); q.Enqueue(1); q.Enqueue(2); Assert.IsFalse(q.IsEmpty); }
public void Test_Count() { PriorityQueue <double> q = null; q = new MaxPriorityQueue <double>(); q.Enqueue(1); q.Enqueue(2); Assert.AreEqual(2, q.Count); }
public void Test_Contains_Not() { PriorityQueue <double> q = null; q = new MaxPriorityQueue <double>(); q.Enqueue(3); q.Enqueue(2); q.Enqueue(1); Assert.IsFalse(q.Contains(4)); }
public void Test_Enqueue() { PriorityQueue <double> q = null; q = new MaxPriorityQueue <double>(); q.Enqueue(3); q.Enqueue(2); q.Enqueue(1); Assert.AreEqual(3, q.Peek()); }
public void Test_Capacity_AutoResize() { PriorityQueue <double> q = null; q = new MaxPriorityQueue <double>(3); q.Enqueue(1); q.Enqueue(2); q.Enqueue(3); q.Enqueue(4); Assert.AreEqual(6, q.Capacity); }
public void Test_PriorityUpgrade() { PriorityQueue <double> q = null; q = new MaxPriorityQueue <double>(); q.Enqueue(30); q.Enqueue(10); q.Enqueue(20); q.Remove(20); q.Enqueue(40); Assert.AreEqual(40, q.Peek()); }
public void Peek_Should_Return_The_Max_Value_Without_Removing() { var pq = new MaxPriorityQueue <int>(); pq.Enqueue(5); pq.Enqueue(3); pq.Enqueue(8); pq.Enqueue(1); var result = pq.Peek(); result.Should().Be(8); pq.Count.Should().Be(4); }
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 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 TryPeek_Should_Return_True_And_Outs_The_Max_Value_When_Queue_Is_Not_Empty() { var pq = new MaxPriorityQueue <int>(); pq.Enqueue(5); pq.Enqueue(3); pq.Enqueue(8); pq.Enqueue(1); var result = pq.TryPeek(out var value); result.Should().BeTrue(); value.Should().Be(8); pq.Count.Should().Be(4); }
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 MaxPriorityQueueDoesNotInsertItemToHeadIfItemIsLowerPriorityThanHead() { 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 originalHead = priorityQueue.Peek(); priorityQueue.Enqueue("A_49", 49); string newHead = priorityQueue.Peek(); Assert.AreEqual("A_50", originalHead); Assert.AreEqual("A_50", newHead); }
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 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 MaxQueueAddItemWithSize() { var queue = new MaxPriorityQueue <string, int>(Number); for (int i = 0; i < _array.Length; i++) { queue.Enqueue(_array[i].Item1, _array[i].Item2); } Assert.AreEqual(Number, queue.Count); }
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 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 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); }
private static void Main() { var maxPriorityQueue = new MaxPriorityQueue <string>(); maxPriorityQueue.Enqueue("Buy bread", 15); maxPriorityQueue.Enqueue("Buy milk", 10); maxPriorityQueue.Enqueue("Buy chocolate", 17); maxPriorityQueue.Enqueue("Go to shop", 30); maxPriorityQueue.Enqueue("Go home", 9); Console.WriteLine("Max priority queue: "); maxPriorityQueue.PrintQueue(); var minPriorityQueue = new MinPriorityQueue <string>(); minPriorityQueue.Enqueue("Buy bread", 15); minPriorityQueue.Enqueue("Buy milk", 10); minPriorityQueue.Enqueue("Buy chocolate", 17); minPriorityQueue.Enqueue("Go to shop", 30); minPriorityQueue.Enqueue("Go home", 9); Console.WriteLine("Min priority queue: "); minPriorityQueue.PrintQueue(); }
public void MaxPriorityQueue_SingleEnqueueDequeueTest() { string test = "test"; var queue = new MaxPriorityQueue <string>(); queue.Enqueue(test); Assert.IsFalse(queue.IsEmpty); Assert.AreEqual(1, queue.Size); var dequeued = queue.DequeueMax(); Assert.IsTrue(queue.IsEmpty); Assert.AreEqual(0, queue.Size); Assert.AreEqual(test, dequeued); }
public void SortByAscendingPriority() { var sut = new MaxPriorityQueue <int, int>(); var random = new Random(); var sortedResults = new List <int>(); for (var i = 0; i < 50000; i++) { var randomValue = random.Next(1000); sortedResults.Add(randomValue); sut.Enqueue(randomValue, randomValue); } sortedResults = sortedResults.OrderBy(x => x).ToList(); var results = sut.Sort().ToList(); CollectionAssert.AreEqual(sortedResults, results); }
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 Enqueue_Should_Create_Max_Priority_Queue_With_Max_Value_In_Root() { var pq = new MaxPriorityQueue <int>(); pq.Enqueue(6); pq.Enqueue(9); pq.Enqueue(8); pq.Enqueue(5); pq.Enqueue(1); pq.Enqueue(3); pq.Count.Should().Be(6); pq.First().Should().Be(9); }
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 MaxPriorityQueue_Full_EnumeratorTest() { var testData = new int[] { 12, 0, 3, 9, 1, 10, 4, 15, 5, 2, 13, 7, 8, 6, 11, 14 }; var queue = new MaxPriorityQueue <int>(); foreach (var item in testData) { queue.Enqueue(item); } Assert.IsFalse(queue.IsEmpty); Assert.AreEqual(testData.Length, queue.Size); int value = 15; foreach (var item in queue) { Assert.AreEqual(value--, item); } Assert.AreEqual(-1, value); }
public void prim_MST() { //(V Log V)+(V Log V) +(V^2)+(V^2 Log V) //(E Log V) while (Nodes.Count != 0) //V { Node currentNode = Nodes.Dequeue(); //O(Log V) Visited[currentNode.Vertex] = true; //O(1) MSTW += N[currentNode.Vertex].Value; //O(1) mxpQ.Enqueue(N[currentNode.Vertex]); //O(Log(V)) int count = 0; //O(1) RGBPixel ValueOfVaritx = data.ElementAt(currentNode.Vertex); // O(V) foreach (RGBPixel element in data) //V { N[count].Color = element; //O(1) if (currentNode.Vertex != count) //O(1) { int x, z, y, res; //O(1) x = Math.Abs(ValueOfVaritx.red - element.red); //O(1) y = Math.Abs(ValueOfVaritx.blue - element.blue); //O(1) z = Math.Abs(ValueOfVaritx.green - element.green); //O(1) res = x * x + y * y + z * z; //O(1) AdjNode Node1 = new AdjNode(count, Math.Sqrt(res)); //O(1) if (Visited[Node1.Des] == false) //O(1) { if (N[Node1.Des].Value > Node1.Weight) //O(1) { Nodes.ChangeKey(N[Node1.Des], Node1.Weight); //O(Log V) Parent[Node1.Des] = currentNode.Vertex; //O(1) } } } count++; //O(1) } } Console.WriteLine("MST is : " + Math.Round(MSTW, 1)); //O(1) CreateNewColors(k); //O(K D) }
public void EnumerateValuesMaxFirst() { var sut = new MaxPriorityQueue <int, int>(); var random = new Random(); var sortedResults = new List <int>(); for (var i = 0; i < 50000; i++) { var randomValue = random.Next(1000); sortedResults.Add(randomValue); sut.Enqueue(randomValue, randomValue); } sortedResults = sortedResults.OrderByDescending(x => x).ToList(); var j = 0; foreach (var result in sut) { Assert.AreEqual(sortedResults[j], result); j++; } }
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); }
public void MaxPriorityQueue_MultipleEnqueueDequeueTest() { var testData = new int[] { 12, 0, 3, 9, 1, 3, 4, 4, 5, 2, 13, 7, 8, 3, 11, 14, 15 }; var queue = new MaxPriorityQueue <int>(); foreach (var item in testData) { queue.Enqueue(item); } Assert.IsFalse(queue.IsEmpty); Assert.AreEqual(testData.Length, queue.Size); var dequeued = queue.DequeueMax(); Assert.IsFalse(queue.IsEmpty); Assert.AreEqual(testData.Length - 1, queue.Size); Assert.AreEqual(15, dequeued); dequeued = queue.DequeueMax(); Assert.IsFalse(queue.IsEmpty); Assert.AreEqual(testData.Length - 2, queue.Size); Assert.AreEqual(14, dequeued); dequeued = queue.Max; Assert.IsFalse(queue.IsEmpty); Assert.AreEqual(testData.Length - 2, queue.Size); Assert.AreEqual(13, dequeued); dequeued = queue.DequeueMax(); Assert.IsFalse(queue.IsEmpty); Assert.AreEqual(testData.Length - 3, queue.Size); Assert.AreEqual(13, dequeued); dequeued = queue.DequeueMax(); Assert.IsFalse(queue.IsEmpty); Assert.AreEqual(testData.Length - 4, queue.Size); Assert.AreEqual(12, dequeued); dequeued = queue.DequeueMax(); Assert.IsFalse(queue.IsEmpty); Assert.AreEqual(testData.Length - 5, queue.Size); Assert.AreEqual(11, dequeued); dequeued = queue.DequeueMax(); Assert.IsFalse(queue.IsEmpty); Assert.AreEqual(testData.Length - 6, queue.Size); Assert.AreEqual(9, dequeued); dequeued = queue.DequeueMax(); Assert.IsFalse(queue.IsEmpty); Assert.AreEqual(testData.Length - 7, queue.Size); Assert.AreEqual(8, dequeued); dequeued = queue.DequeueMax(); Assert.IsFalse(queue.IsEmpty); Assert.AreEqual(testData.Length - 8, queue.Size); Assert.AreEqual(7, dequeued); dequeued = queue.DequeueMax(); Assert.IsFalse(queue.IsEmpty); Assert.AreEqual(testData.Length - 9, queue.Size); Assert.AreEqual(5, dequeued); dequeued = queue.DequeueMax(); Assert.IsFalse(queue.IsEmpty); Assert.AreEqual(testData.Length - 10, queue.Size); Assert.AreEqual(4, dequeued); dequeued = queue.DequeueMax(); Assert.IsFalse(queue.IsEmpty); Assert.AreEqual(testData.Length - 11, queue.Size); Assert.AreEqual(4, dequeued); dequeued = queue.DequeueMax(); Assert.IsFalse(queue.IsEmpty); Assert.AreEqual(testData.Length - 12, queue.Size); Assert.AreEqual(3, dequeued); dequeued = queue.DequeueMax(); Assert.IsFalse(queue.IsEmpty); Assert.AreEqual(testData.Length - 13, queue.Size); Assert.AreEqual(3, dequeued); dequeued = queue.DequeueMax(); Assert.IsFalse(queue.IsEmpty); Assert.AreEqual(testData.Length - 14, queue.Size); Assert.AreEqual(3, dequeued); dequeued = queue.DequeueMax(); Assert.IsFalse(queue.IsEmpty); Assert.AreEqual(testData.Length - 15, queue.Size); Assert.AreEqual(2, dequeued); dequeued = queue.DequeueMax(); Assert.IsFalse(queue.IsEmpty); Assert.AreEqual(testData.Length - 16, queue.Size); Assert.AreEqual(1, dequeued); dequeued = queue.DequeueMax(); Assert.IsTrue(queue.IsEmpty); Assert.AreEqual(0, queue.Size); Assert.AreEqual(0, dequeued); }