# What Is Count Sort in Data Structure?

//

Angela Bailey

Count Sort is a sorting algorithm that operates on a set of integers. It is an efficient sorting technique that works well when the range of input values is small compared to the number of elements to be sorted. Count Sort is a non-comparison based sorting algorithm, which means it does not rely on comparing elements to determine their order.

## How Does Count Sort Work?

The main idea behind Count Sort is to determine, for each input element, the number of elements that are smaller than it. This information can then be used to place the element directly into its correct position in the output array.

To do this, Count Sort first creates a count array to store the count of each unique element in the input array. The count array is initialized with all zeros.

Next, Count Sort iterates through the input array and incrementally updates the count array based on the frequency of each element. The count array now contains cumulative counts for each element.

Then, Count Sort uses the count array to determine the correct position of each element in the output array. It scans through the input array again and places each element in its appropriate position by decrementing its corresponding count value in the count array.

The time complexity of Count Sort is O(n+k), where n is the number of elements and k is the range of input values. It performs well when k is relatively small compared to n.

## Example:

Let’s consider an example to understand how Count Sort works:

• Input Array: [4, 2, 5, 1, 3]

Step 1: Create a count array and initialize it with all zeros.

```Count Array: [0, 0, 0, 0, 0]
```

Step 2: Iterate through the input array and update the count array.

```Count Array: [1, 1, 1, 1, 1]
```

Step 3: Modify the count array to store cumulative counts.

```Count Array: [1, 2, 3, 4, 5]
```

Step 4: Determine the correct position of each element in the output array using the count array.

```Output Array: [ , , , , ]
Count Array: [0, 1, 2, 3, 4]
```

Place each element in its appropriate position:

```Output Array: [ , , , , ]
Count Array: [0, 0, 0, 0, 0] (Decrement count values after placing elements)
Output Array: [ , , , , ]
Count Array: [-1, -1, -1, -1, -1] (The count array is now updated to reflect placed elements.)
Output Array: [1, 2, 3, 4, 5] (The elements are placed according to their correct positions.)
Final Output Array: [1,[,2,[,3,4,[5]```

The final output array is sorted in ascending order using Count Sort.

• Count Sort is efficient for sorting arrays with a small range of input values.
• It has a time complexity of O(n+k), making it faster than comparison-based sorting algorithms like Bubble Sort or Insertion Sort.
• Count Sort is stable, meaning it preserves the relative order of elements with equal keys.