Binary Search Iterative Approach in DSA Javascript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main idea behind the binary search algorithm?

Binary search repeatedly divides a sorted list in half to find a target value quickly by comparing the middle element and deciding which half to search next.

beginner

In the iterative binary search, what variables are commonly used to keep track of the search range?

Two variables: low (start index) and high (end index) define the current search range within the sorted array.

intermediate

Why do we calculate the middle index as mid = low + Math.floor((high - low) / 2) instead of (low + high) / 2?

To avoid potential overflow when low and high are large numbers, this formula safely calculates the middle index without exceeding number limits.

beginner

What condition ends the iterative binary search loop?

The loop ends when low becomes greater than high, meaning the target is not found in the array.

beginner

What is the time complexity of the binary search iterative approach and why?

The time complexity is O(log n) because the search space halves with each step, quickly narrowing down the target position.

What must be true about the array before applying binary search?

A The array must be unsorted

B The array must be sorted

C The array must contain only positive numbers

D The array must have unique elements only

Binary search only works correctly on sorted arrays because it relies on order to decide which half to search.

In iterative binary search, if the middle element is less than the target, what happens next?

A Search the left half by moving high

B Stop the search and return -1

C Search the right half by moving low

D Return the middle index immediately

If middle element is less than target, the target must be in the right half, so low is moved to mid + 1.

What does the iterative binary search return if the target is not found?

A -1

B The index of the closest element

C 0

D null

Returning -1 is a common way to indicate the target is not present in the array.

Which of these is the correct way to calculate the middle index to avoid overflow?

A mid = (low + high) / 2

B mid = (low - high) / 2

C mid = high - low

D mid = low + Math.floor((high - low) / 2)

Calculating mid as low + Math.floor((high - low) / 2) prevents overflow when low and high are large.

What is the best description of the binary search algorithm?

A Divide and conquer by halving the search space

B Linear search through all elements

C Randomly pick elements until found

D Sort the array then search linearly

Binary search uses divide and conquer by halving the search space each step.

Explain how the iterative binary search algorithm works step-by-step.

Think about how you cut the search space in half each time.

Describe why binary search is faster than linear search on sorted arrays.

Focus on how many elements you check in each method.

Practice

1. What is the main purpose of the binary search iterative approach in a sorted array?

easy

A. To reverse the array elements

B. To find the position of a target value efficiently by repeatedly dividing the search interval in half

C. To sort the array elements in ascending order

D. To find the maximum value in the array

Solution

1. Step 1: Understand binary search goal

   Binary search aims to find a target value's position quickly in a sorted array by dividing the search space repeatedly.

2. Step 2: Identify the iterative approach

   The iterative method uses a loop to narrow down the search range until the target is found or the range is empty.

3. Final Answer:

   To find the position of a target value efficiently by repeatedly dividing the search interval in half -> Option B

4. Quick Check:

   Binary search = efficient position search [OK]

Hint: Binary search halves the search space each step [OK]

Common Mistakes:

• Confusing binary search with sorting algorithms
• Thinking it works on unsorted arrays
• Assuming it finds maximum or minimum values

2. Which of the following is the correct way to initialize the mid index in an iterative binary search in JavaScript?

easy

A. const mid = Math.ceil((start + end) / 2);

B. const mid = (start + end) / 2;

C. const mid = Math.floor((start + end) / 2);

D. const mid = start + end;

Solution

1. Step 1: Understand index calculation

   Mid index must be an integer index, so we use Math.floor to round down the average of start and end.

2. Step 2: Check options for correct syntax

   const mid = Math.floor((start + end) / 2); uses Math.floor((start + end) / 2), which correctly calculates the middle index as an integer.

3. Final Answer:

   const mid = Math.floor((start + end) / 2); -> Option C

4. Quick Check:

   Mid index = Math.floor average [OK]

Hint: Use Math.floor to get integer mid index [OK]

Common Mistakes:

• Using division without floor, resulting in float index
• Using Math.ceil which can cause out-of-range index
• Adding start and end without division

3. What will be the output of the following JavaScript code?

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

console.log(binarySearch([2, 4, 6, 8, 10], 6));

medium

A. 2

B. 3

C. -1

D. 4

Solution

1. Step 1: Trace the binary search steps

   Array is [2,4,6,8,10], target is 6. Initial start=0, end=4, mid=2. arr[2] = 6 matches target.

2. Step 2: Return index when found

   Since arr[mid] equals target, function returns mid = 2 immediately.

3. Final Answer:

   2 -> Option A

4. Quick Check:

   Target 6 found at index 2 [OK]

Hint: Check mid index value first for quick match [OK]

Common Mistakes:

• Confusing index with value
• Off-by-one errors in start/end updates
• Returning value instead of index

4. Identify the bug in the following iterative binary search code snippet:

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

medium

A. The loop condition should be start <= end instead of start < end

B. The mid calculation should use Math.ceil instead of Math.floor

C. The function should return arr[mid] instead of mid

D. The start should be initialized to 1 instead of 0

Solution

1. Step 1: Analyze loop condition impact

   The loop uses start < end, which misses the case when start equals end, possibly skipping the last element check.

2. Step 2: Correct loop condition for full search

   Changing to start <= end ensures the loop checks all elements including when start equals end.

3. Final Answer:

   The loop condition should be start <= end instead of start < end -> Option A

4. Quick Check:

   Loop condition must include equality [OK]

Hint: Use <= to include last element in search [OK]

Common Mistakes:

• Using < excludes last element check
• Changing mid calculation unnecessarily
• Returning value instead of index

5. Given a sorted array with possible duplicate values, how can you modify the iterative binary search to find the first occurrence of a target value?

function binarySearchFirst(arr, target) {
  let start = 0;
  let end = arr.length - 1;
  let result = -1;
  while (start <= end) {
    const mid = Math.floor((start + end) / 2);
    if (arr[mid] === target) {
      result = mid;
      end = mid - 1; // Continue searching left
    } else if (arr[mid] < target) {
      start = mid + 1;
    } else {
      end = mid - 1;
    }
  }
  return result;
}

hard

A. Search right side by moving start to mid + 1 when target is found

B. Return immediately when target is found at mid

C. Change mid calculation to use Math.ceil instead of Math.floor

D. Keep track of found index and continue searching left by moving end to mid - 1

Solution

1. Step 1: Understand duplicate handling

   To find first occurrence, we must not stop at first match but continue searching left side.

2. Step 2: Use result variable and adjust end pointer

   Store current match index in result, then move end to mid - 1 to search left side for earlier occurrence.

3. Final Answer:

   Keep track of found index and continue searching left by moving end to mid - 1 -> Option D

4. Quick Check:

   Track index + search left for first occurrence [OK]

Hint: On match, move left to find first occurrence [OK]

Common Mistakes:

• Stopping search immediately on first match
• Searching right side instead of left
• Ignoring duplicates in binary search