Counting Sort Algorithm in DSA Go - Execution Trace

Concept Flow - Counting Sort Algorithm

Find max value in input array

↓

Create count array of size max+1

↓

Count frequency of each element

↓

Modify count array to store cumulative counts

↓

Place elements into output array using count array

↓

Copy output array back to input array

↓

Done

Counting Sort counts how many times each number appears, then uses that to place numbers in order.

Execution Sample

DSA Go

input := []int{4, 2, 2, 8, 3, 3, 1}
max := 8
count := make([]int, max+1)
for _, num := range input {
	count[num]++
}
for i := 1; i <= max; i++ {
	count[i] += count[i-1]
}
output := make([]int, len(input))
for i := len(input)-1; i >= 0; i-- {
	val := input[i]
	output[count[val]-1] = val
	count[val]--
}
copy(input, output)

This code sorts the input array by counting occurrences and placing elements in order.

Execution Table

Step	Operation	Input Array	Count Array	Output Array	Notes
1	Initial input	[4, 2, 2, 8, 3, 3, 1]	[0,0,0,0,0,0,0,0,0]	[_,_,_,_,_,_,_]	Start with empty count and output arrays
2	Count 4	[4, 2, 2, 8, 3, 3, 1]	[0,0,0,0,1,0,0,0,0]	[_,_,_,_,_,_,_]	Increment count[4]
3	Count 2	[4, 2, 2, 8, 3, 3, 1]	[0,0,2,0,1,0,0,0,0]	[_,_,_,_,_,_,_]	Increment count[2] twice
4	Count 8	[4, 2, 2, 8, 3, 3, 1]	[0,0,2,0,1,0,0,0,1]	[_,_,_,_,_,_,_]	Increment count[8]
5	Count 3	[4, 2, 2, 8, 3, 3, 1]	[0,0,2,2,1,0,0,0,1]	[_,_,_,_,_,_,_]	Increment count[3] twice
6	Count 1	[4, 2, 2, 8, 3, 3, 1]	[0,1,2,2,1,0,0,0,1]	[_,_,_,_,_,_,_]	Increment count[1]
7	Cumulative count step 1	[4, 2, 2, 8, 3, 3, 1]	[0,1,3,5,6,6,6,6,7]	[_,_,_,_,_,_,_]	Each count[i] += count[i-1]
8	Place 1	[4, 2, 2, 8, 3, 3, 1]	[0,0,3,5,6,6,6,6,7]	[1,_,_,_,_,_,_]	Place 1 at output[count[1]-1=0], decrement count[1]
9	Place 3	[4, 2, 2, 8, 3, 3, 1]	[0,0,3,4,6,6,6,6,7]	[1,_,_,_,3,_,_]	Place 3 at output[count[3]-1=4], decrement count[3]
10	Place 3	[4, 2, 2, 8, 3, 3, 1]	[0,0,3,3,6,6,6,6,7]	[1,_,_,3,3,_,_]	Place second 3 at output[count[3]-1=3], decrement count[3]
11	Place 8	[4, 2, 2, 8, 3, 3, 1]	[0,0,3,3,6,6,6,6,6]	[1,_,_,3,3,_,8]	Place 8 at output[count[8]-1=6], decrement count[8]
12	Place 2	[4, 2, 2, 8, 3, 3, 1]	[0,0,2,3,6,6,6,6,6]	[1,_,2,3,3,_,8]	Place 2 at output[count[2]-1=2], decrement count[2]
13	Place 2	[4, 2, 2, 8, 3, 3, 1]	[0,0,1,3,6,6,6,6,6]	[1,2,2,3,3,_,8]	Place second 2 at output[count[2]-1=1], decrement count[2]
14	Place 4	[4, 2, 2, 8, 3, 3, 1]	[0,0,1,3,5,6,6,6,6]	[1,2,2,3,3,4,8]	Place 4 at output[count[4]-1=5], decrement count[4]
15	Copy output to input	[1,2,2,3,3,4,8]	[0,0,1,3,5,6,6,6,6]	[1,2,2,3,3,4,8]	Sorted array copied back
16	End	[1,2,2,3,3,4,8]	[0,0,1,3,5,6,6,6,6]	[1,2,2,3,3,4,8]	Sorting complete

💡 All elements placed in output and copied back; input array is sorted.

Variable Tracker

Variable	Start	After Step 6	After Step 7	After Step 15	Final
input	[4,2,2,8,3,3,1]	[4,2,2,8,3,3,1]	[4,2,2,8,3,3,1]	[1,2,2,3,3,4,8]	[1,2,2,3,3,4,8]
count	[0,0,0,0,0,0,0,0,0]	[0,1,2,2,1,0,0,0,1]	[0,1,3,5,6,6,6,6,7]	[0,0,1,3,5,6,6,6,6]	[0,0,1,3,5,6,6,6,6]
output	[_,_,_,_,_,_,_]	[_,_,_,_,_,_,_]	[_,_,_,_,_,_,_]	[1,2,2,3,3,4,8]	[1,2,2,3,3,4,8]

Key Moments - 3 Insights

Why do we create a count array of size max+1?

Because we need to count frequencies for every number from 0 up to the maximum value, so the array must have max+1 slots (see execution_table step 1).

Why do we modify the count array to cumulative counts?

Cumulative counts tell us the exact position where each element should go in the output array (see execution_table step 7).

Why do we place elements in output array from right to left?

Placing from right to left keeps the sort stable, preserving the order of equal elements (see execution_table steps 8-14).

Visual Quiz - 3 Questions

Look at the execution_table at step 7, what is the value of count[3]?

A 5

B 2

C 4

D 6

💡 Hint

Check the 'Count Array' column at step 7 in execution_table.

At which step does the output array first get the element '8' placed?

A Step 10

B Step 11

C Step 12

D Step 14

💡 Hint

Look at the 'Operation' and 'Output Array' columns in execution_table for when '8' appears.

If the input array had a maximum value of 10 instead of 8, how would the count array size change?

A It would stay the same size

B It would be size 8

C It would be size 11

D It would be size 10

💡 Hint

Recall count array size is max+1, see concept_flow first step.

Concept Snapshot

Counting Sort Algorithm:
- Find max value in input
- Create count array size max+1
- Count frequencies of each element
- Convert count to cumulative counts
- Place elements in output using count
- Copy output back to input
- Stable and efficient for small range integers

Full Transcript

Counting Sort works by first finding the maximum value in the input array. Then it creates a count array with size max+1 to hold frequencies of each number. Next, it counts how many times each number appears. After that, it changes the count array to cumulative counts, which tell where each number should be placed in the output array. Then it places each element from the input into the output array in order, using the count array to find the correct position. Finally, it copies the sorted output back to the input array. This method is stable and fast when the range of numbers is not too large.