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