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