Added quickSort algorithm

Author: skillmaker-dev

Algorithms.NET.Debug/BenchmarkDemo.cs

@@ -8,45 +8,50 @@
 using Algorithms.NET.Sorting.SelectionSort;
 using Algorithms.NET.Sorting.InsertionSort;
 using Algorithms.NET.Sorting.MergeSort;
+using Algorithms.NET.Sorting.QuickSort;
 
 namespace Algorithms.NET.Debug
 {
     [MemoryDiagnoser]
     public class BenchmarkDemo
     {
-        private List<double> _unsortedDesc = new();
-        private List<double> _unsortedDesc2 = new();
+        private List<double> _unsorted = new();
+        private List<double> _unsorted2 = new();
 
         public BenchmarkDemo()
         {
             var rand = new Random();
              for(int i = 0; i < 10000;i++)
             {
-                _unsortedDesc.Add(rand.Next(1000000));
-                _unsortedDesc2.Add(rand.Next(1000000));
+                _unsorted.Add(rand.Next(1000000));
+                _unsorted2.Add(rand.Next(1000000));
             }
         }
 
         [Benchmark]
         public void BuiltInSort() =>
-        _unsortedDesc.Sort();
+        _unsorted2.Sort();
 
 
-        [Benchmark]
+        //[Benchmark]
         public void BubbleSort() => 
-        BubbleSortAlgorithm.SortAscending(_unsortedDesc);
+        BubbleSortAlgorithm.SortAscending(_unsorted);
 
-        [Benchmark]
+        //[Benchmark]
         public void SelectionSort() =>
-        SelectionSortAlgorithm.SortAscending(_unsortedDesc);
+        SelectionSortAlgorithm.SortAscending(_unsorted);
 
-        [Benchmark]
+        //[Benchmark]
         public void InsertionSort() =>
-        InsertionSortAlgorithm.SortAscending(_unsortedDesc);
+        InsertionSortAlgorithm.SortAscending(_unsorted);
 
         [Benchmark]
         public void MergeSort() =>
-        MergeSortAlgorithm.SortAscending(_unsortedDesc2);
+        MergeSortAlgorithm.SortAscending(_unsorted);
+
+        [Benchmark]
+        public void QuickSort() =>
+        QuickSortAlgorithm.SortAscending(_unsorted);
 
     }
 }

Algorithms.NET.Debug/Program.cs

@@ -1,22 +1,23 @@
 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 };
+List<double> unsortedAsc = new() { 0, 1, 2, 3, 4, 5 };
+List<double> unsortedDesc = new() { 5, 4, 3, 2, 1, 0 };
+List<double> unsortedRand = new() { 8, 9, 3, 3, 10, 1 };
 
 //var sortedDesc = Algorithms.NET.Sorting.MergeSort.MergeSortAlgorithm.SortDescending(unsortedAsc);
-//var sortedAsc = Algorithms.NET.Sorting.MergeSort.MergeSortAlgorithm.SortAscending(unsortedDesc);
+var sortedAsc = Algorithms.NET.Sorting.QuickSort.QuickSortAlgorithm.SortDescending(unsortedRand);
 
 
 //foreach (var item in sortedDesc)
 //{
 //    Console.WriteLine(item);
 //}
 //Console.WriteLine();
-//foreach (var item in sortedAsc)
-//{
-//    Console.WriteLine(item);
-//}
+foreach (var item in sortedAsc)
+{
+    Console.WriteLine(item);
+}
 
 //List<double> _unsortedAsc = new();
 //var rand = new Random();
@@ -25,7 +26,7 @@
 //    _unsortedAsc.Add(rand.Next(1000000));
 //}
 
-var summary = BenchmarkRunner.Run<BenchmarkDemo>();
+//var summary = BenchmarkRunner.Run<BenchmarkDemo>();
 
 
 

Algorithms.NET/Sorting/QuickSort/QuickSortAlgorithm.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Algorithms.NET.Sorting.QuickSort
+{
+    public class QuickSortAlgorithm
+    {
+        /// <summary>
+        /// Sorting a list of numbers in ascending order using QuickSort algorithm, Time complexity of mostly O(n Log n) in case of shuffled list and O(n2) in worst case or sorted list.
+        /// </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, 0, sortedList.Count - 1,false);
+        }
+
+        /// <summary>
+        /// Sorting a list of numbers in Descending order using QuickSort algorithm, Time complexity of mostly O(n Log n) in case of shuffled list and O(n2) in worst case or sorted list.
+        /// </summary>
+        /// <param name="list">List of numbers to sort</param>
+        /// <returns>Sorted list in ascending order.</returns>
+        public static List<double> SortDescending(List<double> list)
+        {
+            List<double> sortedList = new List<double>(list);
+
+            return Sort(sortedList, 0, sortedList.Count - 1, true);
+        }
+
+
+        /// <summary>
+        /// Sorting a list of numbers in Descending order using QuickSort algorithm, Time complexity of mostly O(n Log n) in case of shuffled list and O(n2) in worst case or sorted list.
+        /// </summary>
+        /// <param name="list">List of numbers to sort</param>
+        /// <param name="end">Index of last item</param>
+        /// <param name="start">Index of first item</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, int start, int end,bool sortDescending)
+        {
+            var i = start;
+            var j = end;
+
+            //Select middle as the pivot
+            var pivot = list[(start+end)/2];
+            while(i < j)
+            {
+                //Skip elements that are less than pivot
+                while ((!sortDescending && list[i] < pivot) || (sortDescending && list[i] > pivot))
+                    i++;
+
+                //Skip elements that are greater than pivot
+                while ((!sortDescending && list[j] > pivot) || (sortDescending && list[j] < pivot))
+                    j--;
+
+                //Swap elements that are out of order
+                if(i <= j)
+                {
+                    (list[i], list[j]) = (list[j],list[i]);
+                    i++;
+                    j--;
+                }
+            }
+
+            if(start < j)
+                //Sort the right side
+                Sort(list,start,j,sortDescending);
+            if(end > i)
+                //Sort the left side
+                Sort(list,i,end,sortDescending);
+
+            return list;
+        }
+    }
+}