Why Binary Search and What Sorted Order Gives You in DSA Python - Quick Recap

Recall & Review

beginner

What is the main advantage of using binary search over linear search?

Binary search is much faster because it repeatedly divides the search space in half, reducing the number of comparisons needed to find an element in a sorted list.

beginner

Why must the list be sorted to use binary search?

Binary search relies on the list being sorted to decide whether to search the left or right half. Without sorting, this decision cannot be made correctly.

intermediate

What is the time complexity of binary search and why?

The time complexity is O(log n) because the search space is halved with each step, quickly narrowing down the possible locations of the target.

beginner

How does sorted order help in efficient searching?

Sorted order allows algorithms like binary search to eliminate half of the remaining elements at each step, making searching much faster than checking each element one by one.

beginner

What happens if you try to use binary search on an unsorted list?

The binary search will not work correctly and may return wrong results because it assumes the list is sorted to decide which half to search next.

Why do we need a sorted list for binary search?

A To avoid duplicates

B To make the list smaller

C To decide which half of the list to search next

D To increase the list size

Binary search uses the sorted order to know if it should look in the left or right half.

What is the time complexity of binary search?

A O(n)

B O(log n)

C O(n^2)

D O(1)

Binary search cuts the search space in half each time, leading to O(log n) complexity.

What will happen if binary search is used on an unsorted list?

A It may give incorrect results

B It will run faster

C It will sort the list first

D It will always find the element

Binary search assumes sorted order; without it, the search decisions are wrong.

Which of these is NOT a benefit of sorted order?

A Faster insertion at any position

B Easier to find minimum or maximum

C Faster searching

D Ability to use binary search

Insertion in sorted lists can be slower because elements may need to be shifted.

Binary search works by:

A Sorting the list first

B Checking every element one by one

C Randomly picking elements

D Splitting the list into halves and searching the relevant half

Binary search divides the list and searches only the half where the element can be.

Explain why binary search requires a sorted list and how it uses this property to find an element efficiently.

Think about how knowing order helps decide where to look next.

Describe the main difference in performance between linear search and binary search and why this difference exists.

Consider how many elements each method checks in the worst case.

Practice

1. Why is binary search only applicable on a sorted list?

easy

A. Because it divides the search space based on order to find elements quickly

B. Because it can search any list regardless of order

C. Because it uses random guessing to find elements

D. Because it checks every element one by one

Solution

1. Step 1: Understand binary search method

   Binary search works by repeatedly dividing the list into halves and deciding which half to search next based on order.

2. Step 2: Importance of sorted order

   If the list is not sorted, we cannot decide which half to discard, so binary search fails.

3. Final Answer:

   Because it divides the search space based on order to find elements quickly -> Option A

4. Quick Check:

   Binary search needs sorted list = Because it divides the search space based on order to find elements quickly [OK]

Hint: Binary search needs order to skip halves fast [OK]

Common Mistakes:

• Thinking binary search works on unsorted lists
• Confusing binary search with linear search
• Believing binary search guesses randomly

2. Which of the following is the correct syntax to perform binary search using Python's bisect module on a sorted list arr to find position of x?

easy

A. pos = bisect.find(arr, x)

B. pos = bisect.search(arr, x)

C. pos = bisect.bisect_left(arr, x)

D. pos = bisect.index(arr, x)

Solution

1. Step 1: Recall bisect module functions

   The bisect module provides bisect_left to find insertion position for x in sorted arr.

2. Step 2: Check options for correct function

   Only bisect_left is valid; others like search, find, index do not exist in bisect.

3. Final Answer:

   pos = bisect.bisect_left(arr, x) -> Option C

4. Quick Check:

   bisect_left finds position = pos = bisect.bisect_left(arr, x) [OK]

Hint: Use bisect_left for binary search position in Python [OK]

Common Mistakes:

• Using non-existent bisect functions
• Confusing bisect with list methods
• Trying to use bisect on unsorted lists

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

arr = [2, 4, 6, 8, 10]
left, right = 0, len(arr) - 1
x = 6
while left <= right:
    mid = (left + right) // 2
    if arr[mid] == x:
        print(mid)
        break
    elif arr[mid] < x:
        left = mid + 1
    else:
        right = mid - 1
else:
    print(-1)

medium

A. 2

B. 3

C. -1

D. 0

Solution

1. Step 1: Trace binary search steps

   Initial left=0, right=4, mid=2 (value 6). Since arr[mid] == x, print mid=2 and break.

2. Step 2: Confirm output

   The loop breaks after printing 2, so output is 2.

3. Final Answer:

   2 -> Option A

4. Quick Check:

   Index of 6 in arr is 2 [OK]

Hint: Check mid index value equals target to stop [OK]

Common Mistakes:

• Miscomputing mid index
• Confusing index with value
• Forgetting to break loop on find

4. The following code is intended to perform binary search on a sorted list nums to find target. What is the error?

def binary_search(nums, target):
    left, right = 0, len(nums)
    while left <= right:
        mid = (left + right) // 2
        if nums[mid] == target:
            return mid
        elif nums[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

medium

A. left should start from 1 instead of 0

B. right should be initialized as len(nums) - 1

C. mid calculation should be (left - right) // 2

D. The loop condition should be while left < right

Solution

1. Step 1: Check initialization of right pointer

   right is set to len(nums), which is out of index range since list indices go from 0 to len(nums)-1.

2. Step 2: Correct right initialization

   right should be len(nums) - 1 to avoid index error when accessing nums[mid].

3. Final Answer:

   right should be initialized as len(nums) - 1 -> Option B

4. Quick Check:

   Index max = len(nums)-1 [OK]

Hint: Right pointer max index is length minus one [OK]

Common Mistakes:

• Setting right to length causes index error
• Changing left start incorrectly
• Wrong mid calculation formula

5. You have a sorted list of unique integers representing book IDs: books = [101, 203, 305, 407, 509]. You want to find the position to insert a new book ID 400 so the list remains sorted. Which approach correctly finds the insertion index using binary search logic?

hard

A. Use linear search to find first element greater than 400 and insert before it

B. Insert 400 at the end always because list is sorted

C. Insert 400 at index 0 always to keep list sorted

D. Check middle element; if less than 400, move right pointer; else move left pointer until left > right, then insert at left

Solution

1. Step 1: Understand binary search insertion logic

   Binary search narrows down where to insert by comparing middle element with target and adjusting pointers.

2. Step 2: Apply logic to find insertion index

   When left pointer passes right, left is the correct insertion index to keep list sorted.

3. Final Answer:

   Check middle element; if less than 400, move right pointer; else move left pointer until left > right, then insert at left -> Option D

4. Quick Check:

   Binary search insertion index = Check middle element; if less than 400, move right pointer; else move left pointer until left > right, then insert at left [OK]

Hint: Insert at left pointer after binary search ends [OK]

Common Mistakes:

• Inserting at wrong fixed position
• Using linear search instead of binary
• Not updating pointers correctly