Our FREE site is mostly funded by the Amazon ads ⇓below⇓.

Support us by clicking ⇑above⇑ next time you plan to buy a product on Amazon.

using System;
using System.Linq;
namespace Algorithms.Sorters.Integer
{
/// <summary>
/// Counting sort is an algorithm for sorting a collection of objects according to keys that are small integers; that
/// is, it is an integer sorting algorithm. It operates by counting the number of objects that have each distinct key
/// value, and using arithmetic on those counts to determine the positions of each key value in the output sequence.
/// Its running time is linear in the number of items and the difference between the maximum and minimum key values, so
/// it is only suitable for direct use in situations where the variation in keys is not significantly greater than the
/// number of items. However, it is often used as a subroutine in another sorting algorithm, radix sort, that can
/// handle larger keys more efficiently.
/// </summary>
public class CountingSorter : IIntegerSorter
{
/// <summary>
/// <para>
/// Sorts input array using counting sort algorithm.
/// </para>
/// <para>
/// Time complexity: O(n+k), where k is the range of the non-negative key values.
/// </para>
/// <para>
/// Space complexity: O(n+k), where k is the range of the non-negative key values.
/// </para>
/// </summary>
/// <param name="array">input array.</param>
public void Sort(int[] array)
{
var max = array.Max();
var min = array.Min();
var count = new int[max - min + 1];
var output = new int[array.Length];
for (var i = 0; i < array.Length; i++)
{
count[array[i] - min]++;
}
for (var i = 1; i < count.Length; i++)
{
count[i] += count[i - 1];
}
for (var i = array.Length - 1; i >= 0; i--)
{
output[count[array[i] - min] - 1] = array[i];
count[array[i] - min]--;
}
Array.Copy(output, array, array.Length);
}
}
}