Counting Sort Algorithm in DSA Java - Time & Space Complexity

Time Complexity: Counting Sort Algorithm

O(n + k)

Understanding Time Complexity

We want to understand how the time needed by Counting Sort changes as the input size grows.

Specifically, how the number of steps depends on the number of items and the range of values.

Scenario Under Consideration

Analyze the time complexity of the following Counting Sort code.

public void countingSort(int[] arr) {
    int max = arr[0];
    for (int i = 1; i < arr.length; i++) {
        if (arr[i] > max) max = arr[i];
    }
    int[] count = new int[max + 1];
    for (int num : arr) {
        count[num]++;
    }
    int index = 0;
    for (int i = 0; i < count.length; i++) {
        while (count[i]-- > 0) {
            arr[index++] = i;
        }
    }
}
    

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

Identify Repeating Operations

Look for loops and repeated steps in the code.

• Primary operation: Three loops: one to find max, one to count frequencies, one to rebuild sorted array.
• How many times: Each loop runs proportional to input size or range size.

How Execution Grows With Input

The time depends on both the number of items (n) and the range of values (k).

Input Size (n)	Range Size (k)	Approx. Operations
10	5	About 10 + 10 + 5 = 25
100	50	About 100 + 100 + 50 = 250
1000	200	About 1000 + 1000 + 200 = 2200

Pattern observation: The total steps grow roughly as the sum of input size and range size.

Final Time Complexity

Time Complexity: O(n + k)

This means the time grows linearly with both the number of items and the range of values.

Common Mistake

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

[OK] Correct: The time also depends on the range of values (k). If k is very large, the algorithm slows down.

Interview Connect

Understanding Counting Sort's time complexity helps you explain when it is efficient and when it is not, a useful skill in interviews.

Self-Check

"What if the input array contains negative numbers? How would the time complexity change?"

Practice

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

easy

A. Count the occurrences of each element and use counts to place elements in order

B. Compare each element with every other element to sort

C. Divide the array into halves and sort recursively

D. Swap adjacent elements if they are in wrong order 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

   These counts help to place elements directly in the sorted output without comparisons.

3. Final Answer:

   Count the occurrences of each element and use counts to place elements in order -> Option A

4. Quick Check:

   Counting occurrences = main idea [OK]

Hint: Counting Sort uses counts, not comparisons, to sort [OK]

Common Mistakes:

• Thinking Counting Sort compares elements
• Confusing Counting Sort with Quick Sort or Merge Sort
• Assuming Counting Sort works well with all data types

2. Which of the following is the correct way to declare the count array for Counting Sort in Java if the input values range from 0 to 9?

easy

A. int[] count = new int[10];

B. int count[] = new int(10);

C. int count = new int[10];

D. int[] count = new int();

Solution

1. Step 1: Understand Java array declaration syntax

   In Java, arrays are declared with type[], name = new type[size];

2. Step 2: Check each option for correct syntax

   int[] count = new int[10]; uses correct syntax: int[] count = new int[10]; int count[] = new int(10); uses parentheses instead of brackets, invalid. int count = new int[10]; misses brackets on left side. int[] count = new int(); misses size in brackets.

3. Final Answer:

   int[] count = new int[10]; -> Option A

4. Quick Check:

   Correct Java array syntax = int[] count = new int[10]; [OK]

Hint: Use square brackets and specify size for arrays in Java [OK]

Common Mistakes:

• Using parentheses instead of square brackets
• Not specifying array size when creating
• Incorrect placement of brackets in declaration

3. What will be the output of the following Java code snippet using Counting Sort?

int[] arr = {4, 2, 2, 8, 3, 3, 1};
int max = 8;
int[] count = new int[max + 1];
for (int num : arr) {
    count[num]++;
}
int index = 0;
for (int i = 0; i <= max; i++) {
    while (count[i] > 0) {
        arr[index++] = i;
        count[i]--;
    }
}
System.out.println(java.util.Arrays.toString(arr));

medium

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

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

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

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

Solution

1. Step 1: Count occurrences of each number

   Count array after loop: count[1]=1, count[2]=2, count[3]=2, count[4]=1, count[8]=1, others=0.

2. Step 2: Rebuild sorted array using counts

   Fill arr with 1 once, 2 twice, 3 twice, 4 once, 8 once in order.

3. Final Answer:

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

4. Quick Check:

   Sorted array matches [1, 2, 2, 3, 3, 4, 8] [OK]

Hint: Count frequencies, then overwrite array in order [OK]

Common Mistakes:

• Not initializing count array size correctly
• Forgetting to decrement count during placement
• Printing original array without sorting

4. Identify the error in this Counting Sort code snippet and select the correct fix:

int[] arr = {3, 1, 2};
int max = 3;
int[] count = new int[max];
for (int num : arr) {
    count[num]++;
}

medium

A. Change 'count[num]++' to 'count[num - 1]++' to fix indexing

B. Change 'int[] count = new int[max];' to 'int[] count = new int[max + 1];' to include max index

C. Initialize count array with size 'max - 1' instead of 'max' to save space

D. No error, code is correct as is

Solution

1. Step 1: Check count array size for indexing

   Array 'count' size is max=3, so indices 0,1,2 are valid but input has value 3 which is out of bounds.

2. Step 2: Fix count array size to include max index

   Size should be max+1=4 to allow index 3 access safely.

3. Final Answer:

   Change 'int[] count = new int[max];' to 'int[] count = new int[max + 1];' to include max index -> Option B

4. Quick Check:

   Array size must cover max value index [OK]

Hint: Count array size = max value + 1 to avoid index errors [OK]

Common Mistakes:

• Using count array size equal to max value only
• Adjusting indices incorrectly instead of size
• Ignoring ArrayIndexOutOfBoundsException

5. Given an array arr = {5, 3, 0, 2, 3, 0, 1}, how would you modify the Counting Sort algorithm to sort it if the input can contain negative numbers as well? Choose the best approach.

hard

A. Use a hash map instead of an array for counts

B. Ignore negative numbers as Counting Sort cannot handle them

C. Shift all numbers by adding the absolute value of the minimum negative number before counting

D. Sort only the positive numbers and append negatives at the end

Solution

1. Step 1: Understand Counting Sort limitation with negatives

   Counting Sort uses array indices as counts, so negative indices are invalid.

2. Step 2: Shift values to non-negative range

   Find minimum value, add its absolute value to all elements to make them non-negative, then apply Counting Sort.

3. Final Answer:

   Shift all numbers by adding the absolute value of the minimum negative number before counting -> Option C

4. Quick Check:

   Shift negatives to positive range for Counting Sort [OK]

Hint: Add offset to handle negatives before counting [OK]

Common Mistakes:

• Trying to use negative indices in count array
• Ignoring negative values in input
• Using incorrect data structures without reason