![Page 1: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/1.jpg)
[320] Complexity + Big OTyler Caraza-Harter
![Page 2: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/2.jpg)
Video Survey Results
78 people filled the survey
87% said they would use it to review (5 said they would skip lecture -- please don't!)
68% said "if I don't understand something during in-person lecture, I would prefer to review the video later than ask a question in person"
Plan: usually record videos for review for now (no guarantees if there are technical difficulties)
But! If people aren't asking many questions during lecture, I'll stop recording videos.
![Page 3: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/3.jpg)
ReviewThe situation where git cannot auto-merge is called a ____________
What is the missing step?
1. nano file.txt
2. ????
3. git commit -m "I changed file.txt"
4. git push
What type does check_output return?
How can you use time.time() to measure an operation that is much faster than calling time.time()?
![Page 4: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/4.jpg)
Complexity and Big O: Reading
Required: Think Python, Appendix B
http://www.greenteapress.com/thinkpython/html/thinkpython022.html (skip B.4)
Optional [math heavy]: http://web.mit.edu/16.070/www/lecture/big_o.pdf
![Page 5: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/5.jpg)
Complexity
![Page 6: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/6.jpg)
Performance vs. Complexity
Things that affect performance (total time to run):
- ????
![Page 7: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/7.jpg)
Performance vs. Complexity
Things that affect performance (total time to run):
- speed of the computer (CPU, etc)
- speed of Python (quality+efficiency of interpretation)
- algorithm: strategy for solving the problem
- input size: how much data do we have?
![Page 8: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/8.jpg)
Things that affect performance (total time to run):
- speed of the computer (CPU, etc)
- speed of Python (quality+efficiency of interpretation)
- algorithm: strategy for solving the problem
- input size: how much data do we have?
Performance vs. Complexity
complexity analysis: how many steps must the algorithm perform, as a function of input size?
![Page 9: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/9.jpg)
algorithm A
algorithm B
Do you prefer A or B?
Which algorithm is better?
fewer stepsis faster
![Page 10: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/10.jpg)
Which algorithm is better?
algorithm A
algorithm B
Do you prefer A or B?
fewer stepsis faster
![Page 11: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/11.jpg)
Which algorithm is better?
algorithm A
algorithm B
crossover point
fewer stepsis faster
![Page 12: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/12.jpg)
Which algorithm is better?
algorithm A
algorithm B
What is the asymptotic behavior of the function?
crossover point
complexity analysis only cares about "big" inputs
you might still reasonably care about this portion!
fewer stepsis faster
![Page 13: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/13.jpg)
Things that affect performance (total time to run):
- speed of the computer (CPU, etc)
- speed of Python (quality+efficiency of interpretation)
- algorithm: strategy for solving the problem
- input size: how much data do we have?
Performance vs. Complexity
complexity analysis: how many steps must the algorithm perform, as a function of input size?
![Page 14: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/14.jpg)
Things that affect performance (total time to run):
- speed of the computer (CPU, etc)
- speed of Python (quality+efficiency of interpretation)
- algorithm: strategy for solving the problem
- input size: how much data do we have?
Performance vs. Complexity
complexity analysis: how many steps must the algorithm perform, as a function of input size?
what is this?
![Page 15: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/15.jpg)
What is a "step"?
![Page 16: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/16.jpg)
A step is any unit of work with bounded execution time (it doesn't keep getting slower with growing input size)
What is a step?
STEPSTEPSTEPSTEP
STEP
STEP
STEP
STEP
input size is length of this list
![Page 17: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/17.jpg)
What is a step?
STEP
STEPSTEP
STEP
STEP
also a validbreakdowninto steps
A step is any unit of work with bounded execution time (it doesn't keep getting slower with growing input size)
![Page 18: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/18.jpg)
What is a step?
STEP
STEPSTEP
STEP
STEP
One line can do a lot, so no reason to have lines and steps be equivalent
A step is any unit of work with bounded execution time (it doesn't keep getting slower with growing input size)
![Page 19: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/19.jpg)
What is a step?
STEP
STEPSTEP
STEP
STEP
Sometimes a single line is not a single step:found = X in L
A step is any unit of work with bounded execution time (it doesn't keep getting slower with growing input size)
![Page 20: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/20.jpg)
What is a step?
STEP
STEP
STEP
STEP
???
A step is any unit of work with bounded execution time (it doesn't keep getting slower with growing input size)
![Page 21: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/21.jpg)
What is a step?
STEP
STEP
STEP
STEP
A step is any unit of work with bounded execution time (it doesn't keep getting slower with growing input size)
![Page 22: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/22.jpg)
STEP
STEP
STEP
???
is this a valid way to identify steps?
What is a step?
A step is any unit of work with bounded execution time (it doesn't keep getting slower with growing input size)
![Page 23: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/23.jpg)
STEP
STEP
STEP
not a "step", because exec time depends
on input size
What is a step?
A step is any unit of work with bounded execution time (it doesn't keep getting slower with growing input size)
![Page 24: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/24.jpg)
Counting Executed Steps
![Page 25: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/25.jpg)
Counting Executed Steps
STEP
STEP
STEP
STEP
How many total steps will execute if len(input_nums) == 10?
A step is any unit of work with bounded execution time (it doesn't keep getting slower with growing input size)
![Page 26: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/26.jpg)
Counting Executed Steps
STEP
STEP
STEP
STEP
For N elements, there will be 2*N+3 steps
1
+ 11
+ 10
+ 1
= 23 steps
A step is any unit of work with bounded execution time (it doesn't keep getting slower with growing input size)
![Page 27: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/27.jpg)
STEPSTEPSTEPSTEP
STEP
STEP
STEP
STEP
Counting Executed Steps
How many total steps will execute if len(input_nums) == 10?
A step is any unit of work with bounded execution time (it doesn't keep getting slower with growing input size)
![Page 28: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/28.jpg)
STEPSTEPSTEPSTEP
STEP
STEP
STEP
STEP
Counting Executed Steps
1+ 1
+ 11+ 10
+ 0 to 10
+ 0 to 10
+ 1
+ 1
For N elements, there will be between 2*N+5 and 4*N+5 steps
A step is any unit of work with bounded execution time (it doesn't keep getting slower with growing input size)
![Page 29: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/29.jpg)
Important: we might not identify steps the same, but our execution counts can at most differ by a constant factor!
can we broadly(but rigorously)
categorize based on this?
Counting Executed Steps
A step is any unit of work with bounded execution time (it doesn't keep getting slower with growing input size)
![Page 30: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/30.jpg)
Oa really big "O"
![Page 31: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/31.jpg)
Big O Notation ("O" is for "order of growth")Goal: categorize functions (and algorithms) by how fast they grow- do not care about scale- do not care about small inputs- care about shape of the curve- strategy: find some multiple of a general function is an upper bound
f(N) == 2N2 + 100is an O(N2) function
![Page 32: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/32.jpg)
Big O Notation ("O" is for "order of growth")
f(N) == 2N2 + 100is an O(N2) function
not because N2
is an upper bound
Goal: categorize functions (and algorithms) by how fast they grow- do not care about scale- do not care about small inputs- care about shape of the curve- strategy: find some multiple of a general function is an upper bound
![Page 33: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/33.jpg)
Big O Notation ("O" is for "order of growth")
crossoverpoint
f(N) == 2N2 + 100is an O(N2) function
not because N2
is an upper bound
because some multiple is an upper bound after some point
Goal: categorize functions (and algorithms) by how fast they grow- do not care about scale- do not care about small inputs- care about shape of the curve- strategy: find some multiple of a general function is an upper bound
![Page 34: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/34.jpg)
Defining Big O
f(N) ≤ C * g(N)If for large N values and some fixed constant C
f(N) ∈ O(g(N))Then
![Page 35: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/35.jpg)
Defining Big O
f(N) ≤ C * g(N)If for large N values and some fixed constant C
f(N) ∈ O(g(N))Then
O(1)
O(N2)O(N3)
...O(N)
O(CN)Sets
f(N)=2*N2Note: if f(N) is in O(N2), then of course f(N) is in O(N3) too. When asked, give the most informative answer.
![Page 36: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/36.jpg)
Defining Big O
f(N) ≤ C * g(N)If for large N values and some fixed constant C
f(N) ∈ O(g(N))Then
100N ∈ O(N2)
2N ∈ O(N)
N2 ∈ O(1000000N)
which onesare true?
![Page 37: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/37.jpg)
Defining Big O
f(N) ≤ C * g(N)If for large N values and some fixed constant C
f(N) ∈ O(g(N))Then
100N ∈ O(N2)
2N ∈ O(N)
N2 ∈ O(1000000N)
![Page 38: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/38.jpg)
Defining Big O
f(N) ≤ C * g(N)If for large N values and some fixed constant C
f(N) ∈ O(g(N))Then
N2+N+1 ∈ O(N2)
N2 ∈ O(N2+N+1)
N5 ∈ O(N4 + N3 + N2 + N)
which onesare true?
![Page 39: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/39.jpg)
Defining Big O
f(N) ≤ C * g(N)If for large N values and some fixed constant C
f(N) ∈ O(g(N))Then
N2+N+1 ∈ O(N2)
N2 ∈ O(N2+N+1)
N5 ∈ O(N4 + N3 + N2 + N)
![Page 40: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/40.jpg)
Defining Big O
f(N) ≤ C * g(N)If for large N values and some fixed constant C
f(N) ∈ O(g(N))Then
N2+N+1 ∈ O(N2)
N2 ∈ O(N2+N+1)
N5 ∈ O(N4 + N3 + N2 + N)
simplify when possible
![Page 41: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/41.jpg)
Defining Big O
f(N) ≤ C * g(N)If for large N values and some fixed constant C
f(N) ∈ O(g(N))Then
We'll let f(N) be the number of steps that someAlgorithm A needs to perform for input size N.
When we say Algorithm A ∈ O(g(N)),we mean that f(N) ∈ O(g(N))
![Page 42: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/42.jpg)
Defining Big O
f(N) ≤ C * g(N)If for large N values and some fixed constant C
f(N) ∈ O(g(N))Then
STEP
STEP
STEP
STEP
For N elements, there will be 2*N+3 steps
2*N+3 ≤ 3 * N[for big N values]
therefore
this code is O(N)
![Page 43: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/43.jpg)
Defining Big O
f(N) ≤ C * g(N)If for large N values and some fixed constant C
f(N) ∈ O(g(N))Then
4*N+5 ≤ 5 * N[for big N values]
therefore
this code is O(N)
STEPSTEP
STEPSTEP
STEP
STEP
STEP
STEP
For N elements, there will be between 2*N+5 and 4*N+5 steps
![Page 44: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/44.jpg)
Examples
![Page 45: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/45.jpg)
Coding/Plotting Example
what is the complexity of each function
![Page 46: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/46.jpg)
Coding/Plotting Example
y=N
actual steps
![Page 47: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/47.jpg)
Coding/Plotting Example
y=N
actual stepsfor simplicity, we'll usually do a
worst-case analysis, under which this would still be O(N)
what if we add a break here?
implications forX in L?
![Page 48: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/48.jpg)
Binary Search: Coding Example
O(1)O(N)O(N log N) O(log N)O(N2)
find_primes
Binary Search
is_prime
binary_search
![Page 49: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/49.jpg)
Binary Search: Coding Example
black: actual steps
![Page 50: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/50.jpg)
Sorting: Coding Examples
O(1)O(N)O(N log N) O(log N)O(N2)
is_primefind_primes
binary_search
merge
merge_sort
selectio
n_sort
![Page 51: [320] Complexity + Big O · 2020-03-11 · Big O Notation ("O" is for "order of growth") f(N) == 2N2 + 100 is an O(N2) function not because N2 is an upper bound Goal: categorize functions](https://reader034.vdocuments.us/reader034/viewer/2022050308/5f70056f8fc900134455589d/html5/thumbnails/51.jpg)
Analysis of Algorithms: Key Ideascomplexity: relationship between input size and steps executed
step: an operation of bounded cost (doesn't scale with input size)asymptotic analysis: we only care about very large N values for complexity (for example, assume a big list)worst-case: we'll usually assume the worst arrangement of data because it's harder to do an average case analysis (for example, assume search target at the end of a list)
big O: if f(N) ≤ C * g(N) for large N values and some fixed constant C, big O: then f(N) ∈ O(g(N))