Added Parallel MergeSort

Author: skillmaker-dev

Algorithms.NET.Debug/Program.cs

@@ -6,7 +6,7 @@
 List<double> unsortedRand = new() { 8, 9, 3, 3, 7, 1 };
 List<double> unsortedLessThan1 = new() { .8, .9, .3, .3, .1,0 };
 
-var sortedDesc = Algorithms.NET.Sorting.MergeSort.MergeSortAlgorithm.SortDescending(unsortedAsc);
+var sortedDesc = Algorithms.NET.Sorting.MergeSort.MergeSortAlgorithm.SortDescendingParallel(unsortedAsc);
 var sortedAsc = Algorithms.NET.Sorting.BucketSort.BucketSortAlgorithm.SortAscending(unsortedLessThan1);
 
 
@@ -36,7 +36,7 @@
 
 
 
-//var sortingBenchmarkSummary = BenchmarkRunner.Run<SortingBenchmark>();
+var sortingBenchmarkSummary = BenchmarkRunner.Run<SortingBenchmark>();
 //var searchingBenchmarkSummary = BenchmarkRunner.Run<SearchingBenchmark>();
 
 

Algorithms.NET.Debug/SortingBenchmark.cs

@@ -17,7 +17,7 @@ public class SortingBenchmark
         public SortingBenchmark()
         {
             var rand = new Random();
-            for (int i = 0; i < 10000; i++)
+            for (int i = 0; i < 50000; i++)
             {
                 double number = rand.NextDouble();
                 _unsorted.Add(number);
@@ -46,6 +46,10 @@ public void InsertionSort() =>
         public void MergeSort() =>
         MergeSortAlgorithm.SortAscending(_unsorted);
 
+        [Benchmark]
+        public void MergeSortParallel() =>
+        MergeSortAlgorithm.SortAscendingParallel(_unsorted);
+
         [Benchmark]
         public void QuickSort() =>
         QuickSortAlgorithm.SortAscending(_unsorted);

Algorithms.NET/Sorting/MergeSort/MergeSortAlgorithm.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Threading.Tasks;
 
 namespace Algorithms.NET.Sorting.MergeSort
 {
@@ -26,6 +27,29 @@ public static List<double> SortDescending(List<double> list)
             return Sort(sortedList, true);
         }
 
+
+        /// <summary>
+        /// Sorting a list of numbers in ascending order using MergeSort algorithm, Time complexity of O(n Log n).
+        /// </summary>
+        /// <param name="list">List of numbers to sort</param>
+        /// <returns>Sorted list in ascending order.</returns>
+        public static List<double> SortAscendingParallel(List<double> list)
+        {
+            List<double> sortedList = new List<double>(list);
+            return SortParallel(sortedList, false);
+        }
+
+        /// <summary>
+        /// Sorting a list of numbers in descending order using MergeSort algorithm, Time complexity of O(n Log n).
+        /// </summary>
+        /// <param name="list">List of numbers to sort</param>
+        /// <returns>Sorted list in descending order.</returns>
+        public static List<double> SortDescendingParallel(List<double> list)
+        {
+            List<double> sortedList = new List<double>(list);
+            return SortParallel(sortedList, true);
+        }
+
         /// <summary>
         /// Sorting a list of numbers using MergeSort algorithm, Time complexity of O(n Log n).
         /// </summary>
@@ -61,6 +85,50 @@ public static List<double> Sort(List<double> list, bool sortDescending)
             return list;
         }
 
+
+        /// <summary>
+        /// Sorting a list of numbers using MergeSort algorithm, Time complexity of O(n Log n).
+        /// </summary>
+        /// <param name="list">List of numbers to sort</param>
+        /// <param name="sortDescending">Boolean value specifying whether sorting should be done in descending order</param>
+        /// <returns>A sorted list</returns>
+        public static List<double> SortParallel(List<double> list, bool sortDescending)
+        {
+            //We stop recursion when size is 1, which means an array of one element is sorted.
+            if (list.Count < 2)
+                return list;
+
+            //Divide list in half.
+            int middle = list.Count / 2;
+
+            List<double> left = new List<double>();
+            List<double> right = new List<double>();
+
+            //Fill each half
+            for (int i = 0; i < middle; i++)
+                left.Add(list[i]);
+
+            for (int j = middle; j < list.Count; j++)
+                right.Add(list[j]);
+
+            //Sort each half, use parallel execution when input size is big to help improve performance.
+
+            if (left.Count > 10000)
+                Parallel.Invoke(() => SortParallel(left, sortDescending), () => SortParallel(right, sortDescending));
+            else
+            {
+                SortParallel(left, sortDescending);
+                SortParallel(right, sortDescending);
+            }
+               
+
+            //Merge the results
+            Merge(left, right, list, sortDescending);
+
+            return list;
+        }
+
+
         /// <summary>
         /// Merging two arrays in correct order according to the boolean value of sortDescending
         /// </summary>