Refactored the heaps.

addisu · Jul 29, 2015 · 08ed1bf · 08ed1bf
1 parent 32ab5f8
commit 08ed1bf
Show file tree

Hide file tree

Showing 6 changed files with 55 additions and 17 deletions.
diff --git a/DataStructures/Heaps/BinaryMaxHeap.cs b/DataStructures/Heaps/BinaryMaxHeap.cs
@@ -33,21 +33,21 @@ public BinaryMaxHeap(int capacity, Comparer<T> comparer)
         /// <summary>
         /// Private Method. Builds a max heap from the inner array-list _collection.
         /// </summary>
-        private void BuildMaxHeap()
+        private void _buildMaxHeap()
         {
             int lastIndex = _collection.Count - 1;
             int lastNodeWithChildren = (lastIndex / 2);
 
             for (int node = lastNodeWithChildren; node >= 0; node--)
             {
-                MaxHeapify(node, lastIndex);
+                _maxHeapify(node, lastIndex);
             }
         }
 
         /// <summary>
         /// Private Method. Used in Building a Max Heap.
         /// </summary>
-        private void MaxHeapify(int nodeIndex, int lastIndex)
+        private void _maxHeapify(int nodeIndex, int lastIndex)
         {
             // assume that the subtrees left(node) and right(node) are max-heaps
             int left = (nodeIndex * 2) + 1;
@@ -66,10 +66,11 @@ private void MaxHeapify(int nodeIndex, int lastIndex)
             if (largest != nodeIndex)
             {
                 _collection.Swap(nodeIndex, largest);
-                MaxHeapify(largest, lastIndex);
+                _maxHeapify(largest, lastIndex);
             }
         }
 
+
         /// <summary>
         /// Returns the number of elements in heap
         /// </summary>
@@ -112,7 +113,7 @@ public T this[int index]
                 if (_heapComparer.Compare(_collection[index], _collection[0]) >= 0) // greater than or equal to max
                 {
                     _collection.Swap(0, index);
-                    BuildMaxHeap();
+                    _buildMaxHeap();
                 }
             }
         }
@@ -134,7 +135,7 @@ public void Initialize(IList<T> newCollection)
                 }
 
                 // Build the heap
-                BuildMaxHeap();
+                _buildMaxHeap();
             }
         }
 
@@ -150,7 +151,7 @@ public void Add(T heapKey)
             else
             {
                 _collection.Add(heapKey);
-                BuildMaxHeap();
+                _buildMaxHeap();
             }
         }
 
@@ -184,7 +185,7 @@ public void RemoveMax()
             _collection.RemoveAt(last);
             last--;
 
-            MaxHeapify(0, last);
+            _maxHeapify(0, last);
         }
 
         /// <summary>
@@ -210,6 +211,14 @@ public void Clear()
             _collection.Clear();
         }
 
+        /// <summary>
+        /// Rebuilds the heap.
+        /// </summary>
+        public void RebuildHeap()
+        {
+            _buildMaxHeap();
+        }
+
         /// <summary>
         /// Returns an array version of this heap.
         /// </summary>

diff --git a/DataStructures/Heaps/BinaryMinHeap.cs b/DataStructures/Heaps/BinaryMinHeap.cs
@@ -30,17 +30,18 @@ public BinaryMinHeap(int capacity, Comparer<T> comparer)
             _heapComparer = comparer ?? Comparer<T>.Default;
         }
 
+
         /// <summary>
         /// Builds a min heap from the inner array-list _collection.
         /// </summary>
-        private void BuildMinHeap()
+        private void _buildMinHeap()
         {
             int lastIndex = _collection.Count - 1;
             int lastNodeWithChildren = (lastIndex / 2);
 
             for (int node = lastNodeWithChildren; node >= 0; node--)
             {
-                MinHeapify(node, lastIndex);
+                _minHeapify(node, lastIndex);
             }
         }
 
@@ -50,7 +51,7 @@ private void BuildMinHeap()
         /// <typeparam name="T">Type of Heap elements</typeparam>
         /// <param name="nodeIndex">The node index to heapify at.</param>
         /// <param name="lastIndex">The last index of collection to stop at.</param>
-        private void MinHeapify(int nodeIndex, int lastIndex)
+        private void _minHeapify(int nodeIndex, int lastIndex)
         {
             // assume that the subtrees left(node) and right(node) are max-heaps
             int left = (nodeIndex * 2) + 1;
@@ -69,10 +70,11 @@ private void MinHeapify(int nodeIndex, int lastIndex)
             if (smallest != nodeIndex)
             {
                 _collection.Swap(nodeIndex, smallest);
-                MinHeapify(smallest, lastIndex);
+                _minHeapify(smallest, lastIndex);
             }
         }
 
+
         /// <summary>
         /// Returns the number of elements in heap
         /// </summary>
@@ -116,7 +118,7 @@ public T this[int index]
                 if (_heapComparer.Compare(_collection[index], _collection[0]) <= 0) // less than or equal to min
                 {
                     _collection.Swap(0, index);
-                    BuildMinHeap();
+                    _buildMinHeap();
                 }
             }
         }
@@ -139,7 +141,7 @@ public void Initialize(IList<T> newCollection)
                 }
 
                 // Build the heap
-                BuildMinHeap();
+                _buildMinHeap();
             }
         }
 
@@ -156,7 +158,7 @@ public void Add(T heapKey)
             else
             {
                 _collection.Add(heapKey);
-                BuildMinHeap();
+                _buildMinHeap();
             }
         }
 
@@ -191,7 +193,7 @@ public void RemoveMin()
             _collection.RemoveAt(last);
             last--;
 
-            MinHeapify(0, last);
+            _minHeapify(0, last);
         }
 
         /// <summary>
@@ -218,6 +220,14 @@ public void Clear()
             _collection.Clear();
         }
 
+        /// <summary>
+        /// Rebuilds the heap.
+        /// </summary>
+        public void RebuildHeap()
+        {
+            _buildMinHeap();
+        }
+
         /// <summary>
         /// Returns an array version of this heap.
         /// </summary>

diff --git a/DataStructures/Heaps/BinomialMinHeap.cs b/DataStructures/Heaps/BinomialMinHeap.cs
@@ -339,6 +339,14 @@ public T[] ToArray()
             throw new NotImplementedException();
         }
 
+        /// <summary>
+        /// Rebuilds the heap.
+        /// </summary>
+        public void RebuildHeap()
+        {
+            throw new NotImplementedException();
+        }
+
         /// <summary>
         /// Returns a list copy of heap.
         /// </summary>

diff --git a/DataStructures/Heaps/IMaxHeap.cs b/DataStructures/Heaps/IMaxHeap.cs
@@ -47,6 +47,11 @@ public interface IMaxHeap<T> where T : System.IComparable<T>
         /// </summary>
         void Clear();
 
+        /// <summary>
+        /// Rebuilds the heap.
+        /// </summary>
+        void RebuildHeap();
+
         /// <summary>
         /// Returns an array version of this heap.
         /// </summary>

diff --git a/DataStructures/Heaps/IMinHeap.cs b/DataStructures/Heaps/IMinHeap.cs
@@ -47,6 +47,11 @@ public interface IMinHeap<T> where T : System.IComparable<T>
         /// </summary>
         void Clear();
 
+        /// <summary>
+        /// Rebuilds the heap.
+        /// </summary>
+        void RebuildHeap();
+
         /// <summary>
         /// Returns an array version of this heap.
         /// </summary>

diff --git a/DataStructures/Heaps/MinPriorityQueue.cs b/DataStructures/Heaps/MinPriorityQueue.cs
@@ -191,7 +191,7 @@ public void Enqueue(TKey value, TPriority priority)
         /// <summary>
         /// Dequeue this instance.
         /// </summary>
-        public TKey Dequeue()
+        public TKey DequeueMin()
         {
             if (_heap.IsEmpty)
                 throw new ArgumentOutOfRangeException("Queue is empty.");
@@ -222,6 +222,7 @@ public void UpdatePriority(TKey key, TPriority newPriority)
                 throw new KeyNotFoundException();
 
             _heap[index].Priority = newPriority;
+            //_heap.RebuildHeap();
         }
 
         /// <summary>