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

Binary Search vs Linear Search Real Cost Difference

📖 Scenario: Imagine you have a list of product prices in a store. You want to find if a certain price exists in the list. There are two ways to search: checking each price one by one (linear search) or using a faster method if the list is sorted (binary search).

🎯 Goal: You will create a list of prices, set a target price to find, write both linear and binary search functions, and then print the results showing which method found the price and how many steps each took.

📋 What You'll Learn

Create an array called prices with these exact numbers: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

Create a variable called targetPrice and set it to 70

Write a function called linearSearch that takes prices and targetPrice and returns an object with found (boolean) and steps (number of checks)

Write a function called binarySearch that takes prices and targetPrice and returns an object with found (boolean) and steps (number of checks)

Print the results of both searches showing if the price was found and how many steps each took

💡 Why This Matters

🌍 Real World

Searching for items quickly in sorted lists like product prices, names, or IDs is common in apps and websites.

💼 Career

Understanding search algorithms helps in optimizing software performance and making user experiences faster.

1

Create the price list

Create an array called prices with these exact numbers: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

DSA Typescript

// Create the array prices with the given numbers
// Your code here

Hint

Use const prices = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100];

2

Set the target price

Create a variable called targetPrice and set it to 70

DSA Typescript

const prices = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100];
// Create targetPrice and set it to 70
// Your code here

Hint

Use const targetPrice = 70;

3

Write linear search function

Write a function called linearSearch that takes prices and targetPrice and returns an object with found (boolean) and steps (number of checks). Use a for loop with variable i to check each price.

DSA Typescript

const prices = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100];
const targetPrice = 70;
// Write linearSearch function below
// Your code here

Hint

Use a for loop to check each price. Increase steps each time you check.

4

Write binary search function and print results

Write a function called binarySearch that takes prices and targetPrice and returns an object with found (boolean) and steps (number of checks). Use variables left, right, and mid to search. Then print the results of both linearSearch and binarySearch showing if the price was found and how many steps each took.

DSA Typescript

const prices = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100];
const targetPrice = 70;

function linearSearch(prices: number[], targetPrice: number): { found: boolean; steps: number } {
    let steps = 0;
    for (let i = 0; i < prices.length; i++) {
        steps++;
        if (prices[i] === targetPrice) {
            return { found: true, steps };
        }
    }
    return { found: false, steps };
}

// Write binarySearch function and print results below
// Your code here

Hint

Use a while loop with left, right, and mid to find the target. Count steps each check. Then print results using console.log.

Practice

1. Which search algorithm is generally faster on a sorted list of 1,000,000 elements?

easy

A. Linear Search

B. Both are equally fast

C. Binary Search

D. Neither works on sorted lists

Solution

1. Step 1: Understand the search algorithms

   Binary Search divides the list in half repeatedly, while Linear Search checks each element one by one.

2. Step 2: Compare efficiency on large sorted lists

   Binary Search takes about log2(1,000,000) ≈ 20 steps, Linear Search takes up to 1,000,000 steps.

3. Final Answer:

   Binary Search -> Option C

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 requirements
• Ignoring the difference in step counts

2. Which of the following is the correct TypeScript syntax to perform a linear search on an array arr for a value target?

easy

A. arr.findIndex(target);

B. for (let i = 0; i < arr.length; i++) { if (arr[i] === target) return i; }

C. while (arr.includes(target)) { return arr.indexOf(target); }

D. for (let i in arr) { if (arr[i] == target) return i; }

Solution

1. Step 1: Check syntax for linear search loop

   for (let i = 0; i < arr.length; i++) { if (arr[i] === target) return i; } uses a for loop with index and compares each element to target correctly.

2. Step 2: Analyze other options for correctness

   while (arr.includes(target)) { return arr.indexOf(target); } misuses while with includes; arr.findIndex(target); uses findIndex incorrectly; for (let i in arr) { if (arr[i] == target) return i; } uses 'in' which iterates keys but with loose equality.

3. Final Answer:

   for (let i = 0; i < arr.length; i++) { if (arr[i] === target) return i; } -> Option B

4. Quick Check:

   Correct for loop syntax for linear search [OK]

Hint: Use for loop with strict equality for linear search [OK]

Common Mistakes:

• Using while loop incorrectly
• Using loose equality (==) instead of strict (===)
• Misusing array methods for search

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

const arr = [1, 3, 5, 7, 9];
function binarySearch(array: number[], target: number): number {
  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));

medium

A. 3

B. 2

C. -1

D. 4

Solution

1. Step 1: Trace binary search steps for target 7

   Initial left=0, right=4, mid=2 (value 5). 5 < 7, so left=3.

2. Step 2: Next iteration mid=3 (value 7), matches target, return 3

   The function returns index 3 where 7 is found.

3. Final Answer:

   3 -> Option A

4. Quick Check:

   Index of 7 in array is 3 [OK]

Hint: Calculate mid index and compare stepwise [OK]

Common Mistakes:

• Confusing mid calculation
• Returning wrong index
• Not updating left/right correctly

4. Identify the bug in this linear search function and select the fix:

function linearSearch(arr: number[], target: number): number {
  for (let i = 0; i <= arr.length; i++) {
    if (arr[i] === target) return i;
  }
  return -1;
}

medium

A. Change loop condition to i < arr.length

B. Change === to == in if condition

C. Add a break after return statement

D. Initialize i to 1 instead of 0

Solution

1. Step 1: Analyze loop condition

   The loop runs while i <= arr.length, which causes out-of-bounds access at i = arr.length.

2. Step 2: Fix loop condition to prevent error

   Changing to i < arr.length ensures valid indices only.

3. Final Answer:

   Change loop condition to i < arr.length -> Option A

4. Quick Check:

   Loop must stay within array bounds [OK]

Hint: Use i < arr.length to avoid out-of-bounds [OK]

Common Mistakes:

• Using <= instead of < in loop
• Changing equality operator unnecessarily
• Adding break after return (unreachable code)

5. You have a sorted array of 10,000 elements and want to find a target value. Which approach minimizes the average number of comparisons, and why?

Options:
A) Use Linear Search because it checks elements sequentially.
B) Use Linear Search but start from the middle.
C) Use Binary Search but only check every other element.
D) Use Binary Search because it divides the search space each step.

hard

A. Use Linear Search because it checks elements sequentially.

B. Use Linear Search but start from the middle.

C. Use Binary Search but only check every other element.

D. Use Binary Search because it divides the search space each step.

Solution

1. Step 1: Understand average comparisons for Linear vs Binary Search

   Linear Search averages about n/2 = 5,000 comparisons; Binary Search averages about log2(10,000) ≈ 14 comparisons.

2. Step 2: Evaluate options for efficiency

   Binary Search halves search space each step, minimizing comparisons. Starting Linear Search from middle or skipping elements breaks correctness or efficiency.

3. Final Answer:

   Use Binary Search because it divides the search space each step. -> Option D

4. Quick Check:

   Binary Search minimizes comparisons on sorted arrays [OK]

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

Common Mistakes:

• Thinking linear search is faster on sorted arrays
• Starting linear search from middle doesn't help
• Skipping elements in binary search breaks correctness