Why Sorting Matters and How It Unlocks Other Algorithms in DSA C - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Merge Sort on an Unsorted Array

What is the output of the following C code after sorting the array using merge sort?

DSA C

#include <stdio.h>

void merge(int arr[], int l, int m, int r) {
    int n1 = m - l + 1;
    int n2 = r - m;
    int L[n1], R[n2];
    for (int i = 0; i < n1; i++)
        L[i] = arr[l + i];
    for (int j = 0; j < n2; j++)
        R[j] = arr[m + 1 + j];
    int i = 0, j = 0, k = l;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        } else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }
    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }
    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}

void mergeSort(int arr[], int l, int r) {
    if (l < r) {
        int m = l + (r - l) / 2;
        mergeSort(arr, l, m);
        mergeSort(arr, m + 1, r);
        merge(arr, l, m, r);
    }
}

int main() {
    int arr[] = {5, 2, 9, 1, 5, 6};
    int n = sizeof(arr) / sizeof(arr[0]);
    mergeSort(arr, 0, n - 1);
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}

A 5 2 9 1 5 6

B 9 6 5 5 2 1

C 1 5 2 6 9 5

D 1 2 5 5 6 9

💡 Hint

Think about how merge sort divides and merges the array.

Merge sort divides the array into halves recursively and merges them in sorted order. The final output is the sorted array in ascending order.

🧠 Conceptual

intermediate

Why is Sorting Important for Binary Search?

Why must an array be sorted before applying binary search?

A Because sorting reduces the array size automatically.

B Because binary search only works on arrays with unique elements.

C Because binary search divides the array and compares middle elements, which only works correctly if the array is sorted.

D Because binary search swaps elements to sort the array first.

💡 Hint

Think about how binary search decides which half to search next.

Binary search relies on the order of elements to decide whether to search the left or right half. Without sorting, this logic fails.

❓ Predict Output

advanced

Output of Quick Sort Partition Step

What is the state of the array after the partition function completes in quick sort for the given input?

DSA C

#include <stdio.h>

int partition(int arr[], int low, int high) {
    int pivot = arr[high];
    int i = low - 1;
    for (int j = low; j < high; j++) {
        if (arr[j] < pivot) {
            i++;
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
    int temp = arr[i + 1];
    arr[i + 1] = arr[high];
    arr[high] = temp;
    return i + 1;
}

int main() {
    int arr[] = {10, 80, 30, 90, 40, 50, 70};
    int n = sizeof(arr) / sizeof(arr[0]);
    int pi = partition(arr, 0, n - 1);
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}

A 10 30 40 50 70 90 80

B 08 09 07 05 04 03 01

C 10 30 40 50 70 80 90

D 09 08 07 05 04 03 01

💡 Hint

The pivot is the last element; elements less than pivot go left.

Partition moves elements less than pivot to the left and places pivot in correct position. The array after partition is: 10 30 40 50 70 90 80 with pivot index 4.

🔧 Debug

advanced

Identify the Bug in Bubble Sort Implementation

What is the output of this bubble sort code and what is the bug causing it?

DSA C

#include <stdio.h>

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

int main() {
    int arr[] = {3, 2, 1};
    int n = sizeof(arr) / sizeof(arr[0]);
    bubbleSort(arr, n);
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}

A Runtime error due to out-of-bounds access

B 1 2 3

C 3 2 1

D 2 1 3

💡 Hint

Check the inner loop boundary conditions carefully.

The inner loop should run till j < n - i - 1 to avoid out-of-bounds access. The corrected code sorts the array correctly.

🚀 Application

expert

Using Sorting to Find the Intersection of Two Arrays

Given two unsorted arrays, which approach correctly finds their intersection using sorting?

A Sort both arrays, then use two pointers to find common elements in O(n log n + m log m) time.

B Sort one array and use binary search for each element of the other array.

C Use nested loops to compare each element of one array with all elements of the other without sorting.

D Use a hash map to store elements of one array and check membership for the other without sorting.

💡 Hint

Sorting both arrays allows linear time intersection with two pointers.

Sorting both arrays lets you scan them simultaneously with two pointers to find common elements efficiently.

Practice

1. Why is sorting an important step before applying many algorithms on data?

easy

A. It encrypts data for security

B. It deletes duplicate data automatically

C. It organizes data to make searching and comparisons faster

D. It compresses data to save space

Solution

1. Step 1: Understand sorting's role in data organization

   Sorting arranges data in order, which helps algorithms work efficiently by reducing unnecessary checks.

2. Step 2: Connect sorting to faster searching and comparisons

   When data is sorted, algorithms like binary search can quickly find elements, improving speed.

3. Final Answer:

   It organizes data to make searching and comparisons faster -> Option C

4. Quick Check:

   Sorting helps algorithms run faster = C [OK]

Hint: Sorting arranges data to speed up other algorithms [OK]

Common Mistakes:

• Thinking sorting deletes duplicates
• Confusing sorting with encryption
• Assuming sorting compresses data

2. Which of the following is the correct syntax to sort an integer array arr of size n in C using the standard library?

easy

A. sort(arr, arr+n);

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

C. arr.sort();

D. sort(arr, n);

Solution

1. Step 1: Recall C standard library sorting function

   In C, qsort is used with parameters: pointer to array, number of elements, size of each element, and a comparison function.

2. Step 2: Check each option's syntax

   qsort(arr, n, sizeof(int), compare); matches qsort usage. Options B and D are C++ style or incorrect. arr.sort(); is invalid in C.

3. Final Answer:

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

4. Quick Check:

   C sorting uses qsort with compare function = A [OK]

Hint: Use qsort with compare function in C [OK]

Common Mistakes:

• Using C++ sort syntax in C
• Calling sort without compare function
• Trying to use array methods like arr.sort()

3. What is the output of the following C code snippet?

int arr[] = {5, 2, 9, 1};
int n = 4;
qsort(arr, n, sizeof(int), compare);
for(int i = 0; i < n; i++) printf("%d ", arr[i]);

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

medium

A. 9 5 2 1

B. Compilation error

C. 5 2 9 1

D. 1 2 5 9

Solution

1. Step 1: Understand qsort with compare function

   The compare function subtracts two integers, sorting in ascending order.

2. Step 2: Apply sorting to array

   Original array {5, 2, 9, 1} sorted ascending becomes {1, 2, 5, 9}.

3. Final Answer:

   1 2 5 9 -> Option D

4. Quick Check:

   Sorted ascending array = 1 2 5 9 [OK]

Hint: Compare function subtracts for ascending sort [OK]

Common Mistakes:

• Assuming descending order
• Ignoring compare function logic
• Confusing pointer casting in compare

4. Identify the error in the following C code that attempts to sort an array using qsort:

int arr[] = {3, 1, 4};
int n = 3;
qsort(arr, n, sizeof(int), compare);

int compare(int *a, int *b) {
    return *a - *b;
}

medium

A. The compare function's parameters should be 'const void *', not 'int *'

B. The array size 'n' is incorrect

C. qsort requires a different sorting function name

D. The array 'arr' must be dynamically allocated

Solution

1. Step 1: Check compare function signature for qsort

   qsort expects a compare function with parameters of type 'const void *' to work correctly.

2. Step 2: Identify mismatch in function parameters

   The given compare function uses 'int *' which causes a type mismatch and compilation error.

3. Final Answer:

   The compare function's parameters should be 'const void *', not 'int *' -> Option A

4. Quick Check:

   Correct compare signature = const void * parameters [OK]

Hint: Compare function must use const void pointers [OK]

Common Mistakes:

• Using wrong parameter types in compare function
• Assuming array size is wrong
• Thinking qsort needs dynamic arrays

5. You have a large list of unsorted numbers and want to find if any two numbers sum to a target value efficiently. Which approach best uses sorting to unlock a faster solution?

hard

A. Sort the list, then use two pointers from start and end to find the sum

B. Sort the list and then check every pair with nested loops

C. Use sorting to remove duplicates first, then check sums

D. Sort the list and then perform binary search for each element's complement

Solution

1. Step 1: Understand the two-pointer technique after sorting

   Sorting allows placing pointers at start and end to check sums efficiently without nested loops.

2. Step 2: Compare with other options

   Sort the list and then check every pair with nested loops uses nested loops which is slower. Use sorting to remove duplicates first, then check sums is unrelated to sum search. Sort the list and then perform binary search for each element's complement is slower than two-pointer approach.

3. Final Answer:

   Sort the list, then use two pointers from start and end to find the sum -> Option A

4. Quick Check:

   Two-pointer after sorting = fastest sum search [OK]

Hint: Use two pointers on sorted list for sum search [OK]

Common Mistakes:

• Using nested loops after sorting
• Thinking removing duplicates helps sum search
• Using binary search for each complement inefficiently