Bird
Raised Fist0
DSA Cprogramming~10 mins

Comparison Based vs Non Comparison Based Sorting in DSA C - Interactive Comparison Practice

Choose your learning style10 modes available
Practice - 5 Tasks
Answer the questions below
1fill in blank
easy

Complete the code to swap two integers using a temporary variable.

DSA C
void swap(int *a, int *b) {
    int temp = [1];
    *a = *b;
    *b = temp;
}
Drag options to blanks, or click blank then click option'
A*b
B*a
Ctemp
Da
Attempts:
3 left
💡 Hint
Common Mistakes
Using 'a' instead of '*a' which stores the pointer address, not the value.
Using '*b' which would overwrite the wrong value.
2fill in blank
medium

Complete the code to perform a single pass of Bubble Sort comparing adjacent elements.

DSA C
void bubblePass(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        if (arr[i] [1] arr[i + 1]) {
            int temp = arr[i];
            arr[i] = arr[i + 1];
            arr[i + 1] = temp;
        }
    }
}
Drag options to blanks, or click blank then click option'
A<
B!=
C==
D>
Attempts:
3 left
💡 Hint
Common Mistakes
Using '<' which would sort in descending order incorrectly here.
Using '==' or '!=' which do not help in sorting.
3fill in blank
hard

Fix the error in the Counting Sort function to correctly count frequencies.

DSA C
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[[1]]++;
    }
    int index = 0;
    for (int i = 0; i <= maxVal; i++) {
        while (count[i] > 0) {
            arr[index++] = i;
            count[i]--;
        }
    }
}
Drag options to blanks, or click blank then click option'
Aarr[i]
Bi
Ccount[i]
DmaxVal
Attempts:
3 left
💡 Hint
Common Mistakes
Using 'i' which is the loop index, not the value to count.
Using 'count[i]' which causes wrong indexing.
4fill in blank
hard

Complete the while condition in the Insertion Sort inner loop for ascending order.

DSA C
for (int i = 1; i < n; i++) {
    int key = arr[i];
    int j = i - 1;
    while (j [1] 0 && arr[j] [2] key) {
        arr[j + 1] = arr[j];
        j = j - 1;
    }
    arr[j + 1] = key;
}
Drag options to blanks, or click blank then click option'
A>=
B>
C<=
D<
Attempts:
3 left
💡 Hint
Common Mistakes
Using '>' for the first blank may incorrectly handle j=0.
Using '<' for the second blank shifts elements in the wrong direction for ascending sort.
5fill in blank
hard

Complete the Lomuto partition function for Quick Sort (ascending). Assume swap(void *a, void *b) is defined.

DSA C
int partition(int arr[], int low, int high) {
    int pivot = arr[high];
    int i = low - 1;
    for (int j = low; j [1] high; j++) {
        if (arr[j] <= pivot) {
            i++;
            [2](&arr[i], &arr[j]);
        }
    }
    [3](&arr[i + 1], &arr[high]);
    return i + 1;
}
Drag options to blanks, or click blank then click option'
A<
Bswap
C<=
D>
Attempts:
3 left
💡 Hint
Common Mistakes
Using '<=' for the loop condition processes the pivot too early.
Omitting or misspelling the swap function call.

Practice

(1/5)
1. Which of the following sorting algorithms is non-comparison based?
easy
A. Quick Sort
B. Merge Sort
C. Counting Sort
D. Heap Sort

Solution

  1. Step 1: Understand comparison based sorting

    Merge Sort, Quick Sort, and Heap Sort sort by comparing elements to decide order.
  2. Step 2: Identify non-comparison based sorting

    Counting Sort uses counting frequencies, not comparisons, to sort elements.
  3. Final Answer:

    Counting Sort -> Option C
  4. Quick Check:

    Counting Sort = Non-comparison based [OK]
Hint: Counting Sort uses counts, not comparisons [OK]
Common Mistakes:
  • Confusing Quick Sort as non-comparison
  • Thinking Heap Sort is non-comparison
  • Assuming all sorts use comparisons
2. Which of the following is the correct syntax to call Radix Sort function in C if the function is defined as void radixSort(int arr[], int n);?
easy
A. radixSort();
B. radixSort(n, arr);
C. radixSort(arr);
D. radixSort(arr, n);

Solution

  1. Step 1: Check function definition

    The function expects an integer array and its size as parameters in order.
  2. Step 2: Match call with definition

    Calling radixSort(arr, n); matches the expected parameters and order.
  3. Final Answer:

    radixSort(arr, n); -> Option D
  4. Quick Check:

    Function call matches parameters [OK]
Hint: Match function parameters order exactly [OK]
Common Mistakes:
  • Swapping parameters order
  • Missing array size argument
  • Calling without arguments
3. What will be the output array after applying Counting Sort on arr = {4, 2, 2, 8, 3, 3, 1}?
medium
A. [2, 2, 3, 3, 4, 8, 1]
B. [1, 2, 2, 3, 3, 4, 8]
C. [1, 3, 2, 4, 8, 3, 2]
D. [8, 4, 3, 3, 2, 2, 1]

Solution

  1. Step 1: Count frequencies of each element

    1:1, 2:2, 3:2, 4:1, 8:1
  2. Step 2: Place elements in sorted order by frequency

    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:

    Counting Sort output = Sorted array [OK]
Hint: Counting Sort outputs sorted array by frequency [OK]
Common Mistakes:
  • Not counting duplicates correctly
  • Reversing order
  • Confusing input with output
4. The following code snippet attempts to perform Counting Sort but has a bug. What is the bug?
void countingSort(int arr[], int n) {
  int output[n];
  int count[10] = {0};
  for (int i = 0; i <= n; i++) {
    count[arr[i]]++;
  }
  for (int i = 1; i < 10; i++) {
    count[i] += count[i - 1];
  }
  for (int i = n - 1; i >= 0; i--) {
    output[count[arr[i]] - 1] = arr[i];
    count[arr[i]]--;
  }
  for (int i = 0; i < n; i++) {
    arr[i] = output[i];
  }
}
medium
A. Loop condition should be i < n instead of i <= n in first for loop
B. Count array size is too small
C. Output array is not initialized
D. Final copy loop should run from i = 1

Solution

  1. Step 1: Analyze first for loop range

    The loop runs from i=0 to i<=n, which accesses arr[n], out of bounds.
  2. Step 2: Correct loop condition

    It should be i < n to avoid accessing outside array bounds.
  3. Final Answer:

    Loop condition should be i < n instead of i <= n in first for loop -> Option A
  4. Quick Check:

    Array index out of bounds fixed by i < n [OK]
Hint: Check loop bounds carefully for array indexing [OK]
Common Mistakes:
  • Ignoring off-by-one errors
  • Assuming count array size is wrong without input info
  • Thinking output array needs initialization
5. You have an array of integers where values range from 0 to 1000. Which sorting algorithm is best to sort this array efficiently and why?
hard
A. Counting Sort, because it sorts in O(n + k) where k is range
B. Quick Sort, because it has average O(n log n) time
C. Merge Sort, because it is stable and works well on linked lists
D. Heap Sort, because it uses a heap data structure

Solution

  1. Step 1: Analyze input constraints

    Values range from 0 to 1000, so range k = 1001 is small and fixed.
  2. Step 2: Choose sorting algorithm based on range

    Counting Sort runs in O(n + k), which is efficient for small k compared to comparison sorts O(n log n).
  3. Final Answer:

    Counting Sort, because it sorts in O(n + k) where k is range -> Option A
  4. Quick Check:

    Small range favors Counting Sort [OK]
Hint: Small range arrays use Counting Sort for linear time [OK]
Common Mistakes:
  • Choosing Quick Sort ignoring range advantage
  • Confusing stability with speed
  • Ignoring Counting Sort's range dependency
Recommended

Ready to prove it?

Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.

10 questions~5 mineasy hard