Why Sorting Matters and How It Unlocks Other Algorithms in DSA C - Test Your Knowledge

Practice - 5 Tasks

1fill in blank

easy

Complete the code to sort the array using bubble sort.

DSA C

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

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

A==

B<

C>

D!=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<' instead of '>' causes descending order instead of ascending.

Using '==' or '!=' does not sort properly.

The bubble sort swaps elements if the current element is greater than the next, to sort in ascending order.

2fill in blank

medium

Complete the code to find the middle index for merge sort splitting.

DSA C

int mid = [1] + (high - low) / 2;

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

Alow

Bhigh

C0

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using high alone causes wrong middle index.

Using 0 or 1 ignores the current segment boundaries.

The middle index is calculated from the low index plus half the distance to high.

3fill in blank

hard

Fix the error in the binary search condition to find the target.

DSA C

if (arr[mid] [1] target) {
    return mid;
} else if (arr[mid] < target) {
    low = mid + 1;
} else {
    high = mid - 1;
}

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

A==

B<

C!=

D>

Attempts:

3 left

💡 Hint

Common Mistakes

Using '!=' causes wrong logic and misses the target.

Using '>' or '<' in this condition is incorrect.

Binary search finds the target when the middle element equals the target.

4fill in blank

hard

Fill both blanks to complete the insertion sort inner loop condition.

DSA C

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

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

A>

B<

C--

D++

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<' instead of '>' reverses the sorting order.

Incrementing j causes infinite loop or wrong behavior.

Insertion sort shifts elements greater than the key to the right and decrements j.

5fill in blank

hard

Fill all three blanks to complete the filtering loop that filters and transforms data.

DSA C

for (int i = 0; i < n; i++) {
    if (arr[i] [1] pivot) {
        result[[2]] = arr[i] * 2;
    }
    [3]
}

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

A>

Bi

Ccontinue

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using '>' filters wrong elements.

Not using 'continue' causes unwanted processing.

The loop filters elements less than pivot, stores doubled values using index i in result, and continues to the next iteration.

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