Counting Sort Algorithm in DSA C - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main idea behind the Counting Sort Algorithm?

Counting Sort counts how many times each number appears, then uses these counts to place numbers in the right order without comparing them directly.

beginner

Why is Counting Sort considered a non-comparison sorting algorithm?

Because it sorts by counting occurrences of each value instead of comparing pairs of elements to decide order.

intermediate

What is the time complexity of Counting Sort and when is it efficient?

Counting Sort runs in O(n + k) time, where n is number of elements and k is the range of input values. It is efficient when k is not much larger than n.

beginner

What is the role of the 'count array' in Counting Sort?

The count array stores how many times each value appears. It helps to find the correct position of each element in the sorted output.

intermediate

How does Counting Sort handle stability (keeping order of equal elements)?

By processing elements from right to left when placing them in the output, Counting Sort keeps the original order of equal elements, making it stable.

What does Counting Sort use to determine the position of elements?

A Recursive partitioning

B Pairwise comparisons

C Swapping adjacent elements

D A count array of frequencies

Counting Sort uses a count array to store frequencies of each value to find their positions.

Which condition makes Counting Sort most efficient?

A When input is already sorted

B When input values have a small range

C When input has many duplicates

D When input is very large with random values

Counting Sort is efficient when the range of input values (k) is small compared to the number of elements (n).

What is the space complexity of Counting Sort?

A O(n + k)

B O(k)

C O(n)

D O(1)

Counting Sort uses extra space for the count array and output array, totaling O(n + k).

How does Counting Sort ensure stability?

A By sorting elements from right to left

B It is not stable

C By swapping equal elements

D By sorting elements from left to right

Counting Sort places elements from right to left in the output to maintain the order of equal elements.

Which of these is NOT a step in Counting Sort?

A Counting frequency of each element

B Calculating cumulative counts

C Comparing elements pairwise

D Placing elements in output array

Counting Sort does not compare elements pairwise; it uses counting instead.

Explain how Counting Sort works step-by-step.

Think about how counting helps find positions without comparing.

When should you choose Counting Sort over other sorting algorithms?

Consider input characteristics and algorithm strengths.

Practice

1. What is the main idea behind the Counting Sort algorithm?

easy

A. Counting the number of occurrences of each element to sort

B. Comparing each element with every other element

C. Dividing the array into halves and sorting recursively

D. Swapping adjacent elements repeatedly

Solution

1. Step 1: Understand Counting Sort principle

   Counting Sort counts how many times each value appears in the input.

2. Step 2: Use counts to place elements in order

   Using these counts, it places elements directly into the sorted output.

3. Final Answer:

   Counting the number of occurrences of each element to sort -> Option A

4. Quick Check:

   Counting occurrences = A [OK]

Hint: Counting occurrences helps sort without comparisons [OK]

Common Mistakes:

• Thinking it compares elements like bubble sort
• Confusing with divide and conquer methods
• Assuming it swaps elements repeatedly

2. Which of the following is the correct way to declare the count array in C for counting sort if the maximum value in input is max_val?

easy

A. int count[max_val + 1];

B. int count[max_val];

C. int count[max_val - 1];

D. int count[max_val * 2];

Solution

1. Step 1: Understand array size for counts

   The count array must hold counts for all values from 0 to max_val inclusive, so size is max_val + 1.

2. Step 2: Choose correct declaration

   Declaring int count[max_val + 1]; ensures space for all possible values.

3. Final Answer:

   int count[max_val + 1]; -> Option A

4. Quick Check:

   Count array size = max_val + 1 [OK]

Hint: Count array size must cover all values including max_val [OK]

Common Mistakes:

• Using max_val size misses last element count
• Using max_val - 1 causes out-of-range errors
• Using double size wastes memory unnecessarily

3. What will be the output of the counting sort on the array [4, 2, 2, 8, 3, 3, 1]?

medium

A. [1, 3, 2, 4, 8, 3, 2]

B. [1, 2, 2, 3, 3, 4, 8]

C. [8, 4, 3, 3, 2, 2, 1]

D. [2, 2, 3, 3, 4, 8, 1]

Solution

1. Step 1: Count occurrences of each element

   1 appears once, 2 appears twice, 3 appears twice, 4 once, 8 once.

2. Step 2: Place elements in sorted order using counts

   Sorted array is [1, 2, 2, 3, 3, 4, 8].

3. Final Answer:

   [1, 2, 2, 3, 3, 4, 8] -> Option B

4. Quick Check:

   Sorted array = C [OK]

Hint: Count then output in order for sorted array [OK]

Common Mistakes:

• Confusing input order with output order
• Forgetting to repeat elements by their counts
• Mixing up counts and positions

4. Given the following code snippet for counting sort, what is the error?

int count[5] = {0};
int arr[6] = {1, 3, 4, 2, 3, 0};
for (int i = 0; i < 6; i++) {
    count[arr[i]]++;
}
for (int i = 0; i <= 5; i++) {
    printf("%d ", count[i]);
}

medium

A. Incrementing count[arr[i]] is wrong

B. Count array not initialized to zero

C. Array arr size is incorrect

D. Loop accessing count array goes out of bounds

Solution

1. Step 1: Check count array size and loop range

   Count array size is 5 (indices 0 to 4), but loop runs i from 0 to 5 inclusive, accessing count[5] which is out of bounds.

2. Step 2: Identify out-of-bounds access

   Accessing count[5] causes undefined behavior or error.

3. Final Answer:

   Loop accessing count array goes out of bounds -> Option D

4. Quick Check:

   Loop index > count size = D [OK]

Hint: Check array size vs loop limits carefully [OK]

Common Mistakes:

• Ignoring array size when looping
• Assuming initialization fixes out-of-bounds
• Confusing arr size with count size

5. You want to sort an array containing negative and positive integers using counting sort. Which modification is necessary?

hard

A. Use the array as is because counting sort handles negatives naturally

B. Sort only positive numbers and ignore negatives

C. Shift all numbers by adding the absolute value of the minimum element before sorting

D. Use bubble sort instead

Solution

1. Step 1: Understand counting sort limitation

   Counting sort works only with non-negative integers because it uses array indices as counts.

2. Step 2: Adjust negative values for indexing

   Shift all numbers by adding the absolute value of the minimum element to make all values non-negative before counting.

3. Final Answer:

   Shift all numbers by adding the absolute value of the minimum element before sorting -> Option C

4. Quick Check:

   Shift negatives to non-negative = B [OK]

Hint: Shift negatives to zero or above before counting [OK]

Common Mistakes:

• Trying to count negatives directly
• Ignoring negative values in input
• Switching to other sorts unnecessarily