Binary Search Iterative Approach in DSA Javascript - Execution Trace

Concept Flow - Binary Search Iterative Approach

Start with sorted array and target

↓

Set low = 0, high = array.length - 1

↓

While low <= high

↓

Calculate mid = (low + high) // 2

↓

Compare array[mid

↓

Equal

↓

Return mid

↓

Repeat loop

↓

If not found return -1

Start with low and high pointers on the sorted array. Repeatedly check the middle element. If it matches target, return index. If middle is less, search right half. If more, search left half. Stop when low passes high.

Execution Sample

DSA Javascript

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

This code searches for target in a sorted array using an iterative binary search.

Execution Table

Step	Operation	low	high	mid	arr[mid]	Comparison	Action	Visual State
1	Initialize pointers	0	6	-	-	-	Start search	[1, 3, 5, 7, 9, 11, 13]
2	Calculate mid	0	6	3	7	7 < 9?	low = mid + 1 = 4	[1, 3, 5, 7, 9, 11, 13]
3	Calculate mid	4	6	5	11	11 > 9?	high = mid - 1 = 4	[1, 3, 5, 7, 9, 11, 13]
4	Calculate mid	4	4	4	9	9 == 9?	Return 4	[1, 3, 5, 7, 9, 11, 13]

💡 Found target 9 at index 4, search ends.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
low	0	4	4	4	4
high	6	6	4	4	4
mid	-	3	5	4	4
arr[mid]	-	7	11	9	9

Key Moments - 3 Insights

Why do we update low to mid + 1 when arr[mid] is less than target?

Because arr[mid] is smaller than target, the target must be in the right half, so we move low just after mid to avoid rechecking mid again. See execution_table row 2.

Why does the loop stop when low > high?

When low passes high, it means the search space is empty and target is not found. The loop condition low <= high ensures we only search valid parts. This is shown by the loop condition in the code and the exit condition.

Why do we calculate mid as Math.floor((low + high) / 2)?

To find the middle index between low and high, we average them and round down to get a valid array index. This is shown in each step of the execution_table where mid is calculated.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of mid at Step 3?

A 3

B 5

C 4

D 6

💡 Hint

Check the 'mid' column in execution_table row 3.

At which step does the condition low <= high become false, ending the loop?

A Step 4

B Step 3

C After Step 4 (loop exit)

D Step 2

💡 Hint

The loop ends after returning the target index at Step 4, so condition fails after that.

If the target was 12 instead of 9, what would happen to the 'high' pointer at Step 3?

A high would become 5

B high would become 6

C high would become 4

D high would not change

💡 Hint

At Step 3, arr[mid]=11 < 12, so low = mid + 1 and high does not change.

Concept Snapshot

Binary Search Iterative Approach:
- Works on sorted arrays
- Use two pointers: low and high
- Calculate mid = floor((low + high)/2)
- Compare arr[mid] with target
- If equal, return mid
- If arr[mid] < target, move low to mid+1
- Else move high to mid-1
- Stop when low > high (target not found)

Full Transcript

Binary Search Iterative Approach starts with two pointers low and high at the start and end of a sorted array. We calculate the middle index mid and compare the middle element with the target. If they match, we return the mid index. If the middle element is less than the target, we move the low pointer to mid + 1 to search the right half. If it is greater, we move the high pointer to mid - 1 to search the left half. This process repeats until low passes high, meaning the target is not found. The code uses a while loop to perform this search efficiently in logarithmic time.

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