Open In App

# Python Program for Counting Sort

Counting sort is a sorting technique based on keys between a specific range. It works by counting the number of objects having distinct key values (kind of hashing). Then do some arithmetic to calculate the position of each object in the output sequence.

## Python Program for Counting Sort

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.

## Python3

 `# Python program for counting sort` `# The main function that sort the given string arr[] in``# alphabetical order``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)))` `# This code is contributed by Nikhil Kumar Singh`

Output:

`Sorted character array is eeeefggkkorss`

Time Complexity: O(n)

Space Complexity: O(n)

Please refer complete article on Counting Sort for more details!

## Python Program for Counting Sort 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:

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

## Python3

 `from` `collections ``import` `Counter` `def` `counting_sort(arr):``    ``count ``=` `Counter(arr)``    ``output ``=` `[]``    ``for` `c ``in` `sorted``(count.keys()):``        ``output ``+``=` `*` `count``    ``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.

## Python Program for Counting Sort Using sorted() and reduce():

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

## Python3

 `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)`  `#This code is contributed by VinayPinjala.`

Output

```Sorted string: eeeefggkkorss

```

Time Complexity:

The sorted() function has a time complexity of O(n log n) where n is the length of the input string.
The 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:

The input string is stored in memory, which requires O(n) space.
The 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).