Binary Search Iterative Approach in DSA Javascript - Build from Scratch

Binary Search Iterative Approach

📖 Scenario: You have a sorted list of book IDs in a library system. You want to quickly find if a specific book ID exists in the list using a fast search method.

🎯 Goal: Build a program that uses the iterative binary search method to find a target book ID in a sorted array of book IDs.

📋 What You'll Learn

Create a sorted array called bookIDs with the exact values: [101, 203, 305, 407, 509, 611, 713]

Create a variable called targetID and set it to 407

Write an iterative binary search function called binarySearch that takes arr and target as parameters

Use a while loop with variables left and right to search for targetID in bookIDs

Print the index of targetID if found, or -1 if not found

💡 Why This Matters

🌍 Real World

Binary search is used in many software systems to quickly find data in sorted lists, such as searching for a book in a library database or a contact in a phone book.

💼 Career

Understanding binary search is important for software developers and engineers because it teaches efficient searching techniques and algorithmic thinking, which are often tested in technical interviews.

1

Create the sorted array of book IDs

Create a sorted array called bookIDs with these exact values: [101, 203, 305, 407, 509, 611, 713]

DSA Javascript

// Create the sorted array bookIDs
// Your code here

Hint

Use const to declare the array and include all numbers in order.

2

Set the target book ID to search

Create a variable called targetID and set it to 407

DSA Javascript

const bookIDs = [101, 203, 305, 407, 509, 611, 713];
// Create the targetID variable
// Your code here

Hint

Use const to declare targetID and assign the number 407.

3

Write the iterative binary search function

Write a function called binarySearch that takes parameters arr and target. Inside it, create variables left set to 0 and right set to arr.length - 1. Use a while loop with the condition left <= right. Inside the loop, calculate mid as the floor of (left + right) / 2. If arr[mid] equals target, return mid. If arr[mid] is less than target, set left to mid + 1. Otherwise, set right to mid - 1. After the loop, return -1.

DSA Javascript

const bookIDs = [101, 203, 305, 407, 509, 611, 713];
const targetID = 407;

// Write the binarySearch function below
// Your code here

Hint

Follow the binary search steps carefully inside the while loop.

4

Print the search result

Call the binarySearch function with bookIDs and targetID as arguments. Print the returned index using console.log.

DSA Javascript

const bookIDs = [101, 203, 305, 407, 509, 611, 713];
const targetID = 407;

function binarySearch(arr, target) {
    let left = 0;
    let right = arr.length - 1;
    while (left <= right) {
        let 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;
}

// Print the index of targetID in bookIDs
// Your code here

Hint

Use console.log(binarySearch(bookIDs, targetID)) to print the result.

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