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 int MaxProfit(int k, int[] prices)
{
var peak = 0;
var valley = 0;
var candidates = new Stack <Tuple <int, int> >();
var profits = new MaxPriorityQueue <int>(prices.Length);
while (peak < prices.Length)
{
for (valley = peak; valley < prices.Length - 1 && prices[valley] >= prices[valley + 1]; valley++)
{
;
}
for (peak = valley + 1; peak < prices.Length && prices[peak] >= prices[peak - 1]; peak++)
{
;
}
while (candidates.Count > 0 && prices[valley] < prices[candidates.Peek().Item1])
{
profits.Add(prices[candidates.Peek().Item2 - 1] - prices[candidates.Peek().Item1]);
candidates.Pop();
}
while (candidates.Count > 0 && prices[peak - 1] >= prices[candidates.Peek().Item2 - 1])
{
profits.Add(prices[candidates.Peek().Item2 - 1] - prices[valley]);
valley = candidates.Peek().Item1;
candidates.Pop();
}
candidates.Push(new Tuple <int, int>(valley, peak));
}
while (candidates.Count > 0)
{
profits.Add(prices[candidates.Peek().Item2 - 1] - prices[candidates.Peek().Item1]);
candidates.Pop();
}
var max = 0;
for (; k > 0 && !profits.IsEmpty; k--)
{
max += profits.DeleteMax();
}
return(max);
}
public void Add_ExpectCountIncrement()
{
var queue = new MaxPriorityQueue<int>();
queue.Add(ITEM);
Assert.AreEqual(1, 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 DequeueMax_OneItem_ExpectCountDecrement()
{
var queue = new MaxPriorityQueue<int>();
queue.Add(ITEM);
queue.DequeueMax();
Assert.AreEqual(0, queue.Count);
}
public void Add_ExpectQueueContainsItem()
{
var queue = new MaxPriorityQueue<int>();
queue.Add(ITEM);
var items = queue.ToArray();
CollectionAssert.AreEquivalent(new[] { ITEM }, items);
}
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 AddNum(int num)
{
if (maxHeap.Count == 0 || num < maxHeap.Max)
{
maxHeap.Add(num);
}
else
{
minHeap.Add(num);
}
if (maxHeap.Count < minHeap.Count)
{
maxHeap.Add(minHeap.DeleteMin());
}
else if (maxHeap.Count > minHeap.Count + 1)
{
minHeap.Add(maxHeap.DeleteMax());
}
}
public IList <IList <int> > GetSkyline(int[][] buildings)
{
var points = buildings.SelectMany((building) => new[]
{
new Point {
IsLeft = true, Other = building[1], X = building[0], Y = building[2]
},
new Point {
IsLeft = false, X = building[1], Y = building[2]
}
}).OrderBy((point) => point, new PointComparer());
var current = new MaxPriorityQueue <Point>();
var skyline = new List <IList <int> >();
foreach (var point in points)
{
if (point.IsLeft)
{
if (!current.IsEmpty && point.Y <= current.Max.Y)
{
while (!current.IsEmpty && current.Max.Other < point.X)
{
current.DeleteMax();
}
}
if (current.IsEmpty || point.Y > current.Max.Y)
{
skyline.Add(new[] { point.X, point.Y });
}
current.Add(point);
}
else
{
while (!current.IsEmpty && current.Max.Other <= point.X)
{
current.DeleteMax();
}
var height = current.IsEmpty ? 0 : current.Max.Y;
if (height != skyline[skyline.Count - 1][1])
{
skyline.Add(new[] { point.X, current.IsEmpty ? 0 : current.Max.Y });
}
}
}
return(skyline);
}
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);
}
private MaxPriorityQueue<int> CreateQueueAddTwoNotEqualItems()
{
var queue = new MaxPriorityQueue<int>();
queue.Add(MIN_ITEM);
queue.Add(MAX_ITEM);
return queue;
}
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);
}
public void PeekMax_OneItem_ExpectReturnItem()
{
var queue = new MaxPriorityQueue<int>();
queue.Add(ITEM);
var peekedItem = queue.PeekMax();
Assert.AreEqual(ITEM, peekedItem);
}
public void PeekMax_ExpectCountNotChange()
{
var queue = new MaxPriorityQueue<int>();
queue.Add(ITEM);
queue.PeekMax();
Assert.AreEqual(1, queue.Count);
}
