added countingSort algorithm

Author: skillmaker-dev

Algorithms.NET.Debug/Program.cs

@@ -1,16 +1,17 @@
 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 };
+List<int> unsortedRand = new() { 8, 9, 3, 3, 10, 1 };
 
 //var sortedDesc = Algorithms.NET.Sorting.MergeSort.MergeSortAlgorithm.SortDescending(unsortedAsc);
-var sortedAsc = Algorithms.NET.Sorting.QuickSort.QuickSortAlgorithm.SortDescending(unsortedRand);
+var sortedAsc = Algorithms.NET.Sorting.CountingSort.CountingSortAlgorithm.SortAscending(unsortedRand.ToArray());
+var sortedDesc = Algorithms.NET.Sorting.CountingSort.CountingSortAlgorithm.SortDescending(unsortedRand.ToArray());
 
 
-//foreach (var item in sortedDesc)
-//{
-//    Console.WriteLine(item);
-//}
-//Console.WriteLine();
+foreach (var item in sortedDesc)
+{
+    Console.WriteLine(item);
+}
+Console.WriteLine();
 foreach (var item in sortedAsc)
 {
     Console.WriteLine(item);

Algorithms.NET/Sorting/CountingSort/CountingSortAlgorithm.cs

@@ -0,0 +1,72 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Algorithms.NET.Sorting.CountingSort
+{
+    public class CountingSortAlgorithm
+    {
+        /// <summary>
+        /// Sorting an array of positive integers in ascending order using CountingSort algorithm, Time complexity of O(n).
+        /// </summary>
+        /// <param name="list">Array of numbers to sort</param>
+        /// <returns>Sorted Array in ascending order.</returns>
+        public static int[] SortAscending(int[] list)
+        {
+            return Sort(list, false);
+        }
+
+        /// <summary>
+        /// Sorting an array of positive integers in Descending order using CountingSort algorithm, Time complexity of O(n).
+        /// </summary>
+        /// <param name="list">Array of numbers to sort</param>
+        /// <returns>Sorted Array in Descending order.</returns>
+        public static int[] SortDescending(int[] list)
+        {
+            return Sort(list, true);
+        }
+
+        /// <summary>
+        /// Sorting an array of positive integers using CountingSort algorithm, Time complexity of O(n).
+        /// </summary>
+        /// <param name="list">Array of numbers to sort</param>
+        /// <param name="sortDescending">Boolean value specifying whether sorting should be done in descending order</param>
+        /// <returns>A sorted Array</returns>
+        private static int[] Sort(int[] list, bool sortDescending)
+        {
+            int[] sortedList = new int[list.Length];
+            list.CopyTo(sortedList, 0);
+
+            int max = sortedList[0];
+            for (int i = 1; i < sortedList.Length; i++)
+                if (sortedList[i] > max)
+                    max = sortedList[i];
+
+            int[] countingArray = new int[max + 1];
+
+            for (int i = 0; i < sortedList.Length; i++)
+            {
+                countingArray[sortedList[i]]++;
+            }
+
+            if (!sortDescending)
+            {
+                int k = 0;
+                for (int i = 0; i < countingArray.Length; i++)
+                    for (int j = 0; j < countingArray[i]; j++)
+                        sortedList[k++] = i;
+            }
+            else
+            {
+                int k = 0;
+                for (int i = countingArray.Length - 1; i >= 0; i--)
+                    for (int j = 0; j < countingArray[i]; j++)
+                        sortedList[k++] = i;
+            }
+
+
+            return sortedList;
+        }
+    }
+}