Analysis

Week 1, Wednesday

January 7, 2026

Announcements

• Labs begin next week.

From Monday

Algorithm Analysis

1. Correctness — Does it work?
2. Efficiency — How long? How much memory?

“This week: efficiency. Next week: proving correctness.”

The Shazam Lesson – Fin

Naive search: “Linear” — too slow

Hash lookup: “Constant” — instant

Database size	Linear search	Hash lookup
1,000	1 sec	0.001 sec
1,000,000	1000 sec	0.001 sec
100,000,000	27 hours	0.001 sec

“Today: How do we figure out which is which?”

How does Shazam actually work?

“Hash table lookup doesn’t depend on the size of the database.”

O(1) — constant time.

“We’ll learn how in Week 5.”

Speed matters in surprising places

It’s not just Shazam!

YouTube

800 million videos

Every search: < 0.5 sec

Linear search would take hours

Genomics

Human genome: 3 billion base pairs

Finding a gene sequence

Naive: days → Real tools: seconds

Pandemic response

330 million people

Contact tracing within 2 connections

Relationships grow exponentially

As data grows, bad algorithms become impossible.

Analysis

Measuring the value of algorithms

Suppose you have two correct algorithms that solve the same problem — which is better?

• Use different metrics — time, space most common
• Express ________ as a (positive) function:

 

 

• Form of function depends on structure of the algorithm:

“time” and “space” are the two main metrics.

“Express WHAT as a function?” → Let them say “running time” or “work”

We’ll write T(n) — running time as a function of input size n.

Intro to Analysis

0	1	2	3	4	5	6	7	…	99,999,999
🎵	🎵	🎵	🎵	🎵	🎵	🎵	🎵	…	🎵

• Do you have any questions about the Python?

• How long does it take to run (in seconds)?

“Is this correct?” (Yes)

“Is this efficient?” (Let’s see…)

“How long does it take?”

What might determine the running time?

0	1	2	3	4	5	6	7	…	99,999,999
🎵	🎵	🎵	🎵	🎵	🎵	🎵	🎵	…	🎵

What factors affect how long find_song_naive takes?

They’ll say: “It depends!”

“What does it depend on?”

Let them generate: size of database, where the song is, machine speed…

Guide to: we care about SIZE. That’s the input to our algorithm.

Discussion results…

Machine speed

A faster computer runs the same code faster.

But that’s not about the algorithm.

Location of song

At the front? Quick!

At the end? Slow.

Not there at all? Slowest.

Size of database

100 songs vs 100 million songs

This is the big one.

We want to characterize the algorithm, not the machine or our luck.

“Which should we focus on for algorithm analysis?”

Machine speed varies (not about the algorithm). Location varies (best case vs worst case). Size is the INPUT.

“We parameterize by n.”

write T(n) running time on input of size n.  T(n) is a function!

Aside for Cases

• Best case: minimum running time over all inputs
• Worst case: maximum running time over all inputs
• Average case: expected running time (needs probability)

“The answer depends on the input!”

Best case: 1 Worst case: n Average case: (1+2+…+n)/n = (n+1)/2 ≈ n/2

“Which should we report?”

we will do worst case, almost always.

Back to \(T(n)\)

• What’s a good name?

• What’s a good expression for running time? \(T(n) =\)

What construct do we have that characterizes functions in a way that ignores constants?

“Does the 2 matter?”

At n = 1,000,000: 2n ≈ n. Constants are noise.

The SHAPE matters: linear.

what construct do we have that characterizes functions in a way that ignores constants?

The Definition of Big-O

\(f(n)\) is \(O(g(n))\) if there exist constants \(c > 0\) and \(n_0 \geq 0\) such that:

\[f(n) \leq c \cdot g(n) \quad \text{for all } n \geq n_0\]

“In words: f grows no faster than g, once n is big enough.”

Other Definitions

\(f(n)\) is \(O(g(n))\) if there exist constants \(c > 0\) and \(n_0 \geq 0\) such that:

\[f(n) \leq c \cdot g(n) \quad \text{for all } n \geq n_0\]

\(f(n)\) is \(\Omega(g(n))\) if there exist constants \(c > 0\) and \(n_0 \geq 0\) such that:

\[f(n) \geq c \cdot g(n) \quad \text{for all } n \geq n_0\]

\(f(n)\) is \(\Theta(g(n))\) iff it is both \(O(g(n))\) and \(\Omega(g(n))\).

“We mostly use O, though we usually mean Θ.”

Example 1

• Python questions?
• What’s the Big-O?

One pass through the array. \(O(n)\).

“We’ll see this again Monday with pandas.”

Example 2

For \(n = 6\):

• What are the values of i and j for the 17th element counted?

• What are the values of i and j for the 32nd element counted?

• What’s the Big-O?

Let them trace: 16

“Predict for n = 8?” (64)

Double n → QUADRUPLE the work. QUADRATIC. \(O(n^2)\)

Example 3

For \(n = 6\):

• What are the values of i and j for the 4th element counted?

• What are the values of i and j for the 12th element counted?

• What’s the Big-O?

i=0: 0. i=1: 1. i=2: 2. i=3: 3. i=4: 4. Total: 10.

\(0 + 1 + 2 + \ldots + (n-1) = \frac{n(n-1)}{2}\)

Still quadratic! \(O(n^2)\)

The Triangle Sum

\[1 + 2 + 3 + \ldots + n = \frac{n(n+1)}{2}\]

“This is \(O(n^2)\), not \(O(n)\).”

Whenever you see “all pairs” — expect quadratic.

Next week

More analysis