public void PriorityQueueTest()
{
Comparison <int> comparison = (x, y) => x.CompareTo(y);
for (int i = 0; i < 10; i++)
{
for (int j = 1; j < 100; j++)
{
int[] data = Utilities.ArrayUtilities.CreateRandomArray(j, 0, 1000);
MaxPriorityQueue <int> queue = new MaxPriorityQueue <int>();
for (int k = 0; k < data.Length; k++)
{
queue.Insert(data[k]);
Assert.AreEqual(k + 1, queue.Count);
}
int previous = queue.Pop();
while (queue.Count > 0)
{
int current = queue.Pop();
Assert.IsTrue(comparison(previous, current) >= 0);
previous = current;
}
Assert.IsTrue(queue.IsEmpty);
}
}
}
static void Main(string[] args)
{
MaxPriorityQueue <IHeapValue> maxheap = new MaxPriorityQueue <IHeapValue>();
MinPriorityQueue <IHeapValue> minheap = new MinPriorityQueue <IHeapValue>();
List <IHeapValue> list = new List <IHeapValue>();
Random rnd = new Random(DateTime.Now.Millisecond);
for (int i = 0; i < 10; i++)
{
HeapNode hn = new HeapNode()
{
Value = rnd.Next(0, 100)
};
list.Add(hn);
maxheap.Insert(hn);
minheap.Insert(hn);
}
Console.WriteLine("RandomData:");
list.ForEach(n => Console.Write("{0},", n.Value));
Console.WriteLine(Environment.NewLine + "MaxHeapOutput:");
while (!maxheap.IsEmpty)
{
Console.Write("{0},", maxheap.ExtractMax().Value);
}
Console.WriteLine(Environment.NewLine + "MinHeapOutput:");
while (!minheap.IsEmpty)
{
Console.Write("{0},", minheap.ExtractMin().Value);
}
Console.ReadKey();
}
public void PriorityQueueTest()
{
Comparison<int> comparison = (x, y) => x.CompareTo(y);
for (int i = 0; i < 10; i++)
{
for (int j = 1; j < 100; j++)
{
int[] data = Utilities.ArrayUtilities.CreateRandomArray(j, 0, 1000);
MaxPriorityQueue<int> queue = new MaxPriorityQueue<int>();
for(int k = 0; k < data.Length; k++)
{
queue.Insert(data[k]);
Assert.AreEqual(k + 1, queue.Count);
}
int previous = queue.Pop();
while(queue.Count > 0)
{
int current = queue.Pop();
Assert.IsTrue(comparison(previous, current) >= 0);
previous = current;
}
Assert.IsTrue(queue.IsEmpty);
}
}
}
} // end of BuildAccumulator(List<String> query)
/// <summary>
/// Creates a new priority queue by inserting the rank of the document and document id
/// </summary>
/// <returns> a priority queue with max heap property</returns>
private MaxPriorityQueue BuildPriorityQueue()
{
//temporary variable to hold the doc weight
double normalizer;
//temporary variable to hold the final ranking value of that document
double finalRank;
//Make a new priority queue
MaxPriorityQueue priorityQueue = new MaxPriorityQueue();
//for every key value in the Accumulator divide A_{d} by L_{d}
foreach (KeyValuePair <int, double> candidate in this.accumulator)
{
//get corresponding L_{d} value according to ranking system
normalizer = this.rankVariant.GetDocumentWeight(candidate.Key, this.index);
// divide Accumulated Value A_{d} by L_{d}
finalRank = (double)candidate.Value / normalizer;
//add to list to perform priority queue on
priorityQueue.MaxHeapInsert(finalRank, candidate.Key);
}
return(priorityQueue);
} // end of BuildPriorityQueuer();
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 MaxPriorityQueueEnumerationYieldsLowestPriorityAsLastItem()
{
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);
List <string> list = new List <string>();
foreach (string s in priorityQueue)
{
list.Add(s);
}
Assert.AreEqual("A_3", list.Last());
}
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 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_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 CreateTiers()
{
Console.WriteLine("Creating Tier Indices");
List <Posting> termPostings;
List <string> vocab = this.tempPostingMap.Keys.ToList();
foreach (string term in vocab)
{
//get postings for the term
termPostings = tempPostingMap[term];
//make priority queue
MaxPriorityQueue tierQueue = new MaxPriorityQueue();
foreach (Posting p in termPostings)
{
tierQueue.MaxHeapInsert(p.Positions.Count, p.DocumentId);
}
//Create the Tiers using a priority queue
List <MaxPriorityQueue.InvertedIndex> temp = tierQueue.RetrieveTier(1);
tempTier1.Add(term, temp);
temp = tierQueue.RetrieveTier(10);
tempTier2.Add(term, temp);
temp = tierQueue.RetrieveTier(100);
tempTier3.Add(term, temp);
}
}
static void Main(string[] args)
{
MaxPriorityQueue<IHeapValue> maxheap = new MaxPriorityQueue<IHeapValue>();
MinPriorityQueue<IHeapValue> minheap = new MinPriorityQueue<IHeapValue>();
List<IHeapValue> list = new List<IHeapValue>();
Random rnd = new Random(DateTime.Now.Millisecond);
for (int i = 0; i < 10; i++)
{
HeapNode hn = new HeapNode() { Value = rnd.Next(0, 100) };
list.Add(hn);
maxheap.Insert(hn);
minheap.Insert(hn);
}
Console.WriteLine("RandomData:");
list.ForEach(n => Console.Write("{0},", n.Value));
Console.WriteLine(Environment.NewLine + "MaxHeapOutput:");
while (!maxheap.IsEmpty)
{
Console.Write("{0},", maxheap.ExtractMax().Value);
}
Console.WriteLine(Environment.NewLine + "MinHeapOutput:");
while (!minheap.IsEmpty)
{
Console.Write("{0},", minheap.ExtractMin().Value);
}
Console.ReadKey();
}
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 Add_ExpectCountIncrement()
{
var queue = new MaxPriorityQueue<int>();
queue.Add(ITEM);
Assert.AreEqual(1, queue.Count);
}
public void Test_Capacity()
{
PriorityQueue <double> q = null;
q = new MaxPriorityQueue <double>(10);
Assert.AreEqual(10, q.Capacity);
}
public void Test_Capacity_NegativeInput()
{
PriorityQueue <double> q = null;
q = new MaxPriorityQueue <double>(-4);
Assert.AreEqual(64, q.Capacity);
}
public void Test_Capacity_Default()
{
PriorityQueue <double> q = null;
q = new MaxPriorityQueue <double>();
Assert.AreEqual(64, q.Capacity);
}
public void Test_Dequeue_EmptyQ()
{
PriorityQueue <double> q = null;
q = new MaxPriorityQueue <double>();
Assert.AreEqual(default(double), q.Dequeue());
}
public void MaxQueueAddItemsWithSize()
{
var queue = new MaxPriorityQueue <string, int>(Number);
queue.EnqueueRange(_array);
Assert.AreEqual(Number, queue.Count);
}
public void Test_IsEmpty_EmptyQ()
{
PriorityQueue <double> q = null;
q = new MaxPriorityQueue <double>();
Assert.IsTrue(q.IsEmpty);
}
public void Test_Count_EmptyQ()
{
PriorityQueue <double> q = null;
q = new MaxPriorityQueue <double>();
Assert.AreEqual(0, q.Count);
}
public IList <IList <int> > GetSkyline(int[][] buildings)
{
var sortedList = new SortedList <int, IList <int> >();
foreach (var building in buildings)
{
if (!sortedList.ContainsKey(building[0]))
{
sortedList.Add(building[0], new List <int>());
}
sortedList[building[0]].Add(-building[2]);
if (!sortedList.ContainsKey(building[1]))
{
sortedList.Add(building[1], new List <int>());
}
sortedList[building[1]].Add(building[2]);
}
var result = new List <IList <int> >();
var heights = new MaxPriorityQueue();
foreach (var x in sortedList.Keys)
{
foreach (var height in sortedList[x])
{
if (height < 0)
{
heights.Insert(-height);
}
else
{
heights.Delete(height);
}
}
if (heights.Size() == 0)
{
result.Add(new List <int>()
{
x, 0
});
}
else
{
var height = heights.Max();
if (result.Count == 0 || result[result.Count - 1][1] != height)
{
result.Add(new List <int>()
{
x, height
});
}
}
}
return(result);
}
private void Pop(MaxPriorityQueue <Order> pq, TreeSet <int> set, int count)
{
for (var i = 0; i < count; i++)
{
Assert.Equal(set.Max, pq.Top.Id);
Assert.Equal(set.Max, pq.Pop().Id);
set.RemoveMax();
}
}
public void IncreaseKey()
{
var job = new MockJob { Name = "cooking" };
var job2 = new MockJob { Name = "homework" };
var job3 = new MockJob { Name = "hoover" };
var priorityQueue = new MaxPriorityQueue<MockJob>(new[] { new KeyValuePair<double, MockJob>(2.0, job), new KeyValuePair<double, MockJob>(1.1, job2), new KeyValuePair<double, MockJob>(2.5, job3) });
priorityQueue.IncreaseKey(1, 3.0);
Assert.AreEqual("homework", priorityQueue.Maximum().Name,"#E8");
}
public void Add_ExpectQueueContainsItem()
{
var queue = new MaxPriorityQueue<int>();
queue.Add(ITEM);
var items = queue.ToArray();
CollectionAssert.AreEquivalent(new[] { ITEM }, items);
}
public void DequeueMax_OneItem_ExpectCountDecrement()
{
var queue = new MaxPriorityQueue<int>();
queue.Add(ITEM);
queue.DequeueMax();
Assert.AreEqual(0, queue.Count);
}
public void DequeueMax_OneItem_ExpectReturnItem()
{
var queue = new MaxPriorityQueue<int>();
queue.Add(ITEM);
var dequeuedItem = queue.DequeueMax();
Assert.AreEqual(ITEM, dequeuedItem);
}
public void Test_Peek()
{
PriorityQueue <double> q = null;
q = new MaxPriorityQueue <double>();
q.Enqueue(1);
Assert.AreEqual(1, q.Peek());
}
public void TestPriorityQueueBoundary()
{
var pq1 = new MinPriorityQueue <int>();
PriorityQueueBoundary(pq1);
var pq2 = new MaxPriorityQueue <int>();
PriorityQueueBoundary(pq2);
}
public void TestPriorityQueueEnumerator()
{
var pq = new MinPriorityQueue <int>();
Enumerate(pq);
var pq2 = new MaxPriorityQueue <int>();
Enumerate(pq2);
}
public void Insert()
{
var job = new MockJob { Name = "cooking" };
var job2 = new MockJob { Name = "homework" };
var job3 = new MockJob { Name = "hoover" };
var priorityQueue = new MaxPriorityQueue<MockJob>(new[] { new KeyValuePair<double, MockJob>(2.0, job), new KeyValuePair<double, MockJob>(1.1, job2)});
priorityQueue.Insert(new KeyValuePair<double, MockJob>(2.5, job3) );
Assert.AreEqual(3, priorityQueue.Count, "#E9");
Assert.AreEqual("hoover", priorityQueue.Maximum().Name, "#E10");
}
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 MaxPriorityQueue_Add_AddSingleItemToEmptyHeap()
{
MaxPriorityQueue maxPriorityQueue = new MaxPriorityQueue();
Node node2add = new Node { c = 'a', frequency = 100 };
maxPriorityQueue.Add(node2add);
Node returnNode = maxPriorityQueue.Extract();
Assert.AreEqual(node2add, returnNode);
}
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 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 MaxPriorityQueue_Empty_EnumeratorTest()
{
var queue = new MaxPriorityQueue <string>();
Assert.IsTrue(queue.IsEmpty);
Assert.AreEqual(0, queue.Size);
foreach (var item in queue)
{
Assert.Fail("Check enumerator implementation. Queue is empty.");
}
}
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);
}
/// <summary>
/// Method that takes in the query and returns a list of the top ten ranking documents
/// </summary>
/// <param name="query"></param>
/// <returns></returns>
public IList <MaxPriorityQueue.InvertedIndex> GetTopTen(List <string> query)
{
//Build the Accumulator Hashmap
BuildAccumulator(query);
//Build Priority Queue using the Accumulator divided by L_{d}
MaxPriorityQueue priorityQueue = BuildPriorityQueue();
accumulator.Clear();
//Retrieve Top Ten Documents according to percent
return(priorityQueue.RetrieveTopTen());
}
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 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 MaxPriorityQueue_Add_AddTwoItemsToEmptyHeap()
{
MaxPriorityQueue maxPriorityQueue = new MaxPriorityQueue();
Node node1 = new Node { c = 'a', frequency = 100 };
Node node2 = new Node { c = 'f', frequency = 1000 };
maxPriorityQueue.Add(node1);
maxPriorityQueue.Add(node2);
Node returnNode = maxPriorityQueue.Extract();
Assert.AreEqual(node2, returnNode);
returnNode = maxPriorityQueue.Extract();
Assert.AreEqual(node1, returnNode);
}
public void ExtractMax()
{
var job = new MockJob { Name = "cooking" };
var priorityQueue = new MaxPriorityQueue<MockJob>(new[] { new KeyValuePair<double, MockJob>(2.0, job) });
Assert.AreEqual(job.Name, priorityQueue.ExtractMax().Name, "#E2");
Assert.AreEqual(0, priorityQueue.Count, "#E3");
var job2 = new MockJob { Name = "homework" };
var job3 = new MockJob { Name = "hoover" };
priorityQueue = new MaxPriorityQueue<MockJob>(new[] { new KeyValuePair<double, MockJob>(2.0, job), new KeyValuePair<double, MockJob>(1.1, job2), new KeyValuePair<double, MockJob>(2.5, job3) });
Assert.AreEqual("hoover", priorityQueue.ExtractMax().Name, "#E4");
Assert.AreEqual(2, priorityQueue.Count,"#E5");
Assert.AreEqual("cooking",priorityQueue.ExtractMax().Name,"#E6");
Assert.AreEqual(1, priorityQueue.Count, "#E7");
}
public void MaxPQ_Basic()
{
var pq = new MaxPriorityQueue<int>();
pq.Insert(2, null);
pq.Insert(6, null);
pq.Insert(1, null);
Assert.AreEqual(6, (int)(pq.DelMax().Item1));
pq.Insert(9, null);
pq.Insert(7, null);
pq.Insert(1, null);
Assert.AreEqual(9, (int)(pq.DelMax().Item1));
pq.Insert(2, null);
pq.Insert(6, null);
pq.Insert(1, null);
Assert.AreEqual(7, (int)(pq.DelMax().Item1));
Assert.AreEqual(6, (int)(pq.Max().Item1));
Assert.AreEqual(6, (int)(pq.DelMax().Item1));
Assert.AreEqual(2, (int)(pq.DelMax().Item1));
Assert.AreEqual(2, (int)(pq.DelMax().Item1));
}
public void Create_ExpectCountToBeZero()
{
var queue = new MaxPriorityQueue<int>();
Assert.AreEqual(0, queue.Count);
}
public void PeekMax_ExpectCountNotChange()
{
var queue = new MaxPriorityQueue<int>();
queue.Add(ITEM);
queue.PeekMax();
Assert.AreEqual(1, queue.Count);
}
public void PeekMax_OneItem_ExpectReturnItem()
{
var queue = new MaxPriorityQueue<int>();
queue.Add(ITEM);
var peekedItem = queue.PeekMax();
Assert.AreEqual(ITEM, peekedItem);
}
public void UltimateTest()
{
const int COUNT = 100000;
var random = new Random();
var array = new int[COUNT];
var queue = new MaxPriorityQueue<int>();
for (var i = 0; i < COUNT; i++)
{
array[i] = random.Next(COUNT);
queue.Add(array[i]);
}
Array.Sort(array);
Array.Reverse(array);
var numbersFromQueue = new int[COUNT];
for (var i = 0; i < COUNT; i++)
{
numbersFromQueue[i] = queue.DequeueMax();
}
Assert.AreEqual(0, queue.Count);
CollectionAssert.AreEqual(array, numbersFromQueue);
}
private MaxPriorityQueue<int> CreateQueueAddTwoNotEqualItems()
{
var queue = new MaxPriorityQueue<int>();
queue.Add(MIN_ITEM);
queue.Add(MAX_ITEM);
return queue;
}
public void DequeueMax_EmptyQueue_ExpectThrowInvalidOperationException()
{
var queue = new MaxPriorityQueue<int>();
queue.DequeueMax();
}
public void DequeueMax_TwoNotEqualItems_ExpectReturnMax()
{
var queue = CreateQueueAddTwoNotEqualItems();
queue.Add(MIN_ITEM);
queue.Add(MAX_ITEM);
var dequeuedItem = queue.DequeueMax();
Assert.AreEqual(MAX_ITEM, dequeuedItem);
//check order of insertion does not matter
queue = new MaxPriorityQueue<int>();
queue.Add(MAX_ITEM);
queue.Add(MIN_ITEM);
dequeuedItem = queue.DequeueMax();
Assert.AreEqual(MAX_ITEM, dequeuedItem);
}