Counting Sort Algorithm in DSA Python - 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.

beginner

What kind of data is Counting Sort best suited for?

Counting Sort works best for sorting numbers that are whole and fall within a small range, like ages or test scores.

intermediate

Why does Counting Sort use an extra array to store counts?

The extra array keeps track of how many times each number appears, so we know exactly where to put each number in the sorted list.

intermediate

What is the time complexity of Counting Sort and why?

Counting Sort runs in O(n + k) time, where n is the number of items and k is the range of input values, because it counts and places items without comparing them.

advanced

How does Counting Sort maintain stability (keeping equal elements in original order)?

Counting Sort places elements from the end of the input array to the output array using the count array, ensuring elements with the same value stay in their original order.

What does Counting Sort use to determine the position of each element in the sorted array?

A Recursive division of the array

B A count array that stores the frequency of each element

C Swapping elements repeatedly

D Comparisons between elements

Counting Sort uses a count array to store how many times each number appears, which helps place elements directly without comparisons.

Counting Sort is most efficient when the range of input values is:

A About the same size as the number of elements

B Much larger than the number of elements

C Much smaller than the number of elements

D Irrelevant to the algorithm's efficiency

Counting Sort is efficient when the range of input values (k) is not much larger than the number of elements (n), making O(n + k) manageable.

Which of these is NOT a step in Counting Sort?

A Comparing elements pairwise

B Calculating cumulative counts

C Counting the frequency of each element

D Placing elements into the output array

Counting Sort does not compare elements pairwise; it uses counts to place elements directly.

What is the space complexity of Counting Sort?

A O(1)

B O(n)

C O(k)

D O(n + k)

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

How does Counting Sort handle negative numbers?

A It works directly without changes

B It sorts negatives before positives automatically

C It cannot handle negative numbers without modification

D It converts negatives to positives internally

Counting Sort needs modification to handle negative numbers, such as shifting values to be non-negative.

Explain how Counting Sort works step-by-step using a simple example.

Think about how you count and then use those counts to place numbers in order.

Describe when and why you would choose Counting Sort over other sorting algorithms.

Consider the type of data and performance needs.

Practice

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

easy

A. Swapping adjacent elements if they are in wrong order

B. Comparing each element with every other element to sort

C. Dividing the list into halves and sorting recursively

D. Counting the occurrences of each element and using that to place elements in order

Solution

1. Step 1: Understand Counting Sort principle

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

2. Step 2: Use counts to place elements

   It then uses these counts to place elements directly in the sorted order without comparisons.

3. Final Answer:

   Counting the occurrences of each element and using that to place elements in order -> Option D

4. Quick Check:

   Counting occurrences = A [OK]

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

Common Mistakes:

• Thinking Counting Sort compares elements
• Confusing Counting Sort with comparison-based sorts
• Assuming Counting Sort works on all data types

2. Which of the following is the correct way to initialize the count array for Counting Sort in Python for input values ranging from 0 to 5?

easy

A. count = [0] * 6

B. count = [0] * 5

C. count = [null] * 6

D. count = []

Solution

1. Step 1: Determine count array size

   For values 0 to 5 inclusive, we need 6 slots (0,1,2,3,4,5).

2. Step 2: Initialize count array with zeros

   Using [0] * 6 creates a list of six zeros to count occurrences.

3. Final Answer:

   count = [0] * 6 -> Option A

4. Quick Check:

   Length 6 with zeros = D [OK]

Hint: Count array size = max value + 1 [OK]

Common Mistakes:

• Using wrong size for count array
• Initializing with null instead of 0
• Leaving count array empty

3. What will be the output of the following Python code using Counting Sort on the list [4, 2, 2, 8, 3, 3, 1]?

def counting_sort(arr):
    max_val = max(arr)
    count = [0] * (max_val + 1)
    for num in arr:
        count[num] += 1
    sorted_arr = []
    for i in range(len(count)):
        sorted_arr.extend([i] * count[i])
    return sorted_arr

print(counting_sort([4, 2, 2, 8, 3, 3, 1]))

medium

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

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

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

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

Solution

1. Step 1: Count occurrences of each number

   Count array for max_val=8: counts for 1=1, 2=2, 3=2, 4=1, 8=1, others=0.

2. Step 2: Build sorted list using counts

   Extend sorted_arr with each number repeated by its count: [1, 2, 2, 3, 3, 4, 8].

3. Final Answer:

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

4. Quick Check:

   Sorted list matches counting sort output = B [OK]

Hint: Counting Sort output is sorted list with duplicates in order [OK]

Common Mistakes:

• Forgetting to repeat elements by their count
• Returning unsorted or reversed list
• Including zeros for missing elements

4. The following code attempts to implement Counting Sort but has a bug. What is the error?

def counting_sort_bug(arr):
    max_val = max(arr)
    count = [0] * max_val
    for num in arr:
        count[num] += 1
    sorted_arr = []
    for i in range(len(count)):
        sorted_arr.extend([i] * count[i])
    return sorted_arr

print(counting_sort_bug([3, 1, 2, 3]))

medium

A. Count array initialized with zeros incorrectly

B. Loop to build sorted_arr uses wrong range

C. Count array size is too small, missing last element count

D. Function does not return anything

Solution

1. Step 1: Check count array size

   Count array size is max_val, but should be max_val + 1 to include max element index.

2. Step 2: Understand impact on counting

   Missing last index causes error when counting max element (3), leading to IndexError or wrong counts.

3. Final Answer:

   Count array size is too small, missing last element count -> Option C

4. Quick Check:

   Count array size = max_val + 1 [OK]

Hint: Count array size must be max value + 1 [OK]

Common Mistakes:

• Using max_val instead of max_val + 1 for count array size
• Ignoring IndexError from out-of-range access
• Not initializing count array properly

5. You have a list of exam scores ranging from 0 to 100, but some scores are missing. How can you modify Counting Sort to efficiently sort this list and also find how many students scored exactly 75?

hard

A. Use a comparison sort and count 75s during sorting

B. Use Counting Sort normally, then check count[75] for number of students scoring 75

C. Sort with Counting Sort and then scan sorted list to count 75s

D. Use Counting Sort but ignore counts for missing scores

Solution

1. Step 1: Apply Counting Sort on scores 0-100

   Create count array of size 101, count occurrences of each score.

2. Step 2: Use count array to find number of 75 scores

   Count at index 75 directly gives number of students scoring 75 without scanning sorted list.

3. Final Answer:

   Use Counting Sort normally, then check count[75] for number of students scoring 75 -> Option B

4. Quick Check:

   Counting array index = score count, access directly [OK]

Hint: Counting array index = score count, access directly [OK]

Common Mistakes:

• Scanning sorted list instead of using count array
• Ignoring missing scores in count array
• Using slower comparison sorts unnecessarily