From afdfeda8264c950b235a963e0cf9db745c1010e1 Mon Sep 17 00:00:00 2001
From: Alex Macocian <amacocian@hotmail.com>
Date: Thu, 18 Apr 2019 15:41:50 +0200
Subject: [PATCH] Implemented Fibonacci Heap + Tests

---
 SystemExtensions/Collections/BinaryHeap.cs    |   8 +-
 SystemExtensions/Collections/FibonacciHeap.cs | 549 ++++++++++++++++++
 SystemExtensions/Collections/PriorityQueue.cs |   2 +-
 SystemExtensions/Comparators.cs               | 467 +++++++++++++++
 SystemExtensions/SystemExtensions.csproj      |   2 +
 .../Collections/BinaryHeapTests.cs            |   3 +-
 .../Collections/FibonacciHeapTests.cs         | 203 +++++++
 .../Collections/PriorityQueueTests.cs         |   1 +
 .../SystemExtensionsTests.csproj              |   1 +
 9 files changed, 1230 insertions(+), 6 deletions(-)
 create mode 100644 SystemExtensions/Collections/FibonacciHeap.cs
 create mode 100644 SystemExtensions/Comparators.cs
 create mode 100644 SystemExtensionsTests/Collections/FibonacciHeapTests.cs

diff --git a/SystemExtensions/Collections/BinaryHeap.cs b/SystemExtensions/Collections/BinaryHeap.cs
index bdc7544..562f94f 100644
--- a/SystemExtensions/Collections/BinaryHeap.cs
+++ b/SystemExtensions/Collections/BinaryHeap.cs
@@ -78,10 +78,10 @@ namespace SystemExtensions.Collections
             items[position] = value;
         }
         /// <summary>
-        /// Deletes the item at the root. Throws exception if there are no items in the heap.
+        /// Removes the item at the root. Throws exception if there are no items in the heap.
         /// </summary>
-        /// <returns></returns>
-        public T DeleteMin()
+        /// <returns>Value removed.</returns>
+        public T RemoveMin()
         {
             if (count == 0)
             {
@@ -93,7 +93,7 @@ namespace SystemExtensions.Collections
             return min;
         }
         /// <summary>
-        /// Function to return the heap structure as an array
+        /// Return the heap structure as an array
         /// </summary>
         /// <returns>Array with values sorted as in heap</returns>
         public T[] ToArray()
diff --git a/SystemExtensions/Collections/FibonacciHeap.cs b/SystemExtensions/Collections/FibonacciHeap.cs
new file mode 100644
index 0000000..d60633a
--- /dev/null
+++ b/SystemExtensions/Collections/FibonacciHeap.cs
@@ -0,0 +1,549 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SystemExtensions.Collections
+{
+    public class FibonacciHeap<T> : IDisposable
+    {
+        #region Fields
+        private FibonacciNode<T> root;
+        private Comparison<T> comparator;
+        private int count;
+        #endregion
+        #region Properties
+        /// <summary>
+        /// Count of values in the heap.
+        /// </summary>
+        public int Count
+        {
+            get
+            {
+                return count;
+            }
+        }
+        /// <summary>
+        /// Minimal value contained in the heap.
+        /// </summary>
+        public T Minimum
+        {
+            get
+            {
+                return root.Value;
+            }
+        }
+        #endregion
+        #region Constructors
+        public FibonacciHeap(Comparison<T> comparator)
+        {
+            this.comparator = comparator;
+        }
+        #endregion
+        #region Public Methods
+        /// <summary>
+        /// Inserts value into the heap.
+        /// </summary>
+        /// <param name="value">Value to be inserted.</param>
+        public void Insert(T value)
+        {
+            FibonacciNode<T> node = new FibonacciNode<T>();
+            node.Value = value;
+            node.Previous = node.Next = node;
+            node.Degree = 0;
+            node.Marked = false;
+            node.Child = null;
+            node.Parent = null;
+            root = Merge(root, node);
+            count++;
+        }
+        /// <summary>
+        /// Merge current heap with another heap. The other heap will be disposed at the end of this method.
+        /// </summary>
+        /// <param name="otherHeap">The heap to be merged with the current heap.</param>
+        public void Merge(FibonacciHeap<T> otherHeap)
+        {
+            root = Merge(root, otherHeap.root);
+            otherHeap.root = null;
+            count += otherHeap.count;
+            otherHeap.Dispose();
+        }
+        /// <summary>
+        /// Remove the minimum value from the heap.
+        /// </summary>
+        /// <returns>Minimum value.</returns>
+        public T RemoveMinimum()
+        {
+            FibonacciNode<T> currentRoot = root;
+            if (currentRoot != null)
+            {
+                root = RemoveMinimum(root);
+                count--;
+                return currentRoot.Value;
+            }
+            else
+            {
+                throw new IndexOutOfRangeException("Heap is empty!");
+            }
+        }
+        /// <summary>
+        /// Decrease the old value to a new provided value.
+        /// </summary>
+        /// <param name="oldValue">Old value used to find the node to have its key decreased.</param>
+        /// <param name="value">New value to be assigned to the node.</param>
+        public void DecreaseKey(T oldValue, T value)
+        {
+            FibonacciNode<T> node = Find(root, oldValue);
+            root = DecreaseKey(root, node, value);
+        }
+        /// <summary>
+        /// Determines whether the heap contains a specified value.
+        /// </summary>
+        /// <param name="value">Valye to locate in the heap.</param>
+        /// <returns></returns>
+        public bool Contains(T value)
+        {
+            return Find(root, value) != null;
+        }
+        /// <summary>
+        /// Clears the heap.
+        /// </summary>
+        public void Clear()
+        {
+            count = 0;
+            Remove(root);
+            root.Next = root.Previous = root.Parent = root.Child = null;
+            root = null;
+        }
+        /// <summary>
+        /// Return the heap structure as an array. Array is not sorted other than the
+        /// actual structure of the heap.
+        /// </summary>
+        /// <returns>Array with values from the heap.</returns>
+        public T[] ToArray()
+        {
+            if(count == 0)
+            {
+                return null;
+            }
+            T[] array = new T[count];
+            if (count == 1)
+            {
+                array[0] = root.Value;
+                return array;
+            }
+            else
+            {
+                int index = 0;
+                RecursiveFillArray(root, ref array, ref index);
+                return array;
+            }
+        }
+        #endregion
+        #region Private Methods
+        /// <summary>
+        /// Recursively traverse the heap and copy its contents to an array.
+        /// </summary>
+        /// <param name="currentNode">Current node.</param>
+        /// <param name="array">Array to be filled with contents of heap.</param>
+        /// <param name="index">Index of the next unintialized element in the array.</param>
+        private void RecursiveFillArray(FibonacciNode<T> currentNode, ref T[] array, ref int index)
+        {
+            FibonacciNode<T> oldNode = currentNode;
+            do
+            {
+                array[index] = currentNode.Value;
+                index++;
+                if (currentNode.HasChildren())
+                {
+                    RecursiveFillArray(currentNode.Child, ref array, ref index);
+                }
+                currentNode = currentNode.Previous;
+            } while (currentNode != oldNode);
+        }
+        /// <summary>
+        /// Recursively remove the node and its children from the heap.
+        /// </summary>
+        /// <param name="node">Node to be removed.</param>
+        private void Remove(FibonacciNode<T> node)
+        {
+            if(node != null)
+            {
+                FibonacciNode<T> current = node;
+                do
+                {
+                    Remove(current.Child);
+                    if (current.Parent != null)
+                    {
+                        current.Parent.Child = null;
+                    }
+                    current = current.Next;
+                } while (current != node);
+                current.Next = current.Previous = current.Child = current.Parent = null;
+            }
+        }
+        /// <summary>
+        /// Merge two heaps into a larger heap.
+        /// </summary>
+        /// <param name="node1">Root of first heap.</param>
+        /// <param name="node2">Root of second heap.</param>
+        private FibonacciNode<T> Merge(FibonacciNode<T> node1, FibonacciNode<T> node2)
+        {
+            if(node1 == null)
+            {
+                return node2;
+            }
+            if(node2 == null)
+            {
+                return node1;
+            }
+            if(comparator(node1.Value, node2.Value) > 0)
+            {
+                FibonacciNode<T> temp = node1;
+                node1 = node2;
+                node2 = temp;
+            }
+            FibonacciNode<T> node1Next = node1.Next;
+            FibonacciNode<T> node2Prev = node2.Previous;
+            node1.Next = node2;
+            node2.Previous = node1;
+            node1Next.Previous = node2Prev;
+            node2Prev.Next = node1Next;
+            return node1;
+        }
+        /// <summary>
+        /// Adds child to the parent.
+        /// </summary>
+        /// <param name="parent">Parent node to accept child.</param>
+        /// <param name="child">Child node to be added to the parent.</param>
+        private void AddChild(FibonacciNode<T> parent, FibonacciNode<T> child)
+        {
+            child.Previous = child.Next = child;
+            child.Parent = parent;
+            parent.Degree++;
+            parent.Child = Merge(parent.Child, child);
+        }
+        /// <summary>
+        /// Removes the parent of the specified node.
+        /// </summary>
+        /// <param name="node">Node to be removed from its parent.</param>
+        private void RemoveParent(FibonacciNode<T> node)
+        {
+            if(node == null)
+            {
+                return;
+            }
+            FibonacciNode<T> current = node;
+            do
+            {
+                current.Marked = false;
+                current.Parent = null;
+                current = current.Next;
+            } while (current != node);
+        }
+        /// <summary>
+        /// Removes the minimum node from the provided tree.
+        /// </summary>
+        /// <param name="node">Root of the provided tree.</param>
+        /// <returns></returns>
+        private FibonacciNode<T> RemoveMinimum(FibonacciNode<T> node)
+        {
+            RemoveParent(node.Child);
+            if(node.Next == node)
+            {
+                node = node.Child;
+            }
+            else
+            {
+                node.Next.Previous = node.Previous;
+                node.Previous.Next = node.Next;
+                node = Merge(node.Next, node.Child);
+            }
+            if(node == null)
+            {
+                return node;
+            }
+
+            FibonacciNode<T>[] trees = new FibonacciNode<T>[64];
+            while (true)
+            {
+                if(trees[node.Degree] != null)
+                {
+                    FibonacciNode<T> t = trees[node.Degree];
+                    if(t == node)
+                    {
+                        break;
+                    }
+                    trees[node.Degree] = null;
+                    if(comparator(node.Value, t.Value) < 0)
+                    {
+                        t.Previous.Next = t.Next;
+                        t.Next.Previous = t.Previous;
+                        AddChild(node, t);
+                    }
+                    else
+                    {
+                        t.Previous.Next = t.Next;
+                        t.Next.Previous = t.Previous;
+                        if(node.Next == node)
+                        {
+                            t.Next = t.Previous = t;
+                            AddChild(t, node);
+                            node = t;
+                        }
+                        else
+                        {
+                            node.Previous.Next = t;
+                            node.Next.Previous = t;
+                            t.Next = node.Next;
+                            t.Previous = node.Previous;
+                            AddChild(t, node);
+                            node = t;
+                        }
+                    }
+                    continue;
+                }
+                else
+                {
+                    trees[node.Degree] = node;
+                }
+                node = node.Next;
+            }
+            FibonacciNode<T> min = node;
+            FibonacciNode<T> start = node;
+            do
+            {
+                if(comparator(node.Value, min.Value) < 0)
+                {
+                    min = node;
+                }
+                node = node.Next;
+            } while (node != start);
+            return min;
+        }
+        /// <summary>
+        /// Cut node from heap.
+        /// </summary>
+        /// <param name="root">Root of heap.</param>
+        /// <param name="node">Node to be cut.</param>
+        /// <returns></returns>
+        private FibonacciNode<T> Cut(FibonacciNode<T> root, FibonacciNode<T> node)
+        {
+            if(node.Next == node)
+            {
+                node.Parent.Child = null;
+            }
+            else
+            {
+                node.Next.Previous = node.Previous;
+                node.Previous.Next = node.Next;
+                node.Parent.Child = node.Next;
+            }
+            node.Next = node.Previous = node;
+            node.Marked = false;
+            return Merge(root, node);
+        }
+        /// <summary>
+        /// Decrease value of provided node substituting it with the provided value.
+        /// </summary>
+        /// <param name="root">Root of the heap.</param>
+        /// <param name="node">Node to have value decreased.</param>
+        /// <param name="value">New value of the node. It is only applied if the value is lower than the previous value.</param>
+        /// <returns></returns>
+        private FibonacciNode<T> DecreaseKey(FibonacciNode<T> root, FibonacciNode<T> node, T value)
+        {
+            if(comparator(node.Value, value) < 0)
+            {
+                return root;
+            }
+            node.Value = value;
+            if(node.Parent != null)
+            {
+                if(comparator(node.Value, node.Parent.Value) < 0)
+                {
+                    root = Cut(root, node);
+                    FibonacciNode<T> parent = node.Parent;
+                    node.Parent = null;
+                    while(parent != null && parent.Marked)
+                    {
+                        root = Cut(root, parent);
+                        node = parent;
+                        parent = node.Parent;
+                        node.Parent = null;
+                    }
+                    if(parent != null && parent.Parent != null)
+                    {
+                        parent.Marked = true;
+                    }
+                }
+            }
+            else
+            {
+                if(comparator(node.Value, root.Value) < 0)
+                {
+                    root = node;
+                }
+            }
+            return root;
+        }
+        /// <summary>
+        /// Find the node that has the specified value in the heap.
+        /// </summary>
+        /// <param name="root">Root of the heap.</param>
+        /// <param name="value">Value to be found.</param>
+        /// <returns></returns>
+        private FibonacciNode<T> Find(FibonacciNode<T> root, T value)
+        {
+            FibonacciNode<T> node = root;
+            if(node == null)
+            {
+                return null;
+            }
+            do
+            {
+                if(comparator(node.Value, value) == 0)
+                {
+                    return node;
+                }
+                FibonacciNode<T> ret = Find(node.Child, value);
+                if(ret != null)
+                {
+                    return ret;
+                }
+                node = node.Next;
+            } while (node != root);
+            return null;
+        }
+        #endregion
+        #region IDisposable Support
+        private bool disposedValue = false;
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!disposedValue)
+            {
+                if (root != null)
+                {
+                    if (disposing)
+                    {
+                        Remove(root);
+                    }
+                    root.Previous = root.Next = root.Parent = root.Child = null;
+                    root = null;
+                }
+
+                disposedValue = true;
+            }
+        }
+        public void Dispose()
+        {
+            // Do not change this code. Put cleanup code in Dispose(bool disposing) above.
+            Dispose(true);
+            // TODO: uncomment the following line if the finalizer is overridden above.
+            // GC.SuppressFinalize(this);
+        }
+        #endregion
+    }
+
+    internal class FibonacciNode<T>
+    {
+        #region Fields
+        private FibonacciNode<T> previous;
+        private FibonacciNode<T> next;
+        private FibonacciNode<T> child;
+        private FibonacciNode<T> parent;
+        private T value;
+        private int degree;
+        private bool marked;
+        #endregion
+        #region Properties
+        public FibonacciNode<T> Previous
+        {
+            get
+            {
+                return previous;
+            }
+            set
+            {
+                previous = value;
+            }
+        }
+        public FibonacciNode<T> Next
+        {
+            get
+            {
+                return next;
+            }
+            set
+            {
+                next = value;
+            }
+        }
+        public FibonacciNode<T> Child
+        {
+            get
+            {
+                return child;
+            }
+            set
+            {
+                child = value;
+            }
+        }
+        public FibonacciNode<T> Parent
+        {
+            get
+            {
+                return parent;
+            }
+            set
+            {
+                parent = value;
+            }
+        }
+        public bool Marked
+        {
+            get
+            {
+                return marked;
+            }
+            set
+            {
+                marked = value;
+            }
+        }
+        public T Value
+        {
+            get
+            {
+                return value;
+            }
+            set
+            {
+                this.value = value; 
+            }
+        }
+        public int Degree
+        {
+            get
+            {
+                return degree;
+            }
+            set
+            {
+                degree = value;
+            }
+        }
+        #endregion
+        #region Public Methods
+        public bool HasChildren()
+        {
+            return child != null;
+        }
+        public bool HasParent()
+        {
+            return parent != null;
+        }
+        #endregion
+    }
+}
diff --git a/SystemExtensions/Collections/PriorityQueue.cs b/SystemExtensions/Collections/PriorityQueue.cs
index 998f892..88c698b 100644
--- a/SystemExtensions/Collections/PriorityQueue.cs
+++ b/SystemExtensions/Collections/PriorityQueue.cs
@@ -39,7 +39,7 @@ namespace SystemExtensions.Collections
         {
             if (Count > 0)
             {
-                return binaryHeap.DeleteMin();
+                return binaryHeap.RemoveMin();
             }
             else
             {
diff --git a/SystemExtensions/Comparators.cs b/SystemExtensions/Comparators.cs
new file mode 100644
index 0000000..a309a5b
--- /dev/null
+++ b/SystemExtensions/Comparators.cs
@@ -0,0 +1,467 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SystemExtensions
+{
+    public static class Comparators
+    {
+        #region Fields
+        private static Comparison<int> intComparison = new Comparison<int>(IntegerComparison);
+        private static Comparison<float> floatComparison = new Comparison<float>(FloatComparison);
+        private static Comparison<double> doubleComparison = new Comparison<double>(DoubleComparison);
+        private static Comparison<bool> boolComparison = new Comparison<bool>(BoolComparison);
+        private static Comparison<decimal> decimalComparison = new Comparison<decimal>(DecimalComparison);
+        private static Comparison<byte> byteComparison = new Comparison<byte>(ByteComparison);
+        private static Comparison<long> longComparison = new Comparison<long>(LongComparison);
+        private static Comparison<uint> uintComparison = new Comparison<uint>(UintComparison);
+        private static Comparison<Int16> int16Comparison = new Comparison<Int16>(Int16Comparison);
+        private static Comparison<Int32> int32Comparison = new Comparison<Int32>(Int32Comparison);
+        private static Comparison<Int64> int64Comparison = new Comparison<Int64>(int64Comparison);
+        private static Comparison<UInt16> uInt16Comparison = new Comparison<UInt16>(uInt16Comparison);
+        private static Comparison<UInt32> uInt32Comparison = new Comparison<UInt32>(uInt32Comparison);
+        private static Comparison<UInt64> uInt64Comparison = new Comparison<UInt64>(uInt64Comparison);
+        #endregion
+        #region Properties
+        /// <summary>
+        /// Comparison between two ints.
+        /// </summary>
+        public static Comparison<int> Int
+        {
+            get
+            {
+                return intComparison;
+            }
+        }
+        /// <summary>
+        /// Comparison between two floats.
+        /// </summary>
+        public static Comparison<float> Float
+        {
+            get
+            {
+                return floatComparison;
+            }
+        }
+        /// <summary>
+        /// Comparison between two doubles.
+        /// </summary>
+        public static Comparison<double> Double
+        {
+            get
+            {
+                return doubleComparison;
+            }
+        }
+        /// <summary>
+        /// Comparison between two decimals.
+        /// </summary>
+        public static Comparison<decimal> Decimal
+        {
+            get
+            {
+                return decimalComparison;
+            }
+        }
+        /// <summary>
+        /// Comparison between two bools.
+        /// </summary>
+        public static Comparison<bool> Bool
+        {
+            get
+            {
+                return boolComparison;
+            }
+        }
+        /// <summary>
+        /// Comparison between two bytes.
+        /// </summary>
+        public static Comparison<byte> Byte
+        {
+            get
+            {
+                return byteComparison;
+            }
+        }
+        /// <summary>
+        /// Comparison between two longs.
+        /// </summary>
+        public static Comparison<long> Long
+        {
+            get
+            {
+                return longComparison;
+            }
+        }
+        /// <summary>
+        /// Comparison between two uints.
+        /// </summary>
+        public static Comparison<uint> Uint
+        {
+            get
+            {
+                return uintComparison;
+            }
+        }
+        /// <summary>
+        /// Comparison between two int16.
+        /// </summary>
+        public static Comparison<Int16> Int16
+        {
+            get
+            {
+                return int16Comparison;
+            }
+        }
+        /// <summary>
+        /// Comparison between two int32.
+        /// </summary>
+        public static Comparison<Int32> Int32
+        {
+            get
+            {
+                return int32Comparison;
+            }
+        }
+        /// <summary>
+        /// Comparison between two int64.
+        /// </summary>
+        public static Comparison<Int64> Int64
+        {
+            get
+            {
+                return int64Comparison;
+            }
+        }
+        /// <summary>
+        /// Comparison between two uint16.
+        /// </summary>
+        public static Comparison<UInt16> UInt16
+        {
+            get
+            {
+                return uInt16Comparison;
+            }
+        }
+        /// <summary>
+        /// Comparison between two uint32.
+        /// </summary>
+        public static Comparison<UInt32> UInt32
+        {
+            get
+            {
+                return uInt32Comparison;
+            }
+        }
+        /// <summary>
+        /// Comparison between two uint64.
+        /// </summary>
+        public static Comparison<UInt64> UInt64
+        {
+            get
+            {
+                return uInt64Comparison;
+            }
+        }
+        #endregion
+        #region Private Methods
+        /// <summary>
+        /// Compares two UInt64.
+        /// </summary>
+        /// <param name="x">First value.</param>
+        /// <param name="y">Second value.</param>
+        /// <returns>Returns 1 if x > y. 0 if equal and -1 if y > x.</returns>
+        private static int Uint64Comparison(UInt64 x, UInt64 y)
+        {
+            if (x == y)
+            {
+                return 0;
+            }
+            else if (x > y)
+            {
+                return 1;
+            }
+            else
+            {
+                return -1;
+            }
+        }
+        /// <summary>
+        /// Compares two UInt32.
+        /// </summary>
+        /// <param name="x">First value.</param>
+        /// <param name="y">Second value.</param>
+        /// <returns>Returns 1 if x > y. 0 if equal and -1 if y > x.</returns>
+        private static int Uint32Comparison(UInt32 x, UInt32 y)
+        {
+            if (x == y)
+            {
+                return 0;
+            }
+            else if (x > y)
+            {
+                return 1;
+            }
+            else
+            {
+                return -1;
+            }
+        }
+        /// <summary>
+        /// Compares two UInt16.
+        /// </summary>
+        /// <param name="x">First value.</param>
+        /// <param name="y">Second value.</param>
+        /// <returns>Returns 1 if x > y. 0 if equal and -1 if y > x.</returns>
+        private static int Uint16Comparison(UInt16 x, UInt16 y)
+        {
+            if (x == y)
+            {
+                return 0;
+            }
+            else if (x > y)
+            {
+                return 1;
+            }
+            else
+            {
+                return -1;
+            }
+        }
+        /// <summary>
+        /// Compares two Int64.
+        /// </summary>
+        /// <param name="x">First value.</param>
+        /// <param name="y">Second value.</param>
+        /// <returns>Returns 1 if x > y. 0 if equal and -1 if y > x.</returns>
+        private static int Int64Comparison(Int64 x, Int64 y)
+        {
+            if (x == y)
+            {
+                return 0;
+            }
+            else if (x > y)
+            {
+                return 1;
+            }
+            else
+            {
+                return -1;
+            }
+        }
+        /// <summary>
+        /// Compares two UInt32.
+        /// </summary>
+        /// <param name="x">First value.</param>
+        /// <param name="y">Second value.</param>
+        /// <returns>Returns 1 if x > y. 0 if equal and -1 if y > x.</returns>
+        private static int Int32Comparison(Int32 x, Int32 y)
+        {
+            if (x == y)
+            {
+                return 0;
+            }
+            else if (x > y)
+            {
+                return 1;
+            }
+            else
+            {
+                return -1;
+            }
+        }
+        /// <summary>
+        /// Compares two UInt16.
+        /// </summary>
+        /// <param name="x">First value.</param>
+        /// <param name="y">Second value.</param>
+        /// <returns>Returns 1 if x > y. 0 if equal and -1 if y > x.</returns>
+        private static int Int16Comparison(Int16 x, Int16 y)
+        {
+            if (x == y)
+            {
+                return 0;
+            }
+            else if (x > y)
+            {
+                return 1;
+            }
+            else
+            {
+                return -1;
+            }
+        }
+        /// <summary>
+        /// Compares two uint.
+        /// </summary>
+        /// <param name="x">First value.</param>
+        /// <param name="y">Second value.</param>
+        /// <returns>Returns 1 if x > y. 0 if equal and -1 if y > x.</returns>
+        private static int UintComparison(uint x, uint y)
+        {
+            if (x == y)
+            {
+                return 0;
+            }
+            else if (x > y)
+            {
+                return 1;
+            }
+            else
+            {
+                return -1;
+            }
+        }
+        /// <summary>
+        /// Compares two Long.
+        /// </summary>
+        /// <param name="x">First value.</param>
+        /// <param name="y">Second value.</param>
+        /// <returns>Returns 1 if x > y. 0 if equal and -1 if y > x.</returns>
+        private static int LongComparison(long x, long y)
+        {
+            if (x == y)
+            {
+                return 0;
+            }
+            else if (x > y)
+            {
+                return 1;
+            }
+            else
+            {
+                return -1;
+            }
+        }
+        /// <summary>
+        /// Compares two Byte.
+        /// </summary>
+        /// <param name="x">First value.</param>
+        /// <param name="y">Second value.</param>
+        /// <returns>Returns 1 if x > y. 0 if equal and -1 if y > x.</returns>
+        private static int ByteComparison(byte x, byte y)
+        {
+            if (x == y)
+            {
+                return 0;
+            }
+            else if (x > y)
+            {
+                return 1;
+            }
+            else
+            {
+                return -1;
+            }
+        }
+        /// <summary>
+        /// Compares two Decimal.
+        /// </summary>
+        /// <param name="x">First value.</param>
+        /// <param name="y">Second value.</param>
+        /// <returns>Returns 1 if x > y. 0 if equal and -1 if y > x.</returns>
+        private static int DecimalComparison(decimal x, decimal y)
+        {
+            if (x == y)
+            {
+                return 0;
+            }
+            else if (x > y)
+            {
+                return 1;
+            }
+            else
+            {
+                return -1;
+            }
+        }
+        /// <summary>
+        /// Compares two Bool.
+        /// </summary>
+        /// <param name="x">First value.</param>
+        /// <param name="y">Second value.</param>
+        /// <returns>Returns 1 if x is true and y is false. 0 if they are the same and -1 
+        /// if y is true and x is false.</returns>
+        private static int BoolComparison(bool x, bool y)
+        {
+            if (x == y)
+            {
+                return 0;
+            }
+            else if (x == true && y == false)
+            {
+                return 1;
+            }
+            else
+            {
+                return -1;
+            }
+        }
+        /// <summary>
+        /// Compares two Double.
+        /// </summary>
+        /// <param name="x">First value.</param>
+        /// <param name="y">Second value.</param>
+        /// <returns>Returns 1 if x > y. 0 if equal and -1 if y > x.</returns>
+        private static int DoubleComparison(double x, double y)
+        {
+            if (x == y)
+            {
+                return 0;
+            }
+            else if (x > y)
+            {
+                return 1;
+            }
+            else
+            {
+                return -1;
+            }
+        }
+        /// <summary>
+        /// Compares two Float.
+        /// </summary>
+        /// <param name="x">First value.</param>
+        /// <param name="y">Second value.</param>
+        /// <returns>Returns 1 if x > y. 0 if equal and -1 if y > x.</returns>
+        private static int FloatComparison(float x, float y)
+        {
+            if (x == y)
+            {
+                return 0;
+            }
+            else if (x > y)
+            {
+                return 1;
+            }
+            else
+            {
+                return -1;
+            }
+        }
+        /// <summary>
+        /// Compares two Integer.
+        /// </summary>
+        /// <param name="x">First value.</param>
+        /// <param name="y">Second value.</param>
+        /// <returns>Returns 1 if x > y. 0 if equal and -1 if y > x.</returns>
+        private static int IntegerComparison(int x, int y)
+        {
+            if (x == y)
+            {
+                return 0;
+            }
+            else if (x > y)
+            {
+                return 1;
+            }
+            else
+            {
+                return -1;
+            }
+        }
+        #endregion
+    }
+}
diff --git a/SystemExtensions/SystemExtensions.csproj b/SystemExtensions/SystemExtensions.csproj
index 0166dee..79f3be0 100644
--- a/SystemExtensions/SystemExtensions.csproj
+++ b/SystemExtensions/SystemExtensions.csproj
@@ -42,7 +42,9 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Collections\BinaryHeap.cs" />
+    <Compile Include="Collections\FibonacciHeap.cs" />
     <Compile Include="Collections\PriorityQueue.cs" />
+    <Compile Include="Comparators.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Threading\PriorityThreadPool.cs" />
   </ItemGroup>
diff --git a/SystemExtensionsTests/Collections/BinaryHeapTests.cs b/SystemExtensionsTests/Collections/BinaryHeapTests.cs
index cf04ab9..b994387 100644
--- a/SystemExtensionsTests/Collections/BinaryHeapTests.cs
+++ b/SystemExtensionsTests/Collections/BinaryHeapTests.cs
@@ -5,6 +5,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using SystemExtensions;
 
 namespace SystemExtensions.Collections.Tests
 {
@@ -77,7 +78,7 @@ namespace SystemExtensions.Collections.Tests
                     {
                         Assert.Fail();
                     }
-                    System.Diagnostics.Debug.WriteLine(binaryHeap.DeleteMin());
+                    System.Diagnostics.Debug.WriteLine(binaryHeap.RemoveMin());
                     tries--;
                 }
             }
diff --git a/SystemExtensionsTests/Collections/FibonacciHeapTests.cs b/SystemExtensionsTests/Collections/FibonacciHeapTests.cs
new file mode 100644
index 0000000..814579a
--- /dev/null
+++ b/SystemExtensionsTests/Collections/FibonacciHeapTests.cs
@@ -0,0 +1,203 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using SystemExtensions.Collections;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Threading;
+
+namespace SystemExtensions.Collections.Tests
+{
+    [TestClass()]
+    public class FibonacciHeapTests
+    {
+        private static int IntegerComparison(int x, int y)
+        {
+            if (x == y)
+            {
+                return 0;
+            }
+            else if (x > y)
+            {
+                return 1;
+            }
+            else
+            {
+                return -1;
+            }
+        }
+        FibonacciHeap<int> fibonacciHeap = new FibonacciHeap<int>(new Comparison<int>(IntegerComparison));
+        [TestMethod()]
+        public void InsertTest()
+        {
+            for (int i = 0; i < 1000; i++)
+            {
+                fibonacciHeap.Insert(i);
+            }
+            if (fibonacciHeap.RemoveMinimum() != 0)
+            {
+                Assert.Fail();
+            }
+            for (int i = 1; i < 1000; i++)
+            {
+                if (!fibonacciHeap.Contains(i))
+                {
+                    Assert.Fail();
+                }
+            }
+        }
+
+        [TestMethod()]
+        public void FibonacciHeapTest()
+        {
+            fibonacciHeap.Dispose();
+            fibonacciHeap = new FibonacciHeap<int>(new Comparison<int>(IntegerComparison));
+            if(fibonacciHeap.Count != 0)
+            {
+                Assert.Fail();
+            }
+        }
+
+        [TestMethod()]
+        public void MergeTest()
+        {
+            fibonacciHeap.Dispose();
+            FibonacciHeap<int> fibonacciHeap1 = new FibonacciHeap<int>(new Comparison<int>(IntegerComparison));
+            FibonacciHeap<int> fibonacciHeap2 = new FibonacciHeap<int>(new Comparison<int>(IntegerComparison));
+
+            for(int i = 0; i < 100; i++)
+            {
+                fibonacciHeap1.Insert(i);
+            }
+
+            for(int i = 100; i < 300; i++)
+            {
+                fibonacciHeap2.Insert(i);
+            }
+
+            fibonacciHeap1.Merge(fibonacciHeap2);
+            for(int i = 1; i < 300; i++)
+            {
+                if (!fibonacciHeap1.Contains(i))
+                {
+                    Assert.Fail();
+                }
+            }
+        }
+
+        [TestMethod()]
+        public void RemoveMinimumTest()
+        {
+            try
+            {
+                fibonacciHeap.RemoveMinimum();
+                Assert.Fail();
+            }
+            catch(IndexOutOfRangeException exception)
+            {
+
+            }
+            catch(Exception e)
+            {
+                Assert.Fail();
+            }
+            for (int i = 0; i < 1000; i++)
+            {
+                fibonacciHeap.Insert(i);
+            }
+            for (int i = 0; i < 1000; i++)
+            {
+                if (fibonacciHeap.RemoveMinimum() != i)
+                {
+                    Assert.Fail();
+                }
+            }
+        }
+
+        [TestMethod()]
+        public void DecreaseKeyTest()
+        {
+            fibonacciHeap.Insert(5);
+            fibonacciHeap.Insert(10);
+            fibonacciHeap.Insert(7);
+            fibonacciHeap.DecreaseKey(5, 3);
+            if(fibonacciHeap.Contains(5) || !fibonacciHeap.Contains(3))
+            {
+                Assert.Fail();
+            }
+            fibonacciHeap.DecreaseKey(10, 1);
+            if(fibonacciHeap.RemoveMinimum() != 1)
+            {
+                Assert.Fail();
+            }
+        }
+
+        [TestMethod()]
+        public void ContainsTest()
+        {
+            for(int i = 0; i < 10000; i++)
+            {
+                fibonacciHeap.Insert(i);
+            }
+            if (!fibonacciHeap.Contains(5124))
+            {
+                Assert.Fail();
+            }
+        }
+
+        [TestMethod()]
+        public void ClearTest()
+        {
+            for(int i = 0; i < 10000; i++)
+            {
+                fibonacciHeap.Insert(i);
+            }
+            fibonacciHeap.RemoveMinimum();
+            fibonacciHeap.Clear();
+            if(fibonacciHeap.Count > 0)
+            {
+                Assert.Fail();
+            }
+        }
+
+        [TestMethod()]
+        public void DisposeTest()
+        {
+            List<FibonacciHeap<int>> heaps = new List<Collections.FibonacciHeap<int>>();
+            for(int i = 0; i < 10; i++)
+            {
+                heaps.Add(new Collections.FibonacciHeap<int>(new Comparison<int>(IntegerComparison)));
+                for(int j = 0; j < 10000; j++)
+                {
+                    heaps[heaps.Count - 1].Insert(j);
+                }
+            }
+            for(int i = 0; i < 10; i++)
+            {
+                heaps[i].Dispose();
+            }
+            GC.Collect();
+            heaps.Clear();
+        }
+
+        [TestMethod()]
+        public void ToArrayTest()
+        {
+            for(int i = 999; i >= 0; i--)
+            {
+                fibonacciHeap.Insert(i);
+            }
+            fibonacciHeap.RemoveMinimum();
+            int[] arr = fibonacciHeap.ToArray();
+
+            for(int i = 1; i < 512; i++)
+            {
+                if(arr[i - 1] != i)
+                {
+                    Assert.Fail();
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/SystemExtensionsTests/Collections/PriorityQueueTests.cs b/SystemExtensionsTests/Collections/PriorityQueueTests.cs
index 68802ba..22af644 100644
--- a/SystemExtensionsTests/Collections/PriorityQueueTests.cs
+++ b/SystemExtensionsTests/Collections/PriorityQueueTests.cs
@@ -5,6 +5,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using SystemExtensions;
 
 namespace SystemExtensions.Collections.Tests
 {
diff --git a/SystemExtensionsTests/SystemExtensionsTests.csproj b/SystemExtensionsTests/SystemExtensionsTests.csproj
index f8ff112..8165f6e 100644
--- a/SystemExtensionsTests/SystemExtensionsTests.csproj
+++ b/SystemExtensionsTests/SystemExtensionsTests.csproj
@@ -57,6 +57,7 @@
   </Choose>
   <ItemGroup>
     <Compile Include="Collections\BinaryHeapTests.cs" />
+    <Compile Include="Collections\FibonacciHeapTests.cs" />
     <Compile Include="Collections\PriorityQueueTests.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Threading\PriorityThreadPoolTests.cs" />