Binary Search vs Linear Search Real Cost Difference in DSA C++ - Build Both Approaches

Binary Search vs Linear Search Real Cost Difference

📖 Scenario: You work in a library where you need to find books by their ID numbers. You want to compare two ways to find a book: looking one by one (linear search) and jumping to the middle and cutting the search area in half each time (binary search). This helps you understand which way is faster when the list is sorted.

🎯 Goal: You will create a list of book IDs, set a target book ID to find, write code to search for the book using both linear and binary search, and then print the number of steps each search took. This shows the real cost difference between the two methods.

📋 What You'll Learn

Create a sorted list of book IDs called book_ids with these exact values: 101, 203, 305, 407, 509, 611, 713, 815, 917, 1020

Create an integer variable called target_id and set it to 713

Write a linear search loop using for with iterator i to find target_id in book_ids and count steps in linear_steps

Write a binary search loop using while with variables left, right, and mid to find target_id in book_ids and count steps in binary_steps

Print the number of steps taken by linear search and binary search exactly as: Linear search steps: X and Binary search steps: Y

💡 Why This Matters

🌍 Real World

Searching sorted lists quickly is important in many applications like libraries, databases, and online stores.

💼 Career

Understanding search algorithms helps in optimizing software performance and is a common topic in coding interviews.

1

Create the list of book IDs

Create a sorted list of integers called book_ids with these exact values: 101, 203, 305, 407, 509, 611, 713, 815, 917, 1020

DSA C++

# Create the sorted list book_ids with the given values
# Your code here

Hint

Use an array of integers with the exact values in order.

2

Set the target book ID

Create an integer variable called target_id and set it to 713

DSA C++

int book_ids[] = {101, 203, 305, 407, 509, 611, 713, 815, 917, 1020};
// Set target_id to 713
# Your code here

Hint

Use a simple integer variable assignment.

3

Write linear search to count steps

Write a for loop with iterator i to search target_id in book_ids and count steps in linear_steps. Stop the loop when found.

DSA C++

int book_ids[] = {101, 203, 305, 407, 509, 611, 713, 815, 917, 1020};
int target_id = 713;
int linear_steps = 0;
// Write a for loop with i to find target_id and count steps in linear_steps
# Your code here

Hint

Loop through the array, increase steps, and stop when found.

4

Write binary search and print steps

Write a while loop using left, right, and mid to find target_id in book_ids and count steps in binary_steps. Then print the steps exactly as: Linear search steps: X and Binary search steps: Y

DSA C++

int book_ids[] = {101, 203, 305, 407, 509, 611, 713, 815, 917, 1020};
int target_id = 713;
int linear_steps = 0;
for (int i = 0; i < 10; i++) {
    linear_steps++;
    if (book_ids[i] == target_id) {
        break;
    }
}
int binary_steps = 0;
// Write binary search loop to find target_id and count steps in binary_steps
// Then print the steps as required
# Your code here

Hint

Use binary search logic and count each step. Then print the counts exactly.

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