Why Binary Search and What Sorted Order Gives You in DSA Javascript - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Binary Search on Sorted Array

What is the output of the following JavaScript code that performs binary search on a sorted array to find the index of number 7?

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 sortedArray = [1, 3, 5, 7, 9, 11];
console.log(binarySearch(sortedArray, 7));

A -1

B 3

C 2

D 4

💡 Hint

Remember that array indices start at 0 and the array is sorted.

The number 7 is at index 3 in the sorted array [1, 3, 5, 7, 9, 11]. Binary search finds it by checking the middle element and narrowing the search range.

🧠 Conceptual

intermediate

Why Must the Array Be Sorted for Binary Search?

Why is it necessary for the array to be sorted before performing binary search?

A Because binary search requires the array to be reversed first.

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

C Because binary search compares the target with the middle element to decide which half to search next, which only works if the array is sorted.

D Because binary search can only find the first element in any array.

💡 Hint

Think about how binary search decides which half of the array to ignore.

Binary search relies on the order of elements to decide whether to search the left or right half. Without sorting, this decision cannot be made correctly.

❓ Predict Output

advanced

Binary Search Result on Unsorted Array

What is the output of this JavaScript code that runs binary search on an unsorted array to find number 7?

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 unsortedArray = [9, 1, 11, 3, 7, 5];
console.log(binarySearch(unsortedArray, 7));

A -1

B 3

C 2

D 0

💡 Hint

Binary search assumes sorted order; what happens if the array is not sorted?

Binary search on an unsorted array does not guarantee correct results. It may fail to find the target even if it exists.

🧠 Conceptual

advanced

Effect of Sorted Order on Search Efficiency

How does having a sorted array improve the efficiency of searching compared to an unsorted array?

A Sorted arrays allow binary search, which reduces the search steps from linear to logarithmic time.

B Sorted arrays allow linear search to run faster than on unsorted arrays.

C Sorted arrays require more steps to search because elements are arranged in order.

D Sorted arrays do not affect search efficiency; search time is always the same.

💡 Hint

Think about how many elements you can ignore each step in binary search.

Binary search on sorted arrays cuts the search space in half each step, making it much faster than checking each element one by one.

🚀 Application

expert

Final Position After Multiple Binary Search Steps

Given the sorted array [2, 4, 6, 8, 10, 12, 14] and target 10, after two iterations of the binary search loop, what is the value of the variable 'left'?

DSA Javascript

const arr = [2, 4, 6, 8, 10, 12, 14];
const target = 10;
let left = 0;
let right = arr.length - 1;

// First iteration
let mid = Math.floor((left + right) / 2);
if (arr[mid] < target) {
  left = mid + 1;
} else {
  right = mid - 1;
}

// Second iteration
mid = Math.floor((left + right) / 2);
if (arr[mid] < target) {
  left = mid + 1;
} else {
  right = mid - 1;
}

console.log(left);

A 3

B 5

C 2

D 4

💡 Hint

Trace the values of left, right, and mid after each iteration carefully.

After the first iteration, left becomes 4 (mid=3, arr[3]=8 < 10). After the second iteration, mid=5, arr[5]=12 > 10, right=4, left remains 4.