rename Order to SortDirection

Author: justcoding121

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

@@ -17,30 +17,30 @@ public class BHeap<T> : IEnumerable<T> where T : IComparable
 
         public int Count { get; private set; }
 
-        public BHeap(Order order = Order.Ascending)
-            : this(order, null, null) { }
+        public BHeap(SortDirection sortDirection = SortDirection.Ascending)
+            : this(sortDirection, null, null) { }
 
-        public BHeap(Order order, IEnumerable<T> initial)
-            : this(order, initial, null) { }
+        public BHeap(SortDirection sortDirection, IEnumerable<T> initial)
+            : this(sortDirection, initial, null) { }
 
-        public BHeap(Order order, IComparer<T> comparer)
-            : this(order, null, comparer) { }
+        public BHeap(SortDirection sortDirection, IComparer<T> comparer)
+            : this(sortDirection, 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(Order order, IEnumerable<T> initial, IComparer<T> comparer)
+        public BHeap(SortDirection sortDirection, IEnumerable<T> initial, IComparer<T> comparer)
         {
-            this.isMaxHeap = order == Order.Descending;
+            this.isMaxHeap = sortDirection == SortDirection.Descending;
 
             if (comparer != null)
             {
-                this.comparer = new CustomComparer<T>(order, comparer);
+                this.comparer = new CustomComparer<T>(sortDirection, comparer);
             }
             else
             {
-                this.comparer = new CustomComparer<T>(order, Comparer<T>.Default);
+                this.comparer = new CustomComparer<T>(sortDirection, Comparer<T>.Default);
             }
 
             if (initial != null)

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

@@ -21,10 +21,10 @@ private Dictionary<T, List<BinomialHeapNode<T>>> heapMapping
 
         public int Count { get; private set; }
 
-        public BinomialHeap(Order order = Order.Ascending)
+        public BinomialHeap(SortDirection sortDirection = SortDirection.Ascending)
         {
-            this.isMaxHeap = order == Order.Descending;
-            comparer = new CustomComparer<T>(order, Comparer<T>.Default);
+            this.isMaxHeap = sortDirection == SortDirection.Descending;
+            comparer = new CustomComparer<T>(sortDirection, Comparer<T>.Default);
         }
 
         /// <summary>

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

@@ -23,10 +23,10 @@ private Dictionary<T, List<FibornacciHeapNode<T>>> heapMapping
 
         public int Count { get; private set; }
 
-        public FibornacciHeap(Order order = Order.Ascending)
+        public FibornacciHeap(SortDirection sortDirection = SortDirection.Ascending)
         {
-            this.isMaxHeap = order == Order.Descending;
-            comparer = new CustomComparer<T>(order, Comparer<T>.Default);
+            this.isMaxHeap = sortDirection == SortDirection.Descending;
+            comparer = new CustomComparer<T>(sortDirection, Comparer<T>.Default);
         }
 
         /// <summary>

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

@@ -19,10 +19,10 @@ private Dictionary<T, List<PairingHeapNode<T>>> heapMapping
 
         public int Count { get; private set; }
 
-        public PairingHeap(Order order = Order.Ascending)
+        public PairingHeap(SortDirection sortDirection = SortDirection.Ascending)
         {
-            this.isMaxHeap = order == Order.Descending;
-            comparer = new CustomComparer<T>(order, Comparer<T>.Default);
+            this.isMaxHeap = sortDirection == SortDirection.Descending;
+            comparer = new CustomComparer<T>(sortDirection, Comparer<T>.Default);
         }
 
         /// <summary>

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

@@ -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, Order order = Order.Ascending, IEnumerable<T> initial = null)
+        public DaryHeap(int k, SortDirection sortDirection = SortDirection.Ascending, IEnumerable<T> initial = null)
         {
-            this.isMaxHeap = order == Order.Descending;
-            comparer = new CustomComparer<T>(order, Comparer<T>.Default);
+            this.isMaxHeap = sortDirection == SortDirection.Descending;
+            comparer = new CustomComparer<T>(sortDirection, 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(Order order = Order.Ascending)
+        public PriorityQueue(SortDirection sortDirection = SortDirection.Ascending)
         {
-            heap = new BHeap<T>(order);
+            heap = new BHeap<T>(sortDirection);
         }
 
         /// <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>(Order.Ascending, eventQueueLookUp, new EventQueueComparer());
+            eventQueue = new BHeap<Event>(SortDirection.Ascending, eventQueueLookUp, new EventQueueComparer());
         }
 
         public Dictionary<Point, List<Line>> FindIntersections(IEnumerable<Line> lineSegments)

src/Advanced.Algorithms/Search/QuickSelect.cs

@@ -60,7 +60,7 @@ private static T medianOfMedian(T[] input, int left, int right)
                 return input[left];
             }
 
-            var comparer = new CustomComparer<T>(Order.Ascending, Comparer<T>.Default);
+            var comparer = new CustomComparer<T>(SortDirection.Ascending, Comparer<T>.Default);
 
             var size = 5;
             var currentLeft = left;

src/Advanced.Algorithms/Shared/Comparer.cs renamed to src/Advanced.Algorithms/Shared/CustomComparer.cs

@@ -11,9 +11,9 @@ internal class CustomComparer<T> : IComparer<T> where T : IComparable
         private readonly bool isMax;
         private readonly IComparer<T> comparer;
 
-        internal CustomComparer(Order order, IComparer<T> comparer)
+        internal CustomComparer(SortDirection sortDirection, IComparer<T> comparer)
         {
-            this.isMax = order == Order.Descending;
+            this.isMax = sortDirection == SortDirection.Descending;
             this.comparer = comparer;
         }
 

src/Advanced.Algorithms/Shared/Order.cs renamed to src/Advanced.Algorithms/Shared/SortDirection.cs

@@ -6,7 +6,7 @@
 
 namespace Advanced.Algorithms
 {
-    public enum Order
+    public enum SortDirection
     {
         Ascending = 0,
         Descending = 1