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

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Sorting and Searching in a Sorted Array

What is the output of the following JavaScript code that sorts an array and then searches for a value using binary search?

DSA Javascript

function binarySearch(arr, target) {
  let left = 0;
  let right = arr.length - 1;
  while (left <= right) {
    const mid = Math.floor((left + right) / 2);
    if (arr[mid] === target) return mid;
    else if (arr[mid] < target) left = mid + 1;
    else right = mid - 1;
  }
  return -1;
}

const nums = [5, 3, 8, 4, 2];
nums.sort((a, b) => a - b);
const index = binarySearch(nums, 4);
console.log(nums);
console.log(index);

A [5, 3, 8, 4, 2]\n-1

B [2, 3, 4, 5, 8]\n3

C [5, 3, 8, 4, 2]\n3

D [2, 3, 4, 5, 8]\n2

💡 Hint

Remember that Array.sort with a compare function sorts numbers ascending, and binary search returns the index of the target in the sorted array.

The array is sorted to [2, 3, 4, 5, 8]. The binary search looks for 4 and finds it at index 2 (0-based).

🧠 Conceptual

intermediate

Why Sorting Helps in Finding Duplicates

Why does sorting an array first make it easier to find duplicate elements?

A Because sorting reverses the array, which helps in finding duplicates.

B Because sorting groups equal elements together, so duplicates appear next to each other making them easy to spot.

C Because sorting changes the values of elements to unique ones.

D Because sorting removes duplicates automatically.

💡 Hint

Think about how duplicates would look if the array is sorted.

When the array is sorted, all duplicates are placed next to each other. This makes it easy to check neighbors to find duplicates.

❓ Predict Output

advanced

Output of Merging Two Sorted Arrays

What is the output of the following JavaScript code that merges two sorted arrays into one sorted array?

DSA Javascript

function mergeSortedArrays(arr1, arr2) {
  const merged = [];
  let i = 0, j = 0;
  while (i < arr1.length && j < arr2.length) {
    if (arr1[i] < arr2[j]) {
      merged.push(arr1[i]);
      i++;
    } else {
      merged.push(arr2[j]);
      j++;
    }
  }
  while (i < arr1.length) merged.push(arr1[i++]);
  while (j < arr2.length) merged.push(arr2[j++]);
  return merged;
}

const a = [1, 3, 5];
const b = [2, 4, 6];
console.log(mergeSortedArrays(a, b));

A [1, 2, 3, 4, 5, 6]

B [1, 3, 5, 2, 4, 6]

C [2, 4, 6, 1, 3, 5]

D [1, 2, 4, 3, 5, 6]

💡 Hint

The function merges two sorted arrays by comparing elements one by one.

The function compares elements from both arrays and pushes the smaller one, resulting in a fully sorted merged array.

🔧 Debug

advanced

Identify the Error in Sorting Objects by Property

What error will the following code produce when trying to sort an array of objects by their 'age' property?

DSA Javascript

const people = [{name: 'Alice', age: 25}, {name: 'Bob', age: 20}];
people.sort((a, b) => a.age > b.age);
console.log(people);

A The array is sorted incorrectly because the compare function returns a boolean instead of a number.

B SyntaxError due to missing return statement in compare function.

C The array is sorted correctly by age ascending.

D TypeError because 'age' is undefined.

💡 Hint

Array.sort compare function must return a number, not a boolean.

The compare function returns true or false, which is converted to 1 or 0, causing incorrect sorting behavior.

🚀 Application

expert

Using Sorting to Optimize Interval Scheduling

Given a list of intervals with start and end times, which sorting strategy helps to find the maximum number of non-overlapping intervals?

A Sort intervals by their duration (end - start) in descending order.

B Sort intervals by their start time in ascending order.

C Sort intervals by their end time in ascending order.

D Sort intervals by their start time in descending order.

💡 Hint

Choosing intervals that finish earliest leaves room for more intervals later.

Sorting by end time ascending allows greedy selection of intervals that finish earliest, maximizing the count of non-overlapping intervals.