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);
}
