public void FibonacciHeapUpdateKeyMinHeap()
        {
            FibonacciHeap <HeapElement> heap = new FibonacciHeap <HeapElement>((a, b) => a.Priority.CompareTo(b.Priority), true);

            FillHeap(heap, 100);
            Assert.AreEqual(100, heap.Count);

            // add new element. Give it a priority of 50
            HeapElement element = new HeapElement(50, "Value: 50");

            heap.Insert(element);
            Assert.AreEqual(101, heap.Count);

            // update key to 10, using an action lambda
            heap.UpdateKey(element, (a, b) => a.Priority = b, 10);
            Assert.AreEqual(10, element.Priority);

            // check if the heap is still correct
            HeapElement previous = heap.ExtractRoot();
            HeapElement current  = heap.ExtractRoot();

            while (current != null)
            {
                Assert.IsTrue(previous.Priority <= current.Priority);
                previous = current;
                current  = heap.ExtractRoot();
            }
            // heap should be empty
            Assert.AreEqual(0, heap.Count);
        }
        public void FibonacciHeapMergeTestMinHeaps()
        {
            // create two minheaps based on the priority value of the elements.
            FibonacciHeap <HeapElement> heap1 = new FibonacciHeap <HeapElement>((a, b) => a.Priority.CompareTo(b.Priority), true);
            FibonacciHeap <HeapElement> heap2 = new FibonacciHeap <HeapElement>((a, b) => a.Priority.CompareTo(b.Priority), true);

            FillHeap(heap1, 100);
            FillHeap(heap2, 100);
            Assert.AreEqual(100, heap1.Count);
            Assert.AreEqual(100, heap2.Count);
            // merge heap1 into heap2. heap2 will be empty afterwards
            heap1.Merge(heap2);
            Assert.AreEqual(200, heap1.Count);
            Assert.AreEqual(0, heap2.Count);

            // check if they are inserted correctly
            HeapElement previous = heap1.ExtractRoot();
            HeapElement current  = heap1.ExtractRoot();

            while (current != null)
            {
                Assert.IsTrue(previous.Priority <= current.Priority);
                previous = current;
                current  = heap1.ExtractRoot();
            }
            // heap1 should be empty as well
            Assert.AreEqual(0, heap1.Count);
        }
		public void FibonacciHeapUpdateKeyMinHeap()
		{
			FibonacciHeap<HeapElement> heap = new FibonacciHeap<HeapElement>((a, b) => a.Priority.CompareTo(b.Priority), true);

			FillHeap(heap, 100);
			Assert.AreEqual(100, heap.Count);

			// add new element. Give it a priority of 50
			HeapElement element = new HeapElement(50, "Value: 50");
			heap.Insert(element);
			Assert.AreEqual(101, heap.Count);

			// update key to 10, using an action lambda
			heap.UpdateKey(element, (a, b) => a.Priority = b, 10);
			Assert.AreEqual(10, element.Priority);

			// check if the heap is still correct
			HeapElement previous = heap.ExtractRoot();
			HeapElement current = heap.ExtractRoot();
			while(current != null)
			{
				Assert.IsTrue(previous.Priority <= current.Priority);
				previous = current;
				current = heap.ExtractRoot();
			}
			// heap should be empty 
			Assert.AreEqual(0, heap.Count);
		}
		public void FibonacciHeapMergeTestMinHeaps()
		{
			// create two minheaps based on the priority value of the elements. 
			FibonacciHeap<HeapElement> heap1 = new FibonacciHeap<HeapElement>((a, b) => a.Priority.CompareTo(b.Priority), true);
			FibonacciHeap<HeapElement> heap2 = new FibonacciHeap<HeapElement>((a, b) => a.Priority.CompareTo(b.Priority), true);

			FillHeap(heap1, 100);
			FillHeap(heap2, 100);
			Assert.AreEqual(100, heap1.Count);
			Assert.AreEqual(100, heap2.Count);
			// merge heap1 into heap2. heap2 will be empty afterwards
			heap1.Merge(heap2);
			Assert.AreEqual(200, heap1.Count);
			Assert.AreEqual(0, heap2.Count);

			// check if they are inserted correctly
			HeapElement previous = heap1.ExtractRoot();
			HeapElement current = heap1.ExtractRoot();
			while(current != null)
			{
				Assert.IsTrue(previous.Priority <= current.Priority);
				previous = current;
				current = heap1.ExtractRoot();
			}
			// heap1 should be empty as well
			Assert.AreEqual(0, heap1.Count);
		}