Sort descending option

Author: justcoding121

src/Advanced.Algorithms/DataStructures/Heap/BHeap.cs

@@ -10,37 +10,37 @@ namespace Advanced.Algorithms.DataStructures
     /// </summary>
     public class BHeap<T> : IEnumerable<T> where T : IComparable
     {
-        private readonly bool isMax;
+        private readonly bool isMaxHeap;
 
         private T[] heapArray;
         private readonly IComparer<T> comparer;
 
         public int Count { get; private set; }
 
-        public BHeap(bool isMax = false)
-            : this(isMax, null, null) { }
+        public BHeap(Order order = Order.Ascending)
+            : this(order, null, null) { }
 
-        public BHeap(bool isMax, IEnumerable<T> initial)
-            : this(isMax, initial, null) { }
+        public BHeap(Order order, IEnumerable<T> initial)
+            : this(order, initial, null) { }
 
-        public BHeap(bool isMax, IComparer<T> comparer)
-            : this(isMax, null, comparer) { }
+        public BHeap(Order order, IComparer<T> comparer)
+            : this(order, null, comparer) { }
 
         /// <summary>
         /// Time complexity: O(n) if initial is provided. Otherwise O(1).
         /// </summary>
         /// <param name="initial">The initial items in the heap.</param>
-        public BHeap(bool isMax, IEnumerable<T> initial, IComparer<T> comparer)
+        public BHeap(Order order, IEnumerable<T> initial, IComparer<T> comparer)
         {
-            this.isMax = isMax;
+            this.isMaxHeap = order == Order.Descending;
 
             if (comparer != null)
             {
-                this.comparer = new HeapComparer<T>(isMax, comparer);
+                this.comparer = new CustomComparer<T>(order, comparer);
             }
             else
             {
-                this.comparer = new HeapComparer<T>(isMax, Comparer<T>.Default);
+                this.comparer = new CustomComparer<T>(order, Comparer<T>.Default);
             }
 
             if (initial != null)

src/Advanced.Algorithms/DataStructures/Heap/BinomialHeap.cs

@@ -10,7 +10,7 @@ namespace Advanced.Algorithms.DataStructures
     /// </summary>
     public class BinomialHeap<T> : IEnumerable<T> where T : IComparable
     {
-        private readonly bool isMax;
+        private readonly bool isMaxHeap;
         private readonly IComparer<T> comparer;
 
         private DoublyLinkedList<BinomialHeapNode<T>> heapForest
@@ -21,10 +21,10 @@ private Dictionary<T, List<BinomialHeapNode<T>>> heapMapping
 
         public int Count { get; private set; }
 
-        public BinomialHeap(bool isMax = false)
+        public BinomialHeap(Order order = Order.Ascending)
         {
-            this.isMax = isMax;
-            comparer = new HeapComparer<T>(isMax, Comparer<T>.Default);
+            this.isMaxHeap = order == Order.Descending;
+            comparer = new CustomComparer<T>(order, Comparer<T>.Default);
         }
 
         /// <summary>
@@ -109,7 +109,7 @@ public void UpdateKey(T currentValue, T newValue)
 
             if (comparer.Compare(newValue, node.Value) > 0)
             {
-                throw new Exception($"New value is not {(!isMax ? "less" : "greater")} than old value.");
+                throw new Exception($"New value is not {(!isMaxHeap ? "less" : "greater")} than old value.");
             }
 
             updateNodeValue(currentValue, newValue, node);

src/Advanced.Algorithms/DataStructures/Heap/FibornacciHeap.cs

@@ -10,7 +10,7 @@ namespace Advanced.Algorithms.DataStructures
     /// </summary>
     public class FibornacciHeap<T> : IEnumerable<T> where T : IComparable
     {
-        private readonly bool isMax;
+        private readonly bool isMaxHeap;
         private readonly IComparer<T> comparer;
 
         //holds the min/max node at any given time
@@ -23,10 +23,10 @@ private Dictionary<T, List<FibornacciHeapNode<T>>> heapMapping
 
         public int Count { get; private set; }
 
-        public FibornacciHeap(bool isMax = false)
+        public FibornacciHeap(Order order = Order.Ascending)
         {
-            this.isMax = isMax;
-            comparer = new HeapComparer<T>(isMax, Comparer<T>.Default);
+            this.isMaxHeap = order == Order.Descending;
+            comparer = new CustomComparer<T>(order, Comparer<T>.Default);
         }
 
         /// <summary>
@@ -97,7 +97,7 @@ public void UpdateKey(T currentValue, T newValue)
 
             if (comparer.Compare(newValue, node.Value) > 0)
             {
-                throw new Exception($"New value is not {(!isMax ? "less" : "greater")} than old value.");
+                throw new Exception($"New value is not {(!isMaxHeap ? "less" : "greater")} than old value.");
             }
 
             updateNodeValue(currentValue, newValue, node);

src/Advanced.Algorithms/DataStructures/Heap/PairingHeap.cs

@@ -10,7 +10,7 @@ namespace Advanced.Algorithms.DataStructures
     /// </summary>
     public class PairingHeap<T> : IEnumerable<T> where T : IComparable
     {
-        private readonly bool isMax;
+        private readonly bool isMaxHeap;
         private readonly IComparer<T> comparer;
 
         private PairingHeapNode<T> Root;
@@ -19,10 +19,10 @@ private Dictionary<T, List<PairingHeapNode<T>>> heapMapping
 
         public int Count { get; private set; }
 
-        public PairingHeap(bool isMax = false)
+        public PairingHeap(Order order = Order.Ascending)
         {
-            this.isMax = isMax;
-            comparer = new HeapComparer<T>(isMax, Comparer<T>.Default);
+            this.isMaxHeap = order == Order.Descending;
+            comparer = new CustomComparer<T>(order, Comparer<T>.Default);
         }
 
         /// <summary>
@@ -63,7 +63,7 @@ public void UpdateKey(T currentValue, T newValue)
 
             if (comparer.Compare(newValue, node.Value) > 0)
             {
-                throw new Exception($"New value is not {(!isMax ? "less" : "greater")} than old value.");
+                throw new Exception($"New value is not {(!isMaxHeap ? "less" : "greater")} than old value.");
             }
 
             updateNodeValue(currentValue, newValue, node);

src/Advanced.Algorithms/DataStructures/Heap/d-aryHeap.cs

@@ -10,7 +10,7 @@ namespace Advanced.Algorithms.DataStructures
     /// </summary>
     public class DaryHeap<T> : IEnumerable<T> where T : IComparable
     {
-        private readonly bool isMax;
+        private readonly bool isMaxHeap;
         private readonly IComparer<T> comparer;
 
         private T[] heapArray;
@@ -22,10 +22,10 @@ public class DaryHeap<T> : IEnumerable<T> where T : IComparable
         /// </summary>
         /// <param name="k">The number of children per heap node.</param>
         /// <param name="initial">The initial items if any.</param>
-        public DaryHeap(int k,  bool isMax = false, IEnumerable<T> initial = null)
+        public DaryHeap(int k, Order order = Order.Ascending, IEnumerable<T> initial = null)
         {
-            this.isMax = isMax;
-            comparer = new HeapComparer<T>(isMax, Comparer<T>.Default);
+            this.isMaxHeap = order == Order.Descending;
+            comparer = new CustomComparer<T>(order, Comparer<T>.Default);
 
             if (k <= 2)
             {

src/Advanced.Algorithms/DataStructures/Queues/PriorityQueue.cs

@@ -10,9 +10,9 @@ namespace Advanced.Algorithms.DataStructures
     public class PriorityQueue<T> : IEnumerable<T> where T : IComparable
     {
         private readonly BHeap<T> heap;
-        public PriorityQueue(bool isMax = false)
+        public PriorityQueue(Order order = Order.Ascending)
         {
-            heap = new BHeap<T>(isMax);
+            heap = new BHeap<T>(order);
         }
 
         /// <summary>

src/Advanced.Algorithms/Geometry/BentleyOttmann.cs

@@ -66,7 +66,7 @@ private void initialize(IEnumerable<Line> lineSegments)
                                     x.Value
                                 }), new PointComparer());
 
-            eventQueue = new BHeap<Event>(false, eventQueueLookUp, new EventQueueComparer());
+            eventQueue = new BHeap<Event>(Order.Ascending, eventQueueLookUp, new EventQueueComparer());
         }
 
         public Dictionary<Point, List<Line>> FindIntersections(IEnumerable<Line> lineSegments)

src/Advanced.Algorithms/Search/QuickSelect.cs

@@ -60,6 +60,8 @@ private static T medianOfMedian(T[] input, int left, int right)
                 return input[left];
             }
 
+            var comparer = new CustomComparer<T>(Order.Ascending, Comparer<T>.Default);
+
             var size = 5;
             var currentLeft = left;
 
@@ -71,12 +73,12 @@ private static T medianOfMedian(T[] input, int left, int right)
 
                 if (currentRight <= right)
                 {
-                    sort(input, currentLeft, currentRight);
+                    sort(input, currentLeft, currentRight, comparer);
                     medians[++medianIndex] = median(input, currentLeft, currentRight);
                 }
                 else
                 {
-                    sort(input, currentLeft, right);
+                    sort(input, currentLeft, right, comparer);
                     medians[++medianIndex] = median(input, currentLeft, right);
                 }
 
@@ -116,9 +118,9 @@ private static int partition(T[] input, int left, int right, int pivot)
             return newPivot;
         }
 
-        private static void sort(T[] input, int left, int right)
+        private static void sort(T[] input, int left, int right, CustomComparer<T> comparer)
         {
-            MergeSort<T>.PartitionMerge(input, left, right);
+            MergeSort<T>.PartitionMerge(input, left, right, comparer);
         }
 
         private static T median(T[] input, int left, int right)

src/Advanced.Algorithms/DataStructures/Heap/Shared/HeapComparer.cs renamed to src/Advanced.Algorithms/Shared/Comparer.cs

@@ -4,16 +4,16 @@
 using System.Text;
 using System.Threading.Tasks;
 
-namespace Advanced.Algorithms.DataStructures
+namespace Advanced.Algorithms
 {
-    internal class HeapComparer<T> : IComparer<T> where T : IComparable
+    internal class CustomComparer<T> : IComparer<T> where T : IComparable
     {
         private readonly bool isMax;
         private readonly IComparer<T> comparer;
 
-        internal HeapComparer(bool isMax, IComparer<T> comparer)
+        internal CustomComparer(Order order, IComparer<T> comparer)
         {
-            this.isMax = isMax;
+            this.isMax = order == Order.Descending;
             this.comparer = comparer;
         }
 

src/Advanced.Algorithms/Shared/Order.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Advanced.Algorithms
+{
+    public enum Order
+    {
+        Ascending = 0,
+        Descending = 1
+    }
+}