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

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Linear Search on Sorted Array

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

DSA Go

package main
import "fmt"
func linearSearch(arr []int, target int) int {
    for i, v := range arr {
        if v == target {
            return i
        }
    }
    return -1
}
func main() {
    arr := []int{1, 3, 5, 7, 9, 11}
    index := linearSearch(arr, 7)
    fmt.Println(index)
}

A 4

B 2

C -1

D 3

💡 Hint

Linear search returns the index of the first matching element.

The value 7 is at index 3 in the array. Linear search checks each element from the start until it finds 7.

❓ Predict Output

intermediate

Output of Binary Search on Sorted Array

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

DSA Go

package main
import "fmt"
func binarySearch(arr []int, target int) int {
    low, high := 0, len(arr)-1
    for low <= high {
        mid := (low + high) / 2
        if arr[mid] == target {
            return mid
        } else if arr[mid] < target {
            low = mid + 1
        } else {
            high = mid - 1
        }
    }
    return -1
}
func main() {
    arr := []int{1, 3, 5, 7, 9, 11}
    index := binarySearch(arr, 7)
    fmt.Println(index)
}

A 3

B 2

C -1

D 4

💡 Hint

Binary search divides the array and finds the target efficiently.

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

🧠 Conceptual

advanced

Time Complexity Comparison

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

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

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

C Both linear and binary search are O(n)

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

💡 Hint

Binary search cuts the search space in half each step.

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

🚀 Application

advanced

Choosing Search Method for Unsorted Data

You have a large unsorted list of numbers and need to find if a target number exists. Which search method is best and why?

A Binary search, because it is always faster

B Neither, use a hash table instead

C Linear search, because binary search requires sorted data

D Binary search after sorting the list every time you search

💡 Hint

Binary search needs sorted data to work correctly.

Binary search only works on sorted data. Sorting every time is expensive. Linear search works on unsorted data directly.

🔧 Debug

expert

Bug in Binary Search Implementation

What error does the following Go code produce when searching for 12 in the array? Identify the output or error.

DSA Go

package main
import "fmt"
func binarySearch(arr []int, target int) int {
    low, high := 0, len(arr)-1
    for low <= high {
        mid := (low + high) / 2
        if arr[mid] == target {
            return mid
        } else if arr[mid] < target {
            low = mid + 1
        } else {
            high = mid - 1
        }
    }
    return -1
}
func main() {
    arr := []int{1, 3, 5, 7, 9, 11}
    index := binarySearch(arr, 12)
    fmt.Println(index)
}

A -1

B runtime error: index out of range

C 3

D 0

💡 Hint

Check the initial value of high and array indexing.

The variable high is set to len(arr), which is out of valid index range (max index is len(arr)-1). This causes an index out of range runtime error when mid equals len(arr).

Practice

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

easy

A. Neither works on sorted lists

B. Linear Search

C. Binary Search

D. Both are equally fast

Solution

1. Step 1: Understand the search algorithms

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

2. Step 2: Compare efficiency on large sorted lists

   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 C

4. Quick Check:

   Binary Search is faster on sorted large lists [OK]

Hint: Binary Search halves list; Linear checks all items [OK]

Common Mistakes:

• Thinking Linear Search is faster on sorted lists
• Confusing sorted vs unsorted list requirements
• Assuming both have same speed

2. Which of the following is the correct Go syntax to perform a linear search on a slice named arr for a value target?

easy

A. for i, v := range arr { if v == target { return v } }

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

C. for v in arr { if v == target { return i } }

D. while i < len(arr) { if arr[i] == target { return i } i++ }

Solution

1. Step 1: Review Go loop syntax for slices

   Go uses for loops with index and length or range loops; for v in arr { if v == target { return i } } uses invalid syntax, while i < len(arr) { if arr[i] == target { return i } i++ } uses while which Go does not have.

2. Step 2: Identify correct syntax for linear search

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

3. Final Answer:

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

4. Quick Check:

   Go uses for loops, not while [OK]

Hint: Go uses for loops, not while loops [OK]

Common Mistakes:

• Using Python or other language syntax in Go
• Using while loops which Go does not support
• Incorrect range loop syntax

3. Given the following Go code snippet, what will be printed?

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

func main() {
    arr := []int{3, 5, 7, 9, 11}
    index := linearSearch(arr, 7)
    fmt.Println(index)
}

medium

A. 2

B. 3

C. -1

D. 0

Solution

1. Step 1: Trace the linear search function

   The function checks each element in order: arr[0]=3, arr[1]=5, arr[2]=7 matches target 7.

2. Step 2: Return index of first match

   It returns index 2 immediately when it finds 7.

3. Final Answer:

   2 -> Option A

4. Quick Check:

   7 is at index 2 in arr [OK]

Hint: Linear search returns first matching index [OK]

Common Mistakes:

• Confusing index with value
• Assuming zero-based index is one-based
• Returning -1 incorrectly

4. The following Go code attempts to perform binary search on a sorted slice but does not work correctly. What is the main bug?

func binarySearch(arr []int, target int) int {
    low := 0
    high := len(arr)
    for low <= high {
        mid := (low + high) / 2
        if arr[mid] == target {
            return mid
        } else if arr[mid] < target {
            low = mid + 1
        } else {
            high = mid - 1
        }
    }
    return -1
}

medium

A. low should start at 1 instead of 0

B. mid calculation should use float division

C. The loop condition should be low < high

D. high should be initialized to len(arr) - 1

Solution

1. Step 1: Check initialization of high index

   In Go, slice indices go from 0 to len(arr)-1, so high should be len(arr)-1, not len(arr).

2. Step 2: Understand impact on loop and mid calculation

   Using len(arr) causes out-of-range access when mid equals len(arr), causing runtime error.

3. Final Answer:

   high should be initialized to len(arr) - 1 -> Option D

4. Quick Check:

   Slice max index = len(arr)-1 [OK]

Hint: High index = length minus one for slices [OK]

Common Mistakes:

• Setting high to len(arr) causes out-of-range error
• Using float division for mid index
• Incorrect loop condition

5. You have a sorted slice of 1,000,000 integers and want to find if the number 123456 exists. You can use either linear or binary search. Considering real cost difference, which approach is best and why?

hard

A. Use binary search because it reduces comparisons drastically

B. Use linear search because it is simpler to implement

C. Use linear search because it uses less memory

D. Use binary search only if the slice is unsorted

Solution

1. Step 1: Analyze the data and search requirements

   The slice is sorted, so binary search can be applied efficiently.

2. Step 2: Compare real cost of linear vs binary search

   Linear search may check up to 1,000,000 elements; binary search checks about 20 comparisons, saving time.

3. Final Answer:

   Use binary search because it reduces comparisons drastically -> Option A

4. Quick Check:

   Binary search best for sorted large data [OK]

Hint: Binary search cuts steps to log2(n) [OK]

Common Mistakes:

• Choosing linear search for large sorted data
• Confusing memory use with search speed
• Thinking binary search needs unsorted data