Lecture 17 — Searching and Linear Scans

Learning objectives

• Implement and reason about linear search
• State preconditions for search correctness
• Return useful 'not found' information

Case-based lecture: you attempt, we discuss, then we reveal.

The plan

• Four cases: cs-065, cs-066, cs-067, cs-068
• Each: 5-minute attempt → discussion → reveal → prompt
• Worked examples in between — ask anything
• Break mid-lecture · exit question at the end

Key definitions

• Linear scan — visit items one by one until the target or the end; O(n) always, but works on ANY sequence.
• Early exit — stop scanning the moment the answer is known - found it, or proved nothing ahead can match.
• Sentinel value — a reserved answer (-1, None) meaning 'not found'; must be impossible to confuse with a real result.
• Filter — a scan that collects all matches instead of the first - the accumulator list applied to search.
• Precondition — a promise about the input (e.g. 'sorted', 'two runs') that a faster method may rely on.
• Best/worst case — the same algorithm has a cost range; the target's position decides which you get.

Find the First Freeze: scan with early exit

temps = [12, 8, 3, -1, -4, 2]
idx = None
for i, t in enumerate(temps):
    if t <= 0:
        idx = i
        break
print(idx, temps[idx])

Expected: first freeze at index 3 (temperature -1)

Cost: O(n) worst case, but best case O(1) when the freeze is early; early exit is free - take it.

The Course Finder: linear search on an unsorted catalogue

catalogue = [("CS1", "Problem Solving"), ("DS2", "Statistics"), ("CS3", "Systems")]

def find(code):
    for c, title in catalogue:
        if c == code:
            return title
    return "not offered"

print(find("DS2"), find("XX9"))

Expected: Statistics / not offered

Cost: O(n) time, O(1) space; already optimal for unsorted input.

Peak Finding: the first descent marks a peak

a = [1, 3, 8, 4, 2]
peak = None
for i in range(len(a) - 1):
    if a[i] >= a[i + 1]:
        peak = i
        break
if peak is None:
    peak = len(a) - 1
print(a[peak])

Expected: a peak is 8 (at index 2)

Cost: O(n) here; lecture 21 revisits this problem with binary search for O(log n) - a first taste of the same problem having algorithms of different cost.

• **Input:** temps [4, 2, 1, -1, 3], freeze below 0
• **Output:** first freeze on day 4 (index 3); none -> report -1 explicitly
• Solve for the worked instance first. Then ask what would change if one
• number, name, or condition were replaced by something stranger.

Pseudocode, flowchart or Python. State one assumption. Compare with your neighbour at minute 4.

cs-065 — discuss

• What did the deciding quantity turn out to be?
• Which assumption shaped your answer?
• After the solution is revealed, the class spends five minutes on this prompt: **"Which boundary test would you keep if you could keep only one?"**

Instructor: the reveal, the reasoning section and common wrong turns are in the instructor distribution for cs-065 — not embedded in this deck.

• **Input:** courses [(CS1, room 40, cap 30, Tue), (DS1, room 12, cap 60, Wed), (AI, room 41, cap 45, Tue)], cap >= 40, free Tue
• **Output:** [DS1? no - Wed] -> matches: AI only (room cap 45, Tue); DS1 has cap but wrong day
• Solve for the worked instance first. Then ask what would change if one
• number, name, or condition were replaced by something stranger.

Pseudocode, flowchart or Python. State one assumption. Compare with your neighbour at minute 4.

cs-066 — discuss

• What did the deciding quantity turn out to be?
• Which assumption shaped your answer?
• After the solution is revealed, the class spends five minutes on this prompt: **"If this scan ran 10,000 times a day, what would you precompute?"**

Instructor: the reveal, the reasoning section and common wrong turns are in the instructor distribution for cs-066 — not embedded in this deck.

• **Input:** [7, 9, 11, 2, 4, 6] (two sorted runs); minimum is 2
• **Output:** 2 at the run boundary; a plain min() scan works always - the structure allows better
• Solve for the worked instance first. Then ask what would change if one
• number, name, or condition were replaced by something stranger.

Pseudocode, flowchart or Python. State one assumption. Compare with your neighbour at minute 4.

cs-067 — discuss

• What did the deciding quantity turn out to be?
• Which assumption shaped your answer?
• After the solution is revealed, the class spends five minutes on this prompt: **"Which boundary test would you keep if you could keep only one?"**

Instructor: the reveal, the reasoning section and common wrong turns are in the instructor distribution for cs-067 — not embedded in this deck.

• **Input:** [1, 3, 4, 3, 1] -> peak at index 2 (value 4); edge peaks: [5,2] peak at 0; [2,5] peak at 1
• **Output:** returns any one local maximum index; a peak always exists (argument: climb uphill from anywhere)
• Solve for the worked instance first. Then ask what would change if one
• number, name, or condition were replaced by something stranger.

Pseudocode, flowchart or Python. State one assumption. Compare with your neighbour at minute 4.

cs-068 — discuss

• What did the deciding quantity turn out to be?
• Which assumption shaped your answer?
• After the solution is revealed, the class spends five minutes on this prompt: **"If this scan ran 10,000 times a day, what would you precompute?"**

Instructor: the reveal, the reasoning section and common wrong turns are in the instructor distribution for cs-068 — not embedded in this deck.

Common misconceptions

• Returning the loop index 0 as 'not found' - zero is a legitimate position; use None or -1 by spec.
• Breaking early without justification on multi-match scans.
• Assuming linear scan is 'the dumb way' - on unsorted data it is the ONLY way.
• Confusing best case with typical case when reasoning about cost.

Summary & exit question

• Named technique today: Searching and Linear Scans
• Four cases attempted — methods before answers

Exit question (choose one, 60 seconds)

1. Cost of a full scan vs early exit, in words.
2. What precondition made cs-067 fast?
3. Name one search where early exit is wrong.