Counting sort in Java

Counting sort is one of the most used sorting techniques in Java that is based on the keys b/w specific range. Counting sort doesn't perform sorting by comparing elements. It performs sorting by counting objects having distinct key values like hashing. After that, it performs some arithmetic operations for calculating the index position of each object in the output sequence. The counting sort algorithm is not used as a general-purpose sorting algorithm.

Suppose, we have an input array a{4, 3, 2, 5, 4, 3, 5, 1, 0, 2, 5} which have values in the range[0, 5].

We count the occurrence of each element in the array and represent the countings as an array countArray. The countArray[i] represents the occurrence of the number i in the array a.

So, number 0 and 1 appear one time, 2, 3, and 4 appears two times and 5 appear three times.

Now, with the help of the countArray, we determine how many elements are less than or equal to each element of the countArray in array a. We sum all the elements which are less than or equal to countArray[i].

In array a,

There is only one element, i.e., 0, which is less than or equal to zero and that is equal to countArray[0].
There are two elements which are less than or equal to 1, i.e., 0 and 1 which is equal to countArray[0] + countArray[1].
There are 4 values which are less than or equal to 2, i.e., 0, 1, 2, and 2 which is equal to countArray[0]+ countArray[1]+ countArray[2].
There are 6 values which are less than or equal to 3, i.e., 0, 1, 2, 2, 3, 3 which is equal to countArray[0]+ countArray[1]+ countArray[2] ]+ countArray[3].
There are 6 values which are less than or equal to 3, i.e., 0, 1, 2, 2, 3, 3 which is equal to countArray[0]+ countArray[1]+ countArray[2] ]+ countArray[3].
There are 6 values which are less than or equal to 4, i.e., 0, 1, 2, 2, 3, 3, 4, 4 which is equal to countArray[0]+ countArray[1]+ countArray[2] ]+ countArray[3] + countArray[4].
There are 6 values which are less than or equal to 5, i.e., 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 5 which is equal to countArray[0]+ countArray[1]+ countArray[2] ]+ countArray[3] + countArray[4] + countArray[5].

Algorithm

After getting the auxiliary array, i.e., countArray, we perform sorting to sort the array a. These are the following steps to sort the elements of the array a.

Iterate the input array 'a' in the reverse form.
For each element 'i' in the input array, C[i] defines the location of the number i in the sorted array because there are countArray[i] elements less than or equal to i.
At the end of each round, we decrement the countArray[i].

So, in order to sort the input array a, we iterate it in reverse order and start with the number 5. At index 5 in the countArray, we have value 11, which means array 'a' contains 11 elements that are less or equal to the number 5. It means 5 will be our last element in the sorted array.

After moving number 5 in the sorted array, we decrement the value of countArray[5]. Now, the next number in the reverse order is 2, and at index 2, we have value 4, which means array 'a' contains four elements that are less than or equal to 2. So, the number will be at position 4 in the sorted array.

The next number is 0 in the input array 'a' and the value in the countArray at index 0 is 1 which means there is only one element in the input array 'a', which is equal to 0. So, 0 will be the first element in the sorted array.

We perform the same operation for the remaining elements of the input array 'a'.

For element 1

For element 5

For element 3

For element 4

For element 5

For element 2

For element 3

For element 4

Sorted Array

Let's implement the logic of the counting sort in Java by using the above-discussed algorithm:

CountingSortExample.java

// import required classes and packages
package javaTpoint.MicrosoftJava;

import java.util.Scanner;

// create class CountingSortExample to sort an array of elements using counting sort
class CountingSortExample {
	
	// create sortArray() method that sort the given array using counting sort mechanism
	public static void sortArray(int inputArr[])
	{
		// calculate size of the array
		int size = inputArr.length;

		// create another array having same length of inputArr that will store elements in sorted way
		int sortedArr[] = new int[size];

		// Create countArr that will store count of occurrence of each number and initialize it with 0
		int countArr[] = new int[256];
		for (int i = 0; i < 256; ++i) {
			countArr[i] = 0;
		}

		// use for loop to store the count of each number in the countArr
		for (int i = 0; i < size; ++i)
			++countArr[inputArr[i]];

		// modify the value of countArr[i] so that countArr[i] now contains actual position of the current number in the sortedArr
		for (int i = 1; i <= 255; ++i)
			countArr[i] += countArr[i - 1];

		// iterate the inputArr in reverse order to perform counting sort.
		for (int i = size - 1; i >= 0; i--) {
			sortedArr[countArr[inputArr[i]] - 1] = inputArr[i];
			--countArr[inputArr[i]];
		}
		// Copy the sortedArr to inputArr, so that inputArr now contains sorted elements
		for (int i = 0; i < size; ++i)
			inputArr[i] = sortedArr[i];
		
		// print sorted array elements
		System.out.print("Sorted numbers in the array is:");
		for (int i = 0; i < inputArr.length; ++i)
			System.out.print(inputArr[i]);
	}
	// main() method start
	public static void main(String args[])
	{
		
		int size;  
		
		Scanner sc = new Scanner(System.in);  
		System.out.print("Enter the number of elements you want to store in the array: ");  
		
		//reading the number of elements from the that we want to enter  
		size = sc.nextInt();  
		
		//creates an array of the user input size  
		int[] inputArr = new int[size];  
		System.out.println("Enter the elements in the array: ");  
		for(int i=0; i<size; i++)  
		{  
			//reading array elements from the user   
			inputArr[i] = sc.nextInt();  
		}  
		// close scanner class object
		sc.close();
		sortArray(inputArr);
		
	}
}

Output: