added MergeSort algorithm

Author: skillmaker-dev

Algorithms.NET.Debug/BenchmarkDemo.cs

@@ -7,13 +7,22 @@
 using Algorithms.NET.Sorting.BubbleSort;
 using Algorithms.NET.Sorting.SelectionSort;
 using Algorithms.NET.Sorting.InsertionSort;
+using Algorithms.NET.Sorting.MergeSort;
 
 namespace Algorithms.NET.Debug
 {
     [MemoryDiagnoser]
     public class BenchmarkDemo
     {
-        private readonly List<double> _unsortedAsc = new() { 0D, 1D, 2D, 3D, 4D, 5D,6D,7D,8D,9D,10D,11D,12D,13D,14D,15D,16D,17D,18D,19D,20D };
+        private readonly List<double> _unsortedAsc = new();
+
+        public BenchmarkDemo()
+        {
+             for(int i = 0; i < 1000;i++)
+            {
+                _unsortedAsc.Add((double)i);
+            }
+        }
 
         [Benchmark]
         public void BubbleSort() => 
@@ -27,5 +36,9 @@ public void SelectionSort() =>
         public void InsertionSort() =>
         InsertionSortAlgorithm.SortDescending(_unsortedAsc);
 
+        [Benchmark]
+        public void MergeSort() =>
+        MergeSortAlgorithm.SortDescending(_unsortedAsc);
+
     }
 }

Algorithms.NET.Debug/Program.cs

@@ -1,22 +1,22 @@
 using Algorithms.NET.Debug;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Running;
-List<double> unsortedAsc = new() { 0,1,2,3,4,5 };
-List<double> unsortedDesc = new() { 5,4,3,2,1,0 };
-
-var sortedDesc = Algorithms.NET.Sorting.InsertionSort.InsertionSortAlgorithm.SortDescending(unsortedAsc);
-var sortedAsc = Algorithms.NET.Sorting.InsertionSort.InsertionSortAlgorithm.SortAscending(unsortedDesc);
-
-
-foreach (var item in sortedDesc)
-{
-    Console.WriteLine(item);
-}
-Console.WriteLine();
-foreach (var item in sortedAsc)
-{
-    Console.WriteLine(item);
-}
+//List<double> unsortedAsc = new() { 0, 1, 2, 3, 4, 5 };
+//List<double> unsortedDesc = new() { 5, 4, 3, 2, 1, 0 };
+
+//var sortedDesc = Algorithms.NET.Sorting.MergeSort.MergeSortAlgorithm.SortDescending(unsortedAsc);
+//var sortedAsc = Algorithms.NET.Sorting.MergeSort.MergeSortAlgorithm.SortAscending(unsortedDesc);
+
+
+//foreach (var item in sortedDesc)
+//{
+//    Console.WriteLine(item);
+//}
+//Console.WriteLine();
+//foreach (var item in sortedAsc)
+//{
+//    Console.WriteLine(item);
+//}
 
 
 

Algorithms.NET/Sorting/BubbleSort/BubbleSortAlgorithm.cs

@@ -34,8 +34,7 @@ public static IEnumerable<double> SortAscending(List<double> list)
         /// <returns>A sorted list</returns>
         private static IEnumerable<double> Sort(List<double> list, bool sortDescending)
         {
-            var sortedList = new List<double>();
-            sortedList.AddRange(list);
+            var sortedList = new List<double>(list);
             bool isSorted;
 
             for (int i = 0; i < sortedList.Count; i++)

Algorithms.NET/Sorting/InsertionSort/InsertionSortAlgorithm.cs

@@ -34,8 +34,7 @@ public static List<double> SortDescending(List<double> list)
         /// <returns>A sorted list</returns>
         private static List<double> Sort(List<double> list,bool sortDescending)
         {
-            List<double> sortedList = new List<double>();
-            sortedList.AddRange(list);
+            List<double> sortedList = new List<double>(list);
 
             for(int i = 1;i < list.Count;i++)
             {

Algorithms.NET/Sorting/MergeSort/MergeSortAlgorithm.cs

@@ -0,0 +1,94 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Algorithms.NET.Sorting.MergeSort
+{
+    public class MergeSortAlgorithm
+    {
+        /// <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> SortAscending(List<double> list)
+        {
+            List<double> sortedList = new List<double>(list);
+            return Sort(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> SortDescending(List<double> list)
+        {
+            List<double> sortedList = new List<double>(list);
+            return Sort(sortedList, true);
+        }
+
+        /// <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>
+        private static List<double> Sort(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.
+            Sort(left,sortDescending);
+            Sort(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>
+        /// <param name="leftHalf">A list of the left half</param>
+        /// <param name="rightHalf">A list of the right half</param>
+        /// <param name="list">Original list in which we want to insert items correctly</param>
+        /// <param name="sortDescending">Boolean value of whether sorting should be done in descending order or not</param>
+        private static void Merge(List<double> leftHalf, List<double> rightHalf, List<double> list,bool sortDescending)
+        {
+            int i = 0, j = 0, k = 0;
+            
+            //We insert the first items in the correct order by comparing them to each others
+            while(i < leftHalf.Count && j < rightHalf.Count)
+            {
+                if(!sortDescending && leftHalf[i] < rightHalf[j])
+                    list[k++] = leftHalf[i++];
+                else 
+                    list[k++] = rightHalf[j++];
+            }
+
+            //We insert the remaining items 
+            while(j < rightHalf.Count)
+                list[k++] = rightHalf[j++];
+
+            while(i < leftHalf.Count)
+                list[k++] = leftHalf[i++];
+        }
+    }
+}

Algorithms.NET/Sorting/SelectionSort/SelectionSortAlgorithm.cs

@@ -34,8 +34,7 @@ public static IEnumerable<double> SortAscending(List<double> list)
         /// <returns>A sorted list</returns>
         private static IEnumerable<double> Sort(List<double> list,bool sortDescending)
         {
-            var sortedList = new List<double>();
-            sortedList.AddRange(list); 
+            var sortedList = new List<double>(list);
             for(int i = 0; i < sortedList.Count; i++)
             {
                 double min = sortedList[i];