Sorting Stability and When to Use Which Sort in DSA C - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a stable sorting algorithm function name.

DSA C

void [1](int arr[], int n);

Drag options to blanks, or click blank then click option'

AmergeSort

BquickSort

CheapSort

DselectionSort

Attempts:

3 left

💡 Hint

Common Mistakes

Choosing quickSort which is not stable by default.

mergeSort is a stable sorting algorithm, meaning it keeps the order of equal elements.

2fill in blank

medium

Complete the code to compare two elements for stability in sorting.

DSA C

if (arr[i] [1] arr[j]) { swap(&arr[i], &arr[j]); }

Drag options to blanks, or click blank then click option'

A>

B<

C==

D!=

Attempts:

3 left

💡 Hint

Common Mistakes

Using < instead of > causes incorrect swaps.

Using > ensures we swap only when the left element is greater, preserving stability if implemented carefully.

3fill in blank

hard

Fix the error in the code to maintain stability during insertion sort.

DSA C

while (j >= 0 && arr[j] [1] key) { arr[j + 1] = arr[j]; j--; }

Drag options to blanks, or click blank then click option'

A<=

B>

C>=

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using >= moves equal elements and breaks stability.

Using > ensures only elements greater than the key move, preserving stability.

4fill in blank

hard

Fill both blanks to create a condition that chooses a sorting algorithm based on data size.

DSA C

if (n [1] 1000) {
    [2](arr, n);
} else {
    quickSort(arr, 0, n - 1);
}

Drag options to blanks, or click blank then click option'

A<=

B>

CmergeSort

DinsertionSort

Attempts:

3 left

💡 Hint

Common Mistakes

Using > instead of <= causes wrong branch.

For small arrays (<= 1000), insertionSort is efficient and stable; otherwise, quickSort is used.

5fill in blank

hard

Fill all three blanks to implement a stable merge step in merge sort.

DSA C

while (i < n1 && j < n2) {
    if (L[i] [1] R[j]) {
        arr[k] = L[i];
        i[2];
    } else {
        arr[k] = R[j];
        j[3];
    }
    k++;
}

Drag options to blanks, or click blank then click option'

A<=

B++

C--

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using < breaks stability by preferring right element.

Using <= ensures stability by choosing left element first if equal. Increment i and j with ++ after assignment.

Practice

1. What does it mean when a sorting algorithm is called stable?

easy

A. It sorts elements in descending order

B. It uses less memory than unstable sorts

C. It keeps the original order of equal elements after sorting

D. It always sorts in linear time

Solution

1. Step 1: Understand stability in sorting

   A stable sort keeps the relative order of elements that compare equal unchanged.

2. Step 2: Compare options with definition

   Only It keeps the original order of equal elements after sorting matches this definition exactly.

3. Final Answer:

   It keeps the original order of equal elements after sorting -> Option C

4. Quick Check:

   Stable sort = keeps order of equal elements [OK]

Hint: Stable means equal items keep their original order [OK]

Common Mistakes:

• Confusing stability with sorting order
• Thinking stability means faster sorting
• Assuming stability relates to memory use

2. Which of the following is the correct syntax to call the qsort function in C for sorting an array arr of integers with n elements?

easy

A. qsort(arr, n, compare, sizeof(int));

B. qsort(arr, n, sizeof(int), compare);

C. qsort(arr, sizeof(int), n, compare);

D. qsort(arr, compare, n, sizeof(int));

Solution

1. Step 1: Recall qsort parameter order

   The qsort function parameters are: pointer to array, number of elements, size of each element, and comparison function pointer.

2. Step 2: Match parameters with options

   qsort(arr, n, sizeof(int), compare); matches this order exactly: arr, n, sizeof(int), compare.

3. Final Answer:

   qsort(arr, n, sizeof(int), compare); -> Option B

4. Quick Check:

   qsort syntax = arr, n, size, compare [OK]

Hint: Remember qsort: array, count, size, compare function [OK]

Common Mistakes:

• Mixing up size and count parameters
• Placing compare function in wrong position
• Using wrong order of arguments

3. Consider the following C code snippet using bubble sort on an array of structs with an integer key and a character value. Which output shows the array after sorting by key, preserving stability?

typedef struct {
  int key;
  char value;
} Item;

void bubbleSort(Item arr[], int n) {
  for (int i = 0; i < n-1; i++) {
    for (int j = 0; j < n-i-1; j++) {
      if (arr[j].key > arr[j+1].key) {
        Item temp = arr[j];
        arr[j] = arr[j+1];
        arr[j+1] = temp;
      }
    }
  }
}

int main() {
  Item arr[5] = {{2, 'a'}, {3, 'b'}, {2, 'c'}, {1, 'd'}, {3, 'e'}};
  bubbleSort(arr, 5);
  for (int i = 0; i < 5; i++) {
    printf("%d%c ", arr[i].key, arr[i].value);
  }
  return 0;
}

medium

A. 1d 2a 2c 3b 3e

B. 1d 2c 2a 3e 3b

C. 1d 2c 2a 3b 3e

D. 1d 2a 2c 3e 3b

Solution

1. Step 1: Understand bubble sort stability

   Bubble sort is stable, so equal keys keep their original order.

2. Step 2: Trace sorting of array

   Original order for key=2 is 'a' then 'c', for key=3 is 'b' then 'e'. After sorting by key, order is 1d, 2a, 2c, 3b, 3e.

3. Final Answer:

   1d 2a 2c 3b 3e -> Option A

4. Quick Check:

   Bubble sort stable = keeps order of equal keys [OK]

Hint: Stable sort keeps original order of equal keys [OK]

Common Mistakes:

• Assuming bubble sort is unstable
• Swapping equal keys and changing order
• Mixing up output order of equal keys

4. The following code attempts to sort an array using selection sort but does not preserve stability. What change fixes this to make it stable?

void selectionSort(int arr[], int n) {
  for (int i = 0; i < n-1; i++) {
    int min_idx = i;
    for (int j = i+1; j < n; j++) {
      if (arr[j] < arr[min_idx]) {
        min_idx = j;
      }
    }
    int temp = arr[min_idx];
    arr[min_idx] = arr[i];
    arr[i] = temp;
  }
}

medium

A. Sort array in descending order

B. Use bubble sort instead of selection sort

C. Change comparison to <= instead of <

D. Replace swap with shifting elements to insert min element

Solution

1. Step 1: Identify why selection sort is unstable

   Selection sort swaps min element directly, which can reorder equal elements and break stability.

2. Step 2: Fix by shifting elements

   Instead of swapping, shift elements right and insert min element at correct position to keep order.

3. Final Answer:

   Replace swap with shifting elements to insert min element -> Option D

4. Quick Check:

   Stable selection sort = shift, not swap [OK]

Hint: Shift elements instead of swap for stable selection sort [OK]

Common Mistakes:

• Just changing comparison operator
• Switching to bubble sort without reason
• Sorting in wrong order

5. You have a large dataset with many duplicate keys and need to sort it by key while preserving the order of duplicates. The dataset is too large to fit in memory, so you must use external sorting. Which sorting algorithm is best suited for this task?

hard

A. External merge sort because it is stable and handles large data

B. Quick sort because it is fastest in average case

C. Heap sort because it uses constant memory

D. Selection sort because it is simple to implement

Solution

1. Step 1: Understand requirements for large data and stability

   Large data needs external sorting; stability is required to keep duplicate order.

2. Step 2: Match algorithm features

   External merge sort is stable and designed for large data using disk; quicksort and heapsort are unstable and in-memory; selection sort is inefficient.

3. Final Answer:

   External merge sort because it is stable and handles large data -> Option A

4. Quick Check:

   Large stable sort = external merge sort [OK]

Hint: Use external merge sort for large stable sorting [OK]

Common Mistakes:

• Choosing quicksort ignoring stability
• Picking heapsort without external support
• Using simple sorts for large data