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

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Linear Search on Sorted Array

What is the output of the following C++ code that performs a linear search for the value 7 in a sorted array?

DSA C++

int linearSearch(int arr[], int n, int x) {
    for (int i = 0; i < n; i++) {
        if (arr[i] == x) return i;
    }
    return -1;
}

int main() {
    int arr[] = {1, 3, 5, 7, 9, 11};
    int n = sizeof(arr) / sizeof(arr[0]);
    int index = linearSearch(arr, n, 7);
    if (index != -1) {
        std::cout << "Found at index " << index << std::endl;
    } else {
        std::cout << "Not found" << std::endl;
    }
    return 0;
}

A Found at index 3

B Found at index 2

C Not found

D Found at index 4

💡 Hint

Remember that array indexing starts at 0 and linear search checks elements one by one.

The value 7 is at the 4th position in the array, which is index 3 (0-based). Linear search finds it and returns index 3.

❓ Predict Output

intermediate

Output of Binary Search on Sorted Array

What is the output of the following C++ code that performs a binary search for the value 7 in a sorted array?

DSA C++

int binarySearch(int arr[], int left, int right, int x) {
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] == x) return mid;
        if (arr[mid] < x) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

int main() {
    int arr[] = {1, 3, 5, 7, 9, 11};
    int n = sizeof(arr) / sizeof(arr[0]);
    int index = binarySearch(arr, 0, n - 1, 7);
    if (index != -1) {
        std::cout << "Found at index " << index << std::endl;
    } else {
        std::cout << "Not found" << std::endl;
    }
    return 0;
}

A Found at index 2

B Found at index 4

C Not found

D Found at index 3

💡 Hint

Binary search divides the search space in half each step.

The value 7 is at index 3. Binary search finds it by checking the middle element and narrowing down the search.

🧠 Conceptual

advanced

Time Complexity Comparison

Which statement correctly compares the time complexity of linear search and binary search on a sorted array of size n?

A Both linear and binary search are O(n)

B Linear search is O(log n), binary search is O(n)

C Linear search is O(n), binary search is O(log n)

D Both linear and binary search are O(log n)

💡 Hint

Think about how many elements each algorithm checks in the worst case.

Linear search checks each element one by one, so it takes O(n). Binary search halves the search space each time, so it takes O(log n).

🚀 Application

advanced

Choosing Search Method for Unsorted Data

You have a large unsorted array and need to find if a value exists. Which search method is best and why?

A Sort the array first then use linear search

B Use linear search because binary search requires sorted data

C Use binary search because it is always faster

D Use binary search without sorting because it works on any array

💡 Hint

Binary search needs sorted data to work correctly.

Binary search only works on sorted arrays. For unsorted data, linear search is the correct choice without extra steps.

🔧 Debug

expert

Why Does This Binary Search Fail?

What error or problem does the following binary search code have when searching for 7 in the array {1, 3, 5, 7, 9, 11}? int binarySearch(int arr[], int left, int right, int x) { while (left < right) { int mid = (left + right) / 2; if (arr[mid] == x) return mid; if (arr[mid] < x) left = mid + 1; else right = mid - 1; } return -1; } int main() { int arr[] = {1, 3, 5, 7, 9, 11}; int n = sizeof(arr) / sizeof(arr[0]); int index = binarySearch(arr, 0, n - 1, 7); if (index != -1) { std::cout << "Found at index " << index << std::endl; } else { std::cout << "Not found" << std::endl; } return 0; }

A It may miss the target because the loop condition excludes right boundary

B It causes an infinite loop due to incorrect mid calculation

C It always returns -1 even if the element is present

D It causes a runtime error due to out-of-bounds access

💡 Hint

Check the loop condition and how it affects the search range.

The loop uses 'while (left < right)', so when left == right, the loop stops without checking that element. This can cause missing the target if it is at the right boundary.

Practice

1. Which search algorithm generally performs faster on a sorted array of 1,000,000 elements?

easy

A. Binary Search

B. Linear Search

C. Both perform equally

D. Depends on the element position only

Solution

1. Step 1: Understand the search algorithms

   Binary Search divides the search space in half each step, while Linear Search checks elements one by one.

2. Step 2: Compare performance on large sorted arrays

   Binary Search takes 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 large arrays [OK]

Hint: Binary Search halves search space, so faster on sorted data [OK]

Common Mistakes:

• Thinking Linear Search is faster because it is simpler
• Ignoring that array must be sorted for Binary Search
• Assuming both have same speed regardless of data size

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

easy

A. int low = 0, high = n - 1;

B. int low = 1, high = n;

C. int low = 0, high = n;

D. int low = 1, high = n - 1;

Solution

1. Step 1: Understand array indexing in C++

   Arrays start at index 0, so first element is at 0 and last at n-1.

2. Step 2: Set binary search boundaries correctly

   Low should be 0 and high should be n-1 to cover entire array.

3. Final Answer:

   int low = 0, high = n - 1; -> Option A

4. Quick Check:

   Array indices start at 0, so low=0 and high=n-1 [OK]

Hint: Array indexing starts at 0, so high = n - 1 [OK]

Common Mistakes:

• Starting low at 1 instead of 0
• Setting high to n instead of n-1
• Confusing 1-based indexing with 0-based

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

int arr[] = {2, 4, 6, 8, 10};
int n = 5;
int target = 6;
int low = 0, high = n - 1;
int steps = 0;
while (low <= high) {
    steps++;
    int mid = low + (high - low) / 2;
    if (arr[mid] == target) {
        break;
    } else if (arr[mid] < target) {
        low = mid + 1;
    } else {
        high = mid - 1;
    }
}
std::cout << steps << std::endl;

medium

A. 3

B. 2

C. 4

D. 1

Solution

1. Step 1: Trace first iteration

   low=0, high=4, mid=2, arr[2]=6 equals target, steps=1, loop breaks immediately.

2. Step 2: Confirm steps count

   Steps incremented once before break, so output is 1.

3. Final Answer:

   1 -> Option D

4. Quick Check:

   Target found at first mid check, steps = 1 [OK]

Hint: Binary Search finds target quickly, count mid checks [OK]

Common Mistakes:

• Counting steps after break incorrectly
• Miscomputing mid index
• Assuming more iterations needed when target is mid

4. Identify the error in the following linear search code snippet and choose the correct fix:

int linearSearch(int arr[], int n, int target) {
    for (int i = 1; i <= n; i++) {
        if (arr[i] == target) {
            return i;
        }
    }
    return -1;
}

medium

A. Change return i to return i + 1

B. Change loop to for (int i = 0; i < n; i++)

C. Change loop to for (int i = 1; i < n; i++)

D. No error, code is correct

Solution

1. Step 1: Analyze array indexing

   Arrays in C++ start at 0, but loop starts at 1 and goes to n, causing out-of-bounds access.

2. Step 2: Fix loop boundaries

   Loop should start at 0 and run while i < n to cover all elements safely.

3. Final Answer:

   Change loop to for (int i = 0; i < n; i++) -> Option B

4. Quick Check:

   Array indexing starts at 0, loop must reflect that [OK]

Hint: Array indices start at 0, loop from 0 to n-1 [OK]

Common Mistakes:

• Starting loop at 1 causing skip of first element
• Using <= n causing out-of-bounds access
• Assuming array indexing starts at 1

5. You have a sorted array of 1,000 elements and want to find if the number 500 exists. Which search method is more cost-effective considering average case and why?

hard

A. Linear Search, because it uses less memory

B. Linear Search, because it checks elements sequentially

C. Binary Search, because it reduces search space exponentially

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

Solution

1. Step 1: Consider array sortedness and search methods

   Binary Search requires sorted array and halves search space each step; Linear Search checks each element one by one.

2. Step 2: Compare average case cost

   Binary Search takes about log2(1000) ≈ 10 steps; Linear Search takes on average 500 steps.

3. Final Answer:

   Binary Search, because it reduces search space exponentially -> Option C

4. Quick Check:

   Sorted array + binary search = faster average search [OK]

Hint: Use Binary Search on sorted arrays for faster average search [OK]

Common Mistakes:

• Choosing Linear Search for sorted arrays
• Confusing memory use with search speed
• Thinking Binary Search works on unsorted arrays