Counting Sort Algorithm in DSA C - Time & Space Complexity

Time Complexity: Counting Sort Algorithm

O(n + k)

Understanding Time Complexity

Counting Sort is a special sorting method that works well when numbers are in a small range.

We want to know how the time it takes changes as the list size and number range grow.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

void countingSort(int arr[], int n, int maxVal) {
    int count[maxVal + 1];
    for (int i = 0; i <= maxVal; i++)
        count[i] = 0;
    for (int i = 0; i < n; i++)
        count[arr[i]]++;
    int index = 0;
    for (int i = 0; i <= maxVal; i++) {
        while (count[i]-- > 0) {
            arr[index++] = i;
        }
    }
}
    

This code sorts an array by counting how many times each number appears, then rebuilding the sorted array.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Three loops: one to initialize counts, one to count elements, one to rebuild sorted array.
• How many times: First loop runs maxVal+1 times, second runs n times, third runs maxVal+1 times plus total n times inside inner while.

How Execution Grows With Input

The time depends on both the number of elements (n) and the range of numbers (maxVal).

Input Size (n)	Approx. Operations (with fixed maxVal=100)
10	About 10 + 101 + 10 = 121
100	About 100 + 101 + 100 = 301
1000	About 1000 + 101 + 1000 = 2101

Pattern observation: Operations grow roughly linearly with n plus the fixed range size.

Range Size (maxVal)	Approx. Operations (with fixed n=100)
10	About 100 + 11 + 100 = 211
100	About 100 + 101 + 100 = 301
1000	About 100 + 1001 + 100 = 1201

Pattern observation: Operations grow linearly with the range size plus the number of elements.

Final Time Complexity

Time Complexity: O(n + k)

This means the time grows linearly with the number of elements (n) plus the range of input values (k).

Common Mistake

[X] Wrong: "Counting Sort always runs in linear time regardless of input range."

[OK] Correct: If the range (k) is very large compared to n, the time to initialize and process counts grows too, so it's not just about n.

Interview Connect

Understanding Counting Sort's time helps you choose the right sorting method based on data size and range, a useful skill in many coding challenges.

Self-Check

"What if the input array contains negative numbers? How would the time complexity change if we adapt Counting Sort to handle them?"

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