Counting Sort is a non-comparison-based sorting algorithm. It is highly efficient when the range of input values is small compared to the number of elements. The main idea is to count the occurrences of each element and then use these counts to determine the correct position of each element in the sorted output.
Working of Counting Sort
- Find the maximum element in the input array.
- Initialize a countArray of size max + 1 with all zeros.
- Store the frequency of each element from the input array at its corresponding index in countArray.
- Example: if 2 appears twice, countArray[2] = 2.
- Convert countArray into prefix sum each index now shows the final position of that element in the sorted order.
- Build the output array by iterating the input array from the end (to maintain stability).
- Copy output back to the input array.
Algorithm
- Create a count array "countArray[max(input)+1]" initialized to 0.
- For each element in inputArray, increment countArray[element].
- Compute prefix sums in countArray.
- Create an empty outputArray of size N.
- Traverse input from the end and place each element at countArray[element] -1.
- Decrement countArray[element] after each placement.
Python Implementation
Python
def countSort(arr):
max_val = max(arr)
count = [0] * (max_val + 1)
output = [0] * len(arr)
for num in arr:
count[num] += 1
for i in range(1, len(count)):
count[i] += count[i - 1]
for num in reversed(arr):
output[count[num] - 1] = num
count[num] -= 1
for i in range(len(arr)):
arr[i] = output[i]
return arr
arr = [4, 2, 2, 8, 3, 3, 1]
sorted_arr = countSort(arr)
print("Sorted array is:", sorted_arr)
OutputSorted array is: [1, 2, 2, 3, 3, 4, 8]
Explanation:
- count[num] += 1: Increments the count for each number to record how many times it appears in the list.
- count[i] += count[i - 1]: Updates the count array so each position stores the total number of elements ≤ that index (prefix sum).
- output[count[num] - 1] = num: Places each number in its correct sorted position using the cumulative count.
- count[num] -= 1: Decreases the count so the next occurrence of the same number is placed correctly.
- arr[i] = output[i]: Copies the sorted output back into the original array.
Counting Sort Using collections.Counter
The traditional Counting Sort manually counts occurrences and builds prefix sums using arrays. Python's collections.Counter offers a simpler way to achieve the same result, it automatically counts element frequencies.
The logic remains the same:
- Count how often each element appears.
- Arrange elements in sorted order based on their counts.
Using Counter, we skip manual array handling and directly rebuild the sorted output by iterating over sorted keys.
Python Implementation
Python
from collections import Counter
def count_sort(arr):
count = Counter(arr)
res = []
for num in sorted(count.keys()):
res += [num] * count[num]
return res
arr = [4, 2, 2, 8, 3, 3, 1]
sort_arr = count_sort(arr)
print( sort_arr)
Output[1, 2, 2, 3, 3, 4, 8]
Explanation:
- Counter(arr): counts occurrences of each number.
- sorted(count.keys()): gives sorted unique values.
- [num] * count[num]: repeats each number by its count.
Related Articles:
Explore
Python Fundamentals
Python Data Structures
Advanced Python
Data Science with Python
Web Development with Python
Python Practice