Counting Sort – Python

Last Updated : 24 Feb, 2025

Counting Sort is a non-comparison-based sorting algorithm. It is particularly efficient when the range of input values is small compared to the number of elements to be sorted. The basic idea behind Counting Sort is to count the frequency of each distinct element in the input array and use that information to place the elements in their correct sorted positions. For example, for input [1, 4, 3, 2, 2, 1], the output should be [1, 1, 2, 2, 3, 4]. The important thing to notice is that the range of input elements is small and comparable to the size of the array.

Working of Counting Sort

Step 1: Find out the maximum element from the given array.
Step 2: Initialize a countArray[] of length max+1 with all elements as 0. This array will be used for storing the occurrences of the elements of the input array.
Step 3: In the countArray[], store the count of each unique element of the input array at their respective indices. For Example: The count of element 2 in the input array is 2. So, store 2 at index 2 in the countArray[]. Similarly, the count of element 5 in the input array is 1, hence store 1 at index 5 in the countArray[].
Step 4: Store the cumulative sum or prefix sum of the elements of the countArray[] by doing countArray[i] = countArray[i – 1] + countArray[i]. This will help in placing the elements of the input array at the correct index in the output array.
Step 5: Iterate from end of the input array and because traversing input array from end preserves the order of equal elements, which eventually makes this sorting algorithm stable.
Step 6: Update outputArray[ countArray[ inputArray[6] ] – 1] = inputArray[6]. Also, update countArray[ inputArray[6] ] = countArray[ inputArray[6] ]- –
Step 7: For i = 5, Update outputArray[ countArray[ inputArray[5] ] – 1] = inputArray[5]. Also, update countArray[ inputArray[5] ] = countArray[ inputArray[5] ]- –
Step 8: For i = 4, Update outputArray[ countArray[ inputArray[4] ] – 1] = inputArray[4]. Also, update countArray[ inputArray[4] ] = countArray[ inputArray[4] ]- –
Step 9: For i = 3, Update outputArray[ countArray[ inputArray[3] ] – 1] = inputArray[3]. Also, update countArray[ inputArray[3] ] = countArray[ inputArray[3] ]- –
Step 10: For i = 2, Update outputArray[ countArray[ inputArray[2] ] – 1] = inputArray[2]. Also, update countArray[ inputArray[2] ] = countArray[ inputArray[2] ]- –
Step 11: For i = 1, Update outputArray[ countArray[ inputArray[1] ] – 1] = inputArray[1]. Also, update countArray[ inputArray[1] ] = countArray[ inputArray[1] ]- –
Step 12: For i = 0, Update outputArray[ countArray[ inputArray[0] ] – 1] = inputArray[0]. Also, update countArray[ inputArray[0] ] = countArray[ inputArray[0] ]- –Counting Sort Algorithm

Declare an auxiliary array countArray[] of size max(inputArray[])+1 and initialize it with 0.
Traverse array inputArray[] and map each element of inputArray[] as an index of countArray[] array, i.e., execute countArray[inputArray[i]]++ for 0 <= i < N.
Calculate the prefix sum at every index of array inputArray[].
Create an array outputArray[] of size N.
Traverse array inputArray[] from end and update outputArray[ countArray[ inputArray[i] ] – 1] = inputArray[i]. Also, update countArray[inputArray[i] ] = countArray[ inputArray[i] ]- – .

Code Implementation

The provided Python code demonstrates Counting Sort, a non-comparison-based sorting algorithm. Counting Sort works by determining each element’s count in the input sequence, then reconstructing the sorted array. The code comprises a single function countSort that sorts a given string arr in alphabetical order. It uses auxiliary arrays count and output to keep track of character frequencies and sorted positions. The algorithm counts characters’ occurrences, modifies the count array to hold their positions, and constructs the sorted output array. The driver code initializes a string, applies the countSort function, and prints the sorted character array. This algorithm’s efficiency relies on its linear time complexity, making it ideal for a range of values with a limited span.

def countSort(arr):

    # The output character array that will have sorted arr
    output = [0 for i in range(256)]

    # Create a count array to store count of individual
    # characters and initialize count array as 0
    count = [0 for i in range(256)]

    # For storing the resulting answer since the 
    # string is immutable
    ans = ["" for _ in arr]

    # Store count of each character
    for i in arr:
        count[ord(i)] += 1

    # Change count[i] so that count[i] now contains actual
    # position of this character in output array
    for i in range(256):
        count[i] += count[i-1]

    # Build the output character array
    for i in range(len(arr)):
        output[count[ord(arr[i])]-1] = arr[i]
        count[ord(arr[i])] -= 1

    # Copy the output array to arr, so that arr now
    # contains sorted characters
    for i in range(len(arr)):
        ans[i] = output[i]
    return ans 

# Driver program to test above function
arr = "geeksforgeeks"
ans = countSort(arr)
print ("Sorted character array is %s"  %("".join(ans)))

Output

Sorted character array is eeeefggkkorss

Time Complexity: O(n)

Space Complexity: O(n)

Using counter method

This program implements the Counting Sort algorithm using the collections.Counter() method in Python. Counting Sort is a sorting algorithm that works by counting the occurrence of each distinct element in the input list and using that information to determine the position of each element in the output list. The algorithm has a time complexity of O(n+k), where n is the number of elements in the input list and k is the range of the input data, and a space complexity of O(k).

Algorithm:

Convert the input string into a list of characters.
Count the occurrence of each character in the list using the collections. Counter() method.
Sort the keys of the resulting Counter object to get the unique characters in the list in sorted order.
For each character in the sorted list of keys, create a list of repeated characters using the corresponding count from the Counter object.
Concatenate the lists of repeated characters to form the sorted output list.

from collections import Counter

def counting_sort(arr):
    count = Counter(arr)
    output = []
    for c in sorted(count.keys()):
        output += [c] * count[c]
    return output

arr = "geeksforgeeks"
arr = list(arr)
arr = counting_sort(arr)
output = ''.join(arr)
print("Sorted character array is", output)

Output

Sorted character array is eeeefggkkorss

Time Complexity: O(nlogn) due to the use of the sorted() method, but O(n+k) in the best case when k is small.
Space Complexity: O(k) for the count array and output list.

Using sorted() and reduce()

Import the functools module.
Define the input string string.
Use the reduce() function from functools to sort the string.
The lambda function passed to reduce() concatenates the characters in ascending order.
Assign the sorted string to sorted_str.
Print the sorted string.

from functools import reduce

# Input string
string = "geeksforgeeks"

# Sort the characters using reduce and lambda function
sorted_str = reduce(lambda x, y: x+y, sorted(string))

# Print the sorted string
print("Sorted string:", sorted_str)

Output

Sorted string: eeeefggkkorss

Time Complexity:

sorted() function has a time complexity of O(n log n) where n is the length of the input string.
reduce() function has a time complexity of O(n) where n is the length of the input string.
Therefore, the overall time complexity of the code is O(n log n).

Space Complexity:

input string is stored in memory, which requires O(n) space.
sorted() function and reduce() function create new lists, so they require additional O(n) space.
Therefore, the overall space complexity of the code is O(n).