Binary Search vs Linear Search Real Cost Difference in DSA Javascript - Compare & Choose

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Linear Search on an Unsorted Array

What is the output of the following JavaScript code that performs a linear search for the number 7 in an unsorted array?

DSA Javascript

const arr = [3, 1, 4, 7, 5];
function linearSearch(array, target) {
  for (let i = 0; i < array.length; i++) {
    if (array[i] === target) {
      return i;
    }
  }
  return -1;
}
console.log(linearSearch(arr, 7));

A 4

B -1

C 3

D 0

💡 Hint

Remember linear search checks each element until it finds the target.

The function checks each element in order. The number 7 is at index 3 in the array, so it returns 3.

❓ Predict Output

intermediate

Output of Binary Search on a Sorted Array

What is the output of the following JavaScript code that performs a binary search for the number 7 in a sorted array?

DSA Javascript

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

A 4

B -1

C 3

D 5

💡 Hint

Binary search finds the middle element and narrows down the search.

The number 7 is at index 4 in the sorted array, so the binary search returns 4.

🧠 Conceptual

advanced

Why Binary Search Requires a Sorted Array

Why does binary search require the array to be sorted to work correctly?

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

B Because binary search checks every element one by one, so sorting helps speed it up.

C Because binary search uses hashing which requires sorted data.

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

💡 Hint

Think about how binary search decides where to look next.

Binary search compares the target with the middle element and decides to search left or right half. This logic only works if the array is sorted.

❓ Predict Output

advanced

Output of Binary Search on an Unsorted Array

What is the output of the following JavaScript code that performs a binary search for the number 7 in an unsorted array?

DSA Javascript

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

A 2

B -1

C 0

D 3

💡 Hint

Binary search assumes the array is sorted, but here it is not.

Because the array is not sorted, binary search cannot reliably find the target. It returns -1 indicating not found.

🧠 Conceptual

expert

Real Cost Difference Between Linear and Binary Search

Which statement best describes the real cost difference between linear search and binary search when searching for an element in a large sorted array?

A Binary search is always faster because it reduces the search space by half each step, while linear search checks elements one by one.

B Linear search is faster for large arrays because it does not require sorting, unlike binary search.

C Linear search and binary search have the same cost if the target is near the start of the array.

D Binary search has a higher setup cost due to sorting, but once sorted, it is much faster than linear search for repeated searches.

💡 Hint

Consider the cost of sorting and repeated searches.

Binary search requires the array to be sorted, which can be costly initially. However, for repeated searches, binary search is much faster than linear search because it halves the search space each time.

Practice

1. Which search method is generally faster for finding an element in a sorted list of 1,000,000 items?

easy

A. Binary Search

B. Linear Search

C. Both are equally fast

D. Neither works on sorted lists

Solution

1. Step 1: Understand search methods on sorted lists

   Binary Search divides the list repeatedly, reducing search space quickly. Linear Search checks each item one by one.

2. Step 2: Compare efficiency on large sorted lists

   Binary Search runs in about log2(1,000,000) ≈ 20 steps, Linear Search may take up to 1,000,000 steps.

3. Final Answer:

   Binary Search -> Option A

4. Quick Check:

   Binary Search is faster on sorted lists [OK]

Hint: Binary Search halves search space; Linear checks all [OK]

Common Mistakes:

• Thinking Linear Search is faster on sorted lists
• Confusing sorted and unsorted list efficiency
• Ignoring logarithmic speed of Binary Search

2. Which of the following is the correct syntax to start a binary search on a sorted array arr in JavaScript?

easy

A. let mid = (start + end) / 2;

B. let mid = start - end;

C. let mid = start + end;

D. let mid = Math.floor((start + end) / 2);

Solution

1. Step 1: Calculate middle index correctly

   Binary Search finds middle by averaging start and end indices, then flooring to get integer index.

2. Step 2: Check each option for correctness

   let mid = Math.floor((start + end) / 2); uses Math.floor to get integer mid index; others either don't floor or use wrong operations.

3. Final Answer:

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

4. Quick Check:

   Floor average of start and end gives mid [OK]

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

Common Mistakes:

• Not using Math.floor causing float index
• Adding or subtracting indices incorrectly
• Using mid as sum without division

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

const arr = [2, 4, 6, 8, 10];
function linearSearch(array, target) {
  for (let i = 0; i < array.length; i++) {
    if (array[i] === target) return i;
  }
  return -1;
}
console.log(linearSearch(arr, 8));

medium

A. -1

B. 2

C. 3

D. 4

Solution

1. Step 1: Trace the linear search loop

   The function checks each element: arr[0]=2, arr[1]=4, arr[2]=6, arr[3]=8 matches target 8.

2. Step 2: Return index when target found

   At index 3, target 8 is found, so function returns 3.

3. Final Answer:

   3 -> Option C

4. Quick Check:

   Index of 8 in array is 3 [OK]

Hint: Linear search returns index of first match [OK]

Common Mistakes:

• Returning value instead of index
• Off-by-one errors in loop
• Confusing index with element value

4. The following binary search code has a bug. What is the error?

function binarySearch(arr, target) {
  let start = 0;
  let end = arr.length;
  while (start <= end) {
    let 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. end should be initialized to arr.length - 1

B. start should be initialized to 1

C. mid calculation is incorrect

D. Loop condition should be start < end

Solution

1. Step 1: Check initialization of end index

   Array indices go from 0 to arr.length - 1, so end must be arr.length - 1 to avoid out-of-bounds.

2. Step 2: Understand loop condition and mid usage

   With end = arr.length, mid can be arr.length which is invalid index, causing error.

3. Final Answer:

   end should be initialized to arr.length - 1 -> Option A

4. Quick Check:

   Array last index = length - 1 [OK]

Hint: End index must be last valid array index [OK]

Common Mistakes:

• Setting end to arr.length causing index error
• Changing start incorrectly
• Using wrong loop condition

5. You have a sorted array of 1,000,000 numbers and want to find if the number 500,000 exists. Which search method will minimize the average number of comparisons, and why?

hard

A. Linear Search, because it checks elements sequentially

B. Binary Search, because it reduces search space by half each step

C. Linear Search, because it is simpler to implement

D. Binary Search, but only if the array is unsorted

Solution

1. Step 1: Analyze search methods on large sorted arrays

   Linear Search checks elements one by one, averaging 500,000 comparisons for half the array.

2. Step 2: Understand Binary Search efficiency

   Binary Search halves the search space each step, needing about log2(1,000,000) ≈ 20 comparisons.

3. Step 3: Compare average comparisons

   20 comparisons (Binary Search) is much less than 500,000 (Linear Search), so Binary Search is better.

4. Final Answer:

   Binary Search, because it reduces search space by half each step -> Option B

5. Quick Check:

   Binary Search uses log steps, fewer comparisons [OK]

Hint: Binary Search halves search space, fewer checks [OK]

Common Mistakes:

• Choosing Linear Search for sorted arrays
• Ignoring logarithmic speed advantage
• Thinking Binary Search needs sorted array but choosing wrong option