fix Fibonacci spelling

justcoding121 · justcoding121 · commit 5db2d402d1e2 · 2018-12-10T10:03:28.000-05:00
diff --git a/README.md b/README.md
@@ -74,7 +74,7 @@ Supports
 - [X] Binary heap ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/src/Advanced.Algorithms/DataStructures/Heap/BHeap.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/tests/Advanced.Algorithms.Tests/DataStructures/Heap/BHeap_Tests.cs))
 - [X] d-ary heap ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/src/Advanced.Algorithms/DataStructures/Heap/d-aryHeap.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/tests/Advanced.Algorithms.Tests/DataStructures/Heap/D-aryHeap_Tests.cs))
 - [X] Binomial heap ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/src/Advanced.Algorithms/DataStructures/Heap/BinomialHeap.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/tests/Advanced.Algorithms.Tests/DataStructures/Heap/BinomialHeap_Tests.cs))
-- [X] Fibornacci heap ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/src/Advanced.Algorithms/DataStructures/Heap/FibornacciHeap.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/tests/Advanced.Algorithms.Tests/DataStructures/Heap/FibornacciHeap_Tests.cs))
+- [X] Fibonacci heap ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/src/Advanced.Algorithms/DataStructures/Heap/FibonacciHeap.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/tests/Advanced.Algorithms.Tests/DataStructures/Heap/FibonacciHeap_Tests.cs))
 - [X] Pairing heap ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/src/Advanced.Algorithms/DataStructures/Heap/PairingHeap.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/tests/Advanced.Algorithms.Tests/DataStructures/Heap/PairingHeap_Tests.cs))
 
 Note: It is observed that among the implementations here in practice, with the exclusion of UpdateKey (decrement/increment) operation regular Binary Heap & d-ary Heap outperforms other in theory superiors. Likely because it don't have pointer juggling overhead and hey arrays are faster!
@@ -175,11 +175,11 @@ TODO: implement trie compression.
 #### Shortest path
 
 - [X] Bellman-Ford algorithm ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/src/Advanced.Algorithms/Graph/ShortestPath/Bellman-Ford.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/tests/Advanced.Algorithms.Tests/Graph/ShortestPath/BellmanFord_Tests.cs))
-- [X] Dijikstra's algorithm ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/src/Advanced.Algorithms/Graph/ShortestPath/Dijikstra.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/tests/Advanced.Algorithms.Tests/Graph/ShortestPath/Dijikstras_Tests.cs)) using Fibornacci heap.
+- [X] Dijikstra's algorithm ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/src/Advanced.Algorithms/Graph/ShortestPath/Dijikstra.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/tests/Advanced.Algorithms.Tests/Graph/ShortestPath/Dijikstras_Tests.cs)) using Fibonacci heap.
 - [X] Floyd-Warshall algorithm ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/src/Advanced.Algorithms/Graph/ShortestPath/Floyd-Warshall.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/tests/Advanced.Algorithms.Tests/Graph/ShortestPath/FloydWarshall_Tests.cs))
 - [X] Johnson's algorithm ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/src/Advanced.Algorithms/Graph/ShortestPath/Johnsons.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/tests/Advanced.Algorithms.Tests/Graph/ShortestPath/Johnson_Tests.cs))
 - [X] Travelling salesman path ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/src/Advanced.Algorithms/Graph/ShortestPath/TravellingSalesman.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/tests/Advanced.Algorithms.Tests/Graph/ShortestPath/TravellingSalesman_Tests.cs))
-- [X] A* search algorithm ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/src/Advanced.Algorithms/Graph/ShortestPath/AStar.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/tests/Advanced.Algorithms.Tests/Graph/ShortestPath/AStar_Tests.cs)) using Fibornacci heap.
+- [X] A* search algorithm ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/src/Advanced.Algorithms/Graph/ShortestPath/AStar.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/tests/Advanced.Algorithms.Tests/Graph/ShortestPath/AStar_Tests.cs)) using Fibonacci heap.
 
 #### Matching
 
diff --git a/src/Advanced.Algorithms/Compression/HuffmanCoding.cs b/src/Advanced.Algorithms/Compression/HuffmanCoding.cs
@@ -5,7 +5,7 @@
 namespace Advanced.Algorithms.Compression
 {
     /// <summary>
-    /// A huffman coding implementation using Fibornacci Min Heap.
+    /// A huffman coding implementation using Fibonacci Min Heap.
     /// </summary>
     public class HuffmanCoding<T>
     {
diff --git a/src/Advanced.Algorithms/DataStructures/Heap/FibonacciHeap.cs b/src/Advanced.Algorithms/DataStructures/Heap/FibonacciHeap.cs
@@ -8,22 +8,22 @@ namespace Advanced.Algorithms.DataStructures
     /// <summary>
     /// A fibornacci minMax heap implementation.
     /// </summary>
-    public class FibornacciHeap<T> : IEnumerable<T> where T : IComparable
+    public class FibonacciHeap<T> : IEnumerable<T> where T : IComparable
     {
         private readonly bool isMaxHeap;
         private readonly IComparer<T> comparer;
 
         //holds the min/max node at any given time
-        private FibornacciHeapNode<T> minMaxNode = null;
+        private FibonacciHeapNode<T> minMaxNode = null;
 
-        private FibornacciHeapNode<T> heapForestHead;
+        private FibonacciHeapNode<T> heapForestHead;
 
-        private Dictionary<T, List<FibornacciHeapNode<T>>> heapMapping
-            = new Dictionary<T, List<FibornacciHeapNode<T>>>();
+        private Dictionary<T, List<FibonacciHeapNode<T>>> heapMapping
+            = new Dictionary<T, List<FibonacciHeapNode<T>>>();
 
         public int Count { get; private set; }
 
-        public FibornacciHeap(SortDirection sortDirection = SortDirection.Ascending)
+        public FibonacciHeap(SortDirection sortDirection = SortDirection.Ascending)
         {
             this.isMaxHeap = sortDirection == SortDirection.Descending;
             comparer = new CustomComparer<T>(sortDirection, Comparer<T>.Default);
@@ -34,7 +34,7 @@ public FibornacciHeap(SortDirection sortDirection = SortDirection.Ascending)
         /// </summary>
         public void Insert(T newItem)
         {
-            var newNode = new FibornacciHeapNode<T>(newItem);
+            var newNode = new FibonacciHeapNode<T>(newItem);
 
             //return pointer to new Node
             mergeForests(newNode);
@@ -145,10 +145,10 @@ public void UpdateKey(T currentValue, T newValue)
         /// Unions this heap with another.
         /// Time complexity: O(1).
         /// </summary>
-        public void Merge(FibornacciHeap<T> FibornacciHeap)
+        public void Merge(FibonacciHeap<T> FibonacciHeap)
         {
-            mergeForests(FibornacciHeap.heapForestHead);
-            Count = Count + FibornacciHeap.Count;
+            mergeForests(FibonacciHeap.heapForestHead);
+            Count = Count + FibonacciHeap.Count;
         }
 
         /// <summary>
@@ -177,7 +177,7 @@ private void Meld()
             }
 
             //degree - node dictionary
-            var mergeDictionary = new Dictionary<int, FibornacciHeapNode<T>>();
+            var mergeDictionary = new Dictionary<int, FibonacciHeapNode<T>>();
 
             var current = heapForestHead;
             minMaxNode = current;
@@ -270,7 +270,7 @@ private void Meld()
         /// <summary>
         /// Delete this node from Heap Tree and adds it to forest as a new tree 
         /// </summary>
-        private void cut(FibornacciHeapNode<T> node)
+        private void cut(FibonacciHeapNode<T> node)
         {
             var parent = node.Parent;
 
@@ -301,7 +301,7 @@ private void cut(FibornacciHeapNode<T> node)
         /// <summary>
         /// Merges the given fibornacci node list to current Forest 
         /// </summary>
-        private void mergeForests(FibornacciHeapNode<T> headPointer)
+        private void mergeForests(FibonacciHeapNode<T> headPointer)
         {
             var current = headPointer;
             while (current != null)
@@ -313,7 +313,7 @@ private void mergeForests(FibornacciHeapNode<T> headPointer)
 
         }
 
-        private void insertNode(ref FibornacciHeapNode<T> head, FibornacciHeapNode<T> newNode)
+        private void insertNode(ref FibonacciHeapNode<T> head, FibonacciHeapNode<T> newNode)
         {
             newNode.Next = newNode.Previous = null;
 
@@ -329,7 +329,7 @@ private void insertNode(ref FibornacciHeapNode<T> head, FibornacciHeapNode<T> ne
             head = newNode;
         }
 
-        private void deleteNode(ref FibornacciHeapNode<T> heapForestHead, FibornacciHeapNode<T> deletionNode)
+        private void deleteNode(ref FibonacciHeapNode<T> heapForestHead, FibonacciHeapNode<T> deletionNode)
         {
             if (deletionNode == heapForestHead)
             {
@@ -355,26 +355,26 @@ private void deleteNode(ref FibornacciHeapNode<T> heapForestHead, FibornacciHeap
             deletionNode.Previous = null;
         }
 
-        private void addMapping(T newItem, FibornacciHeapNode<T> newNode)
+        private void addMapping(T newItem, FibonacciHeapNode<T> newNode)
         {
             if (heapMapping.ContainsKey(newItem))
             {
                 heapMapping[newItem].Add(newNode);
             }
             else
             {
-                heapMapping[newItem] = new List<FibornacciHeapNode<T>>(new[] { newNode });
+                heapMapping[newItem] = new List<FibonacciHeapNode<T>>(new[] { newNode });
             }
         }
 
-        private void updateNodeValue(T currentValue, T newValue, FibornacciHeapNode<T> node)
+        private void updateNodeValue(T currentValue, T newValue, FibonacciHeapNode<T> node)
         {
             removeMapping(currentValue, node);
             node.Value = newValue;
             addMapping(newValue, node);
         }
 
-        private void removeMapping(T currentValue, FibornacciHeapNode<T> node)
+        private void removeMapping(T currentValue, FibonacciHeapNode<T> node)
         {
             heapMapping[currentValue].Remove(node);
             if (heapMapping[currentValue].Count == 0)
diff --git a/src/Advanced.Algorithms/DataStructures/Heap/Shared/FibornacciHeapNode.cs b/src/Advanced.Algorithms/DataStructures/Heap/Shared/FibornacciHeapNode.cs
@@ -2,27 +2,27 @@
 
 namespace Advanced.Algorithms.DataStructures
 {
-    internal class FibornacciHeapNode<T> : IComparable where T : IComparable
+    internal class FibonacciHeapNode<T> : IComparable where T : IComparable
     {
         internal T Value { get; set; }
 
         internal int Degree;
-        internal FibornacciHeapNode<T> ChildrenHead { get; set; }
+        internal FibonacciHeapNode<T> ChildrenHead { get; set; }
 
-        internal FibornacciHeapNode<T> Parent { get; set; }
+        internal FibonacciHeapNode<T> Parent { get; set; }
         internal bool LostChild { get; set; }
 
-        internal FibornacciHeapNode<T> Previous;
-        internal FibornacciHeapNode<T> Next;
+        internal FibonacciHeapNode<T> Previous;
+        internal FibonacciHeapNode<T> Next;
 
-        internal FibornacciHeapNode(T value)
+        internal FibonacciHeapNode(T value)
         {
             Value = value;
         }
 
         public int CompareTo(object obj)
         {
-            return Value.CompareTo(((FibornacciHeapNode<T>) obj).Value);
+            return Value.CompareTo(((FibonacciHeapNode<T>) obj).Value);
         }
     }
 
diff --git a/src/Advanced.Algorithms/Graph/MinimumSpanningTree/Prims.cs b/src/Advanced.Algorithms/Graph/MinimumSpanningTree/Prims.cs
@@ -32,15 +32,15 @@ public List<MSTEdge<T, W>>
         /// Do DFS to pick smallest weight neighbour edges 
         /// of current spanning tree one by one.
         /// </summary>
-        /// <param name="spanTreeNeighbours"> Use Fibornacci Min Heap to pick smallest edge neighbour </param>
+        /// <param name="spanTreeNeighbours"> Use Fibonacci Min Heap to pick smallest edge neighbour </param>
         /// <param name="spanTreeEdges">result MST edges</param>
         private void dfs(WeightedGraph<T, W> graph, WeightedGraphVertex<T, W> currentVertex, 
             BHeap<MSTEdge<T, W>> spanTreeNeighbours, HashSet<T> spanTreeVertices, 
             List<MSTEdge<T, W>> spanTreeEdges)
         {
             while (true)
             {
-                //add all edges to Fibornacci Heap
+                //add all edges to Fibonacci Heap
                 //So that we can pick the min edge in next step
                 foreach (var edge in currentVertex.Edges)
                 {
diff --git a/src/Advanced.Algorithms/Graph/ShortestPath/AStar.cs b/src/Advanced.Algorithms/Graph/ShortestPath/AStar.cs
@@ -7,7 +7,7 @@
 namespace Advanced.Algorithms.Graph
 {
     /// <summary>
-    /// A* algorithm implementation using Fibornacci Heap.
+    /// A* algorithm implementation using Fibonacci Heap.
     /// </summary>
     public class AStarShortestPath<T, W> where W : IComparable
     {
@@ -38,7 +38,7 @@ public ShortestPathResult<T, W> FindShortestPath(WeightedDiGraph<T, W> graph, T
             var parentMap = new Dictionary<T, T>();
 
             //min heap to pick next closest vertex 
-            var minHeap = new FibornacciHeap<AStarWrap<T, W>>();
+            var minHeap = new FibonacciHeap<AStarWrap<T, W>>();
             //keep references of heap Node for decrement key operation
             var heapMapping = new Dictionary<T, AStarWrap<T, W>>();
 
@@ -167,7 +167,7 @@ public interface IAStarHeuristic<T, W> where W : IComparable
         W HueristicDistanceToTarget(T sourceVertex, T targetVertex);
     }
 
-    //Node for our Fibornacci heap
+    //Node for our Fibonacci heap
     internal class AStarWrap<T, W> : IComparable where W : IComparable
     {
         private IAStarHeuristic<T, W> heuristic;
diff --git a/src/Advanced.Algorithms/Graph/ShortestPath/Dijikstra.cs b/src/Advanced.Algorithms/Graph/ShortestPath/Dijikstra.cs
@@ -7,7 +7,7 @@
 namespace Advanced.Algorithms.Graph
 {
     /// <summary>
-    /// A dijikstra algorithm implementation using Fibornacci Heap.
+    /// A dijikstra algorithm implementation using Fibonacci Heap.
     /// </summary>
     public class DijikstraShortestPath<T, W> where W : IComparable
     {
@@ -35,7 +35,7 @@ public ShortestPathResult<T, W> FindShortestPath(WeightedDiGraph<T, W> graph, T
             var parentMap = new Dictionary<T, T>();
 
             //min heap to pick next closest vertex 
-            var minHeap = new FibornacciHeap<MinHeapWrap<T, W>>();
+            var minHeap = new FibonacciHeap<MinHeapWrap<T, W>>();
             //keep references of heap Node for decrement key operation
             var heapMapping = new Dictionary<T, MinHeapWrap<T, W>>();
 
diff --git a/tests/Advanced.Algorithms.Tests/Advanced.Algorithms.Tests.csproj b/tests/Advanced.Algorithms.Tests/Advanced.Algorithms.Tests.csproj
@@ -78,7 +78,7 @@
     <Compile Include="DataStructures\Heap\BHeap_Tests.cs" />
     <Compile Include="DataStructures\Heap\BinomialHeap_Tests.cs" />
     <Compile Include="DataStructures\Heap\D-aryHeap_Tests.cs" />
-    <Compile Include="DataStructures\Heap\FibornacciHeap_Tests.cs" />
+    <Compile Include="DataStructures\Heap\FibonacciHeap_Tests.cs" />
     <Compile Include="DataStructures\Heap\PairingHeap_Tests.cs" />
     <Compile Include="DataStructures\LinkedList\CircularLinkedList_Tests.cs" />
     <Compile Include="DataStructures\LinkedList\DoublyLinkedList_Tests.cs" />
diff --git a/tests/Advanced.Algorithms.Tests/DataStructures/Heap/FibonacciHeap_Tests.cs b/tests/Advanced.Algorithms.Tests/DataStructures/Heap/FibonacciHeap_Tests.cs
@@ -7,15 +7,15 @@
 namespace Advanced.Algorithms.Tests.DataStructures
 {
     [TestClass]
-    public class FibornacciHeap_Tests
+    public class FibonacciHeap_Tests
     {
 
         [TestMethod]
-        public void Min_FibornacciHeap_Test()
+        public void Min_FibonacciHeap_Test()
         {
             int nodeCount = 1000 * 10;
 
-            var minHeap = new FibornacciHeap<int>();
+            var minHeap = new FibonacciHeap<int>();
 
             for (int i = 0; i <= nodeCount; i++)
             {
@@ -66,11 +66,11 @@ public void Min_FibornacciHeap_Test()
 
 
         [TestMethod]
-        public void Max_FibornacciHeap_Test()
+        public void Max_FibonacciHeap_Test()
         {
             int nodeCount = 1000 * 10;
  
-            var maxHeap = new FibornacciHeap<int>(SortDirection.Descending);
+            var maxHeap = new FibonacciHeap<int>(SortDirection.Descending);
 
             for (int i = 0; i <= nodeCount; i++)
             {

Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@`
`5`	`5`	`namespace Advanced.Algorithms.Compression`
`6`	`6`	`{`
`7`	`7`	`/// <summary>`
`8`		`- /// A huffman coding implementation using Fibornacci Min Heap.`
	`8`	`+ /// A huffman coding implementation using Fibonacci Min Heap.`
`9`	`9`	`/// </summary>`
`10`	`10`	`public class HuffmanCoding<T>`
`11`	`11`	`{`
Original file line number	Diff line number	Diff line change
`@@ -8,22 +8,22 @@ namespace Advanced.Algorithms.DataStructures`
`8`	`8`	`/// <summary>`
`9`	`9`	`/// A fibornacci minMax heap implementation.`
`10`	`10`	`/// </summary>`
`11`		`- public class FibornacciHeap<T> : IEnumerable<T> where T : IComparable`
	`11`	`+ public class FibonacciHeap<T> : IEnumerable<T> where T : IComparable`
`12`	`12`	`{`
`13`	`13`	`private readonly bool isMaxHeap;`
`14`	`14`	`private readonly IComparer<T> comparer;`
`15`	`15`
`16`	`16`	`//holds the min/max node at any given time`
`17`		`- private FibornacciHeapNode<T> minMaxNode = null;`
	`17`	`+ private FibonacciHeapNode<T> minMaxNode = null;`
`18`	`18`
`19`		`- private FibornacciHeapNode<T> heapForestHead;`
	`19`	`+ private FibonacciHeapNode<T> heapForestHead;`
`20`	`20`
`21`		`- private Dictionary<T, List<FibornacciHeapNode<T>>> heapMapping`
`22`		`- = new Dictionary<T, List<FibornacciHeapNode<T>>>();`
	`21`	`+ private Dictionary<T, List<FibonacciHeapNode<T>>> heapMapping`
	`22`	`+ = new Dictionary<T, List<FibonacciHeapNode<T>>>();`
`23`	`23`
`24`	`24`	`public int Count { get; private set; }`
`25`	`25`
`26`		`- public FibornacciHeap(SortDirection sortDirection = SortDirection.Ascending)`
	`26`	`+ public FibonacciHeap(SortDirection sortDirection = SortDirection.Ascending)`
`27`	`27`	`{`
`28`	`28`	`this.isMaxHeap = sortDirection == SortDirection.Descending;`
`29`	`29`	`comparer = new CustomComparer<T>(sortDirection, Comparer<T>.Default);`
`@@ -34,7 +34,7 @@ public FibornacciHeap(SortDirection sortDirection = SortDirection.Ascending)`
`34`	`34`	`/// </summary>`
`35`	`35`	`public void Insert(T newItem)`
`36`	`36`	`{`
`37`		`- var newNode = new FibornacciHeapNode<T>(newItem);`
	`37`	`+ var newNode = new FibonacciHeapNode<T>(newItem);`
`38`	`38`
`39`	`39`	`//return pointer to new Node`
`40`	`40`	`mergeForests(newNode);`
`@@ -145,10 +145,10 @@ public void UpdateKey(T currentValue, T newValue)`
`145`	`145`	`/// Unions this heap with another.`
`146`	`146`	`/// Time complexity: O(1).`
`147`	`147`	`/// </summary>`
`148`		`- public void Merge(FibornacciHeap<T> FibornacciHeap)`
	`148`	`+ public void Merge(FibonacciHeap<T> FibonacciHeap)`
`149`	`149`	`{`
`150`		`- mergeForests(FibornacciHeap.heapForestHead);`
`151`		`- Count = Count + FibornacciHeap.Count;`
	`150`	`+ mergeForests(FibonacciHeap.heapForestHead);`
	`151`	`+ Count = Count + FibonacciHeap.Count;`
`152`	`152`	`}`
`153`	`153`
`154`	`154`	`/// <summary>`
`@@ -177,7 +177,7 @@ private void Meld()`
`177`	`177`	`}`
`178`	`178`
`179`	`179`	`//degree - node dictionary`
`180`		`- var mergeDictionary = new Dictionary<int, FibornacciHeapNode<T>>();`
	`180`	`+ var mergeDictionary = new Dictionary<int, FibonacciHeapNode<T>>();`
`181`	`181`
`182`	`182`	`var current = heapForestHead;`
`183`	`183`	`minMaxNode = current;`
`@@ -270,7 +270,7 @@ private void Meld()`
`270`	`270`	`/// <summary>`
`271`	`271`	`/// Delete this node from Heap Tree and adds it to forest as a new tree`
`272`	`272`	`/// </summary>`
`273`		`- private void cut(FibornacciHeapNode<T> node)`
	`273`	`+ private void cut(FibonacciHeapNode<T> node)`
`274`	`274`	`{`
`275`	`275`	`var parent = node.Parent;`
`276`	`276`
`@@ -301,7 +301,7 @@ private void cut(FibornacciHeapNode<T> node)`
`301`	`301`	`/// <summary>`
`302`	`302`	`/// Merges the given fibornacci node list to current Forest`
`303`	`303`	`/// </summary>`
`304`		`- private void mergeForests(FibornacciHeapNode<T> headPointer)`
	`304`	`+ private void mergeForests(FibonacciHeapNode<T> headPointer)`
`305`	`305`	`{`
`306`	`306`	`var current = headPointer;`
`307`	`307`	`while (current != null)`
`@@ -313,7 +313,7 @@ private void mergeForests(FibornacciHeapNode<T> headPointer)`
`313`	`313`
`314`	`314`	`}`
`315`	`315`
`316`		`- private void insertNode(ref FibornacciHeapNode<T> head, FibornacciHeapNode<T> newNode)`
	`316`	`+ private void insertNode(ref FibonacciHeapNode<T> head, FibonacciHeapNode<T> newNode)`
`317`	`317`	`{`
`318`	`318`	`newNode.Next = newNode.Previous = null;`
`319`	`319`
`@@ -329,7 +329,7 @@ private void insertNode(ref FibornacciHeapNode<T> head, FibornacciHeapNode<T> ne`
`329`	`329`	`head = newNode;`
`330`	`330`	`}`
`331`	`331`
`332`		`- private void deleteNode(ref FibornacciHeapNode<T> heapForestHead, FibornacciHeapNode<T> deletionNode)`
	`332`	`+ private void deleteNode(ref FibonacciHeapNode<T> heapForestHead, FibonacciHeapNode<T> deletionNode)`
`333`	`333`	`{`
`334`	`334`	`if (deletionNode == heapForestHead)`
`335`	`335`	`{`
`@@ -355,26 +355,26 @@ private void deleteNode(ref FibornacciHeapNode<T> heapForestHead, FibornacciHeap`
`355`	`355`	`deletionNode.Previous = null;`
`356`	`356`	`}`
`357`	`357`
`358`		`- private void addMapping(T newItem, FibornacciHeapNode<T> newNode)`
	`358`	`+ private void addMapping(T newItem, FibonacciHeapNode<T> newNode)`
`359`	`359`	`{`
`360`	`360`	`if (heapMapping.ContainsKey(newItem))`
`361`	`361`	`{`
`362`	`362`	`heapMapping[newItem].Add(newNode);`
`363`	`363`	`}`
`364`	`364`	`else`
`365`	`365`	`{`
`366`		`- heapMapping[newItem] = new List<FibornacciHeapNode<T>>(new[] { newNode });`
	`366`	`+ heapMapping[newItem] = new List<FibonacciHeapNode<T>>(new[] { newNode });`
`367`	`367`	`}`
`368`	`368`	`}`
`369`	`369`
`370`		`- private void updateNodeValue(T currentValue, T newValue, FibornacciHeapNode<T> node)`
	`370`	`+ private void updateNodeValue(T currentValue, T newValue, FibonacciHeapNode<T> node)`
`371`	`371`	`{`
`372`	`372`	`removeMapping(currentValue, node);`
`373`	`373`	`node.Value = newValue;`
`374`	`374`	`addMapping(newValue, node);`
`375`	`375`	`}`
`376`	`376`
`377`		`- private void removeMapping(T currentValue, FibornacciHeapNode<T> node)`
	`377`	`+ private void removeMapping(T currentValue, FibonacciHeapNode<T> node)`
`378`	`378`	`{`
`379`	`379`	`heapMapping[currentValue].Remove(node);`
`380`	`380`	`if (heapMapping[currentValue].Count == 0)`
Original file line number	Diff line number	Diff line change
`@@ -2,27 +2,27 @@`
`2`	`2`
`3`	`3`	`namespace Advanced.Algorithms.DataStructures`
`4`	`4`	`{`
`5`		`- internal class FibornacciHeapNode<T> : IComparable where T : IComparable`
	`5`	`+ internal class FibonacciHeapNode<T> : IComparable where T : IComparable`
`6`	`6`	`{`
`7`	`7`	`internal T Value { get; set; }`
`8`	`8`
`9`	`9`	`internal int Degree;`
`10`		`- internal FibornacciHeapNode<T> ChildrenHead { get; set; }`
	`10`	`+ internal FibonacciHeapNode<T> ChildrenHead { get; set; }`
`11`	`11`
`12`		`- internal FibornacciHeapNode<T> Parent { get; set; }`
	`12`	`+ internal FibonacciHeapNode<T> Parent { get; set; }`
`13`	`13`	`internal bool LostChild { get; set; }`
`14`	`14`
`15`		`- internal FibornacciHeapNode<T> Previous;`
`16`		`- internal FibornacciHeapNode<T> Next;`
	`15`	`+ internal FibonacciHeapNode<T> Previous;`
	`16`	`+ internal FibonacciHeapNode<T> Next;`
`17`	`17`
`18`		`- internal FibornacciHeapNode(T value)`
	`18`	`+ internal FibonacciHeapNode(T value)`
`19`	`19`	`{`
`20`	`20`	`Value = value;`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`public int CompareTo(object obj)`
`24`	`24`	`{`
`25`		`- return Value.CompareTo(((FibornacciHeapNode<T>) obj).Value);`
	`25`	`+ return Value.CompareTo(((FibonacciHeapNode<T>) obj).Value);`
`26`	`26`	`}`
`27`	`27`	`}`
`28`	`28`
Original file line number	Diff line number	Diff line change
`@@ -32,15 +32,15 @@ public List<MSTEdge<T, W>>`
`32`	`32`	`/// Do DFS to pick smallest weight neighbour edges`
`33`	`33`	`/// of current spanning tree one by one.`
`34`	`34`	`/// </summary>`
`35`		`- /// <param name="spanTreeNeighbours"> Use Fibornacci Min Heap to pick smallest edge neighbour </param>`
	`35`	`+ /// <param name="spanTreeNeighbours"> Use Fibonacci Min Heap to pick smallest edge neighbour </param>`
`36`	`36`	`/// <param name="spanTreeEdges">result MST edges</param>`
`37`	`37`	`private void dfs(WeightedGraph<T, W> graph, WeightedGraphVertex<T, W> currentVertex,`
`38`	`38`	`BHeap<MSTEdge<T, W>> spanTreeNeighbours, HashSet<T> spanTreeVertices,`
`39`	`39`	`List<MSTEdge<T, W>> spanTreeEdges)`
`40`	`40`	`{`
`41`	`41`	`while (true)`
`42`	`42`	`{`
`43`		`- //add all edges to Fibornacci Heap`
	`43`	`+ //add all edges to Fibonacci Heap`
`44`	`44`	`//So that we can pick the min edge in next step`
`45`	`45`	`foreach (var edge in currentVertex.Edges)`
`46`	`46`	`{`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@`
`7`	`7`	`namespace Advanced.Algorithms.Graph`
`8`	`8`	`{`
`9`	`9`	`/// <summary>`
`10`		`- /// A* algorithm implementation using Fibornacci Heap.`
	`10`	`+ /// A* algorithm implementation using Fibonacci Heap.`
`11`	`11`	`/// </summary>`
`12`	`12`	`public class AStarShortestPath<T, W> where W : IComparable`
`13`	`13`	`{`
`@@ -38,7 +38,7 @@ public ShortestPathResult<T, W> FindShortestPath(WeightedDiGraph<T, W> graph, T`
`38`	`38`	`var parentMap = new Dictionary<T, T>();`
`39`	`39`
`40`	`40`	`//min heap to pick next closest vertex`
`41`		`- var minHeap = new FibornacciHeap<AStarWrap<T, W>>();`
	`41`	`+ var minHeap = new FibonacciHeap<AStarWrap<T, W>>();`
`42`	`42`	`//keep references of heap Node for decrement key operation`
`43`	`43`	`var heapMapping = new Dictionary<T, AStarWrap<T, W>>();`
`44`	`44`
`@@ -167,7 +167,7 @@ public interface IAStarHeuristic<T, W> where W : IComparable`
`167`	`167`	`W HueristicDistanceToTarget(T sourceVertex, T targetVertex);`
`168`	`168`	`}`
`169`	`169`
`170`		`- //Node for our Fibornacci heap`
	`170`	`+ //Node for our Fibonacci heap`
`171`	`171`	`internal class AStarWrap<T, W> : IComparable where W : IComparable`
`172`	`172`	`{`
`173`	`173`	`private IAStarHeuristic<T, W> heuristic;`
Original file line number	Diff line number	Diff line change
`@@ -7,15 +7,15 @@`
`7`	`7`	`namespace Advanced.Algorithms.Tests.DataStructures`
`8`	`8`	`{`
`9`	`9`	`[TestClass]`
`10`		`- public class FibornacciHeap_Tests`
	`10`	`+ public class FibonacciHeap_Tests`
`11`	`11`	`{`
`12`	`12`
`13`	`13`	`[TestMethod]`
`14`		`- public void Min_FibornacciHeap_Test()`
	`14`	`+ public void Min_FibonacciHeap_Test()`
`15`	`15`	`{`
`16`	`16`	`int nodeCount = 1000 * 10;`
`17`	`17`
`18`		`- var minHeap = new FibornacciHeap<int>();`
	`18`	`+ var minHeap = new FibonacciHeap<int>();`
`19`	`19`
`20`	`20`	`for (int i = 0; i <= nodeCount; i++)`
`21`	`21`	`{`
`@@ -66,11 +66,11 @@ public void Min_FibornacciHeap_Test()`
`66`	`66`
`67`	`67`
`68`	`68`	`[TestMethod]`
`69`		`- public void Max_FibornacciHeap_Test()`
	`69`	`+ public void Max_FibonacciHeap_Test()`
`70`	`70`	`{`
`71`	`71`	`int nodeCount = 1000 * 10;`
`72`	`72`
`73`		`- var maxHeap = new FibornacciHeap<int>(SortDirection.Descending);`
	`73`	`+ var maxHeap = new FibonacciHeap<int>(SortDirection.Descending);`
`74`	`74`
`75`	`75`	`for (int i = 0; i <= nodeCount; i++)`
`76`	`76`	`{`