Data Structures and Algorithms

CS245-2015S-02
Algorithm Analysis
David Galles

Department of Computer Science

University of San Francisco
02-0: Algorithm Analysis
When is algorithm A better than algorithm B?
02-1: Algorithm Analysis
When is algorithm A better than algorithm B?

Algorithm A runs faster

02-2: Algorithm Analysis
When is algorithm A better than algorithm B?

Algorithm A runs faster

Algorithm A requires less space to run
02-3: Algorithm Analysis
When is algorithm A better than algorithm B?

Algorithm A runs faster

Algorithm A requires less space to run

Space / Time Trade-off

Can often create an algorithm that runs faster, by

using more space

For now, we will concentrate on time efficiency

02-4: Best Case vs. Worst Case
How long does the following function take to run:
boolean find(int A[], int element) {
for (i=0; i<A.length; i++) {
if (A[i] == elem)
return true;
}
return false;
}
02-5: Best Case vs. Worst Case
How long does the following function take to run:
boolean find(int A[], int element) {
for (i=0; i<A.length; i++) {
if (A[i] == elem)
return true;
}
return false;
}
It depends on if and where the element is in the list
02-6: Best Case vs. Worst Case
Best Case What is the fastest that the algorithm
can run
Worst Case What is the slowest that the
algorithm can run
Average Case How long, on average, does the
algorithm take to run

Worst Case performance is almost always important.

Usually, Best Case performance is unimportant (why?)
Usually, Average Case = Worst Case (but not always!)
02-7: Measuring Time Efficiency
How long does an algorithm take to run?
02-8: Measuring Time Efficiency
How long does an algorithm take to run?

Implement on a computer, time using a stopwatch.

02-9: Measuring Time Efficiency
How long does an algorithm take to run?

Implement on a computer, time using a stopwatch.

Problems:
Not just testing algorithm testing
implementation of algorithm
Implementation details (cache performance,
other programs running in the background, etc)
can affect results
Hard to compare algorithms that are not tested
under exactly the same conditions
02-10: Measuring Time Efficiency
How long does an algorithm take to run?

Implement on a computer, time using a stopwatch.

Problems:
Not just testing algorithm testing
implementation of algorithm
Implementation details (cache performance,
other programs running in the background, etc)
can affect results
Hard to compare algorithms that are not tested
under exactly the same conditions
Better Method: Build a mathematical model of the
running time, use model to compare algorithms
02-11: Competing Algorithms
Linear Search
for (i=low; i <= high; i++)
if (A[i] == elem) return true;
return false;
Binary Search
int BinarySearch(int low, int high, elem) {
if (low > high) return false;
mid = (high + low) / 2;
if (A[mid] == elem) return true;
if (A[mid] < elem)
return BinarySearch(mid+1, high, elem);
else
return BinarySearch(low, mid-1, elem);
}
02-12: Linear vs Binary
Linear Search

for (i=low; i <= high; i++)

if (A[i] == elem) return true;
return false;

Time Required, for a problem of size n (worst

case):
02-13: Linear vs Binary
Linear Search

for (i=low; i <= high; i++)

if (A[i] == elem) return true;
return false;

Time Required, for a problem of size n (worst

case):
c1 n for some constant c1
02-14: Linear vs Binary
Binary Search

int BinarySearch(int low, int high, elem) {

if (low > high) return false;
mid = (high + low) / 2;
if (A[mid] == elem) return true;
if (A[mid] < elem)
return BinarySearch(mid+1, high, elem);
else
return BinarySearch(low, mid-1, elem);
}

Time Required, for a problem of size n (worst

case):
02-15: Linear vs Binary
Binary Search

int BinarySearch(int low, int high, elem) {

if (low > high) return false;
mid = (high + low) / 2;
if (A[mid] == elem) return true;
if (A[mid] < elem)
return BinarySearch(mid+1, high, elem);
else
return BinarySearch(low, mid-1, elem);
}

Time Required, for a problem of size n (worst

case): c2 lg(n) for some constant c2
02-16: Do Constants Matter?
Linear Search requires time c1 n, for some c1
Binary Search requires time c2 lg(n), for some c2

What if there is a very high overhead cost for function

calls?

What if c2 is 1000 times larger than c1 ?

02-17: Constants Do Not Matter!
Length of list Time Required for Time Required for
Linear Search Binary Search
10 0.001 seconds 0.3 seconds
100 0.01 seconds 0.66 seconds
1000 0.1 seconds 1.0 seconds
10000 1 second 1.3 seconds
100000 10 seconds 1.7 seconds
1000000 2 minutes 2.0 seconds
10000000 17 minutes 2.3 seconds
1010 11 days 3.3 seconds
1015 30 centuries 5.0 seconds
1020 300 million years 6.6 seconds
02-18: Growth Rate
We care about the Growth Rate of a function how
much more we can do if we add more processing
power
Faster Computers = Solving Problems Faster
Faster Computers = Solving Larger Problems

Modeling more variables

Handling bigger databases
Pushing more polygons
02-19: Growth Rate Examples

Size of problem that can be solved

time 10n 5n n lg n n2 n3 2n
1s 1000 2000 1003 100 21 13
2s 2000 4000 1843 141 27 14
20 s 20000 40000 14470 447 58 17
1m 60000 120000 39311 774 84 19
1 hr 3600000 7200000 1736782 18973 331 25
02-20: Constants and Running Times
When calculating a formula for the running time of
an algorithm:
Constants arent as important as the growth
rate of the function
Lower order terms dont have much of an
impact on the growth rate
x3 + x vs x3
Wed like a formal method for describing what is
important when analyzing running time, and what
is not.
02-21: Big-Oh Notation
O(f (n)) is the set of all functions that are bound from
above by f (n)

T (n) O(f (n)) if

c, n0 such that T (n) c f (n) when n > n0

02-22: Big-Oh Examples

n O(n) ? Yes

10n O(n) ? Yes

n O(10n) ? Yes
n O(n2 ) ? Yes

n2 O(n) ? No

10n2 O(n2 ) ? Yes

n lg n O(n2 ) ? Yes

ln n O(2n) ? Yes
lg n O(n) ? Yes

3n + 4 O(n) ? Yes

5n2 + 10n 2 O(n3 )? O(n2 ) ? O(n) ?

Yes Yes No
02-23: Big-Oh Examples

n O(n)
10n O(n)
n O(10n)
n O(n2 )
n2 O(n)
10n2 O(n2 )
n lg n O(n2 )
ln n O(2n)
lg n O(n)
3n + 4 O(n)
5n2 + 10n 2 O(n3 ), O(n2 ), O(n) ?
02-24: Big-Oh Examples II

n O(n) ? Yes
lg n O(2n ) ? Yes
lg n O(n) ? Yes
n lg n O(n) ? No
n lg n O(n2 ) ? Yes

n O(lg n) ? No

lg n O( n) ? Yes
3
n lg n O(n 2 ) ? Yes
3

n + n lg n + n n O(n lg n) ? No
3

n + n lg n + n n O(n3 ) ? Yes

3

n + n lg n + n n O(n4 ) ? Yes
02-25: Big-Oh Examples II

n O(n)
lg n O(2n )
lg n O(n)
n lg n O(n)
n lg n O(n2 )

n O(lg n)

lg n O( n)
3
n lg n O(n 2 )
3

n + n lg n + n n O(n lg n)
3

n + n lg n + n n O(n3 )
3

n + n lg n + n n O(n4 )
02-26: Big-Oh Examples III
!
n for n odd
f (n) =
n3 for n even
g(n) = n2
f (n) O(g(n)) ? No, if f(n) is even, n^3 is not smaller than n^2

g(n) O(f (n)) ? No, if f(n) is odd, n^2 is not smaller than n

n O(f (n)) ? Yes

f (n) O(n3 ) ? Yes

02-27: Big-Oh Examples III
!
n for n odd
f (n) =
n3 for n even
g(n) = n2
f (n) O(g(n))
g(n) O(f (n))
n O(f (n))
f (n) O(n3 )
02-28: Big- Notation
(f (n)) is the set of all functions that are bound from
below by f (n)

T (n) (f (n)) if

c, n0 such that T (n) c f (n) when n > n0

02-29: Big- Notation
(f (n)) is the set of all functions that are bound from
below by f (n)

T (n) (f (n)) if

c, n0 such that T (n) c f (n) when n > n0

f (n) O(g(n)) g(n) (f (n))

02-30: Big- Notation
(f (n)) is the set of all functions that are bound both
above and below by f (n). is a tight bound

T (n) (f (n)) if

T (n) O(f (n)) and T (n) (f (n))

02-31: Big-Oh Rules
1. If f (n) O(g(n)) and g(n) O(h(n)), then
f (n) O(h(n))
2. If f (n) O(kg(n) for any constant k > 0, then
f (n) O(g(n))
3. If f1 (n) O(g1 (n)) and f2 (n) O(g2 (n)), then
f1 (n) + f2 (n) O(max(g1 (n), g2 (n)))
4. If f1 (n) O(g1 (n)) and f2 (n) O(g2 (n)), then
f1 (n) f2 (n) O(g1 (n) g2 (n))
(Also work for , and hence )
02-32: Big-Oh Guidelines
Dont include constants/low order terms in Big-Oh
Simple statements: (1)
Loops: (inside) * # of iterations
Nested loops work the same way
Consecutive statements: Longest Statement
Conditional (if) statements:
O(Test + longest branch)
02-33: Calculating Big-Oh
for (i=1; i<n; i++)
sum++;
02-34: Calculating Big-Oh
for (i=1; i<n; i++) Executed n times
sum++; O(1)

Running time: O(n), (n), (n)

02-35: Calculating Big-Oh
for (i=1; i<n; i=i+2)
sum++;
02-36: Calculating Big-Oh
for (i=1; i<n; i=i+2) Executed n/2 times
sum++; O(1)

Running time: O(n), (n), (n) < Hence, this follows

Note this:
n/2 >= C(n) when C <= 1/2, n0 = 1 for every n >= n0
02-37: Calculating Big-Oh
for (i=1; i<n; i++)
for (j=1; j < n/2; j++)
sum++;
02-38: Calculating Big-Oh
for (i=1; i<n; i++) Executed n times
for (j=1; j < n/2; j++) Executed n/2 times
sum++; O(1)

Running time: O(n2 ), (n2 ), (n2 )

02-39: Calculating Big-Oh
for (i=1; i<n; i=i*2)
sum++;
02-40: Calculating Big-Oh
for (i=1; i<n; i=i*2) Executed lg n times
sum++; O(1)

Running Time: O(lg n), (lg n), (lg n)

02-41: Calculating Big-Oh
for (i=0; i<n; i++)
for (j = 0; j<i; j++)
sum++;
02-42: Calculating Big-Oh
for (i=0; i<n; i++) Executed n times
for (j = 0; j<i; j++) Executed <= n times
sum++; O(1)

Running Time: O(n2 ). Also (n2 ) ? Yes and it is also theta(n^2)

SUPER
IMPORTANT! GOT
TRICK HERE!!
02-43: Calculating Big-Oh
for (i=0; i<n; i++)
for (j = 0; j<i; j++)
sum++;

Exact # of times sum++ is executed:

n
" n(n + 1)
i =
i=1
2
(n2 )
02-44: Calculating Big-Oh
sum = 0;
for (i=0; i<n; i++)
sum++;
for (i=1; i<n; i=i*2)
sum++;
02-45: Calculating Big-Oh
Note this: these 2 operation is separated
sum = 0; O(1)
for (i=0; i<n; i++) Executed n times
sum++; O(1)
for (i=1; i<n; i=i*2) Executed lg n times
sum++; O(1) 1. O(n)
2. O(logn)

Running Time: O(n), (n), (n) Hence, choose the biggest one

O(n)
02-46: Calculating Big-Oh
sum = 0;
for (i=0; i<n; i=i+2)
sum++;
for (i=0; i<n/2; i=i+5)
sum++;
02-47: Calculating Big-Oh
sum = 0; O(1)
for (i=0; i<n; i=i+2) Executed n/2 times
sum++; O(1)
for (i=0; i<n/2; i=i+5) Executed n/10 times
sum++; O(1)

Running Time: O(n), (n), (n)

02-48: Calculating Big-Oh
for (i=0; i<n;i++)
for (j=1; j<n; j=j*2)
for (k=1; k<n; k=k+2)
sum++;
02-49: Calculating Big-Oh
for (i=0; i<n;i++) Executed n times
for (j=1; j<n; j=j*2) Executed lg n times
for (k=1; k<n; k=k+2) Executed n/2 times
sum++; O(1)

Running Time: O(n2 lg n), (n2 lg n), (n2 lg n)

02-50: Calculating Big-Oh
sum = 0;
for (i=1; i<n; i=i*2)
for (j=0; j<n; j++)
sum++;
02-51: Calculating Big-Oh
sum = 0; O(1)
for (i=1; i<n; i=i*2) Executed lg n times
for (j=0; j<n; j++) Executed n times
sum++; O(1)

Running Time: O(n lg n), (n lg n), (n lg n)

02-52: Calculating Big-Oh
sum = 0;
for (i=1; i<n; i=i*2)
for (j=0; j<i; j++)
sum++;
02-53: Calculating Big-Oh
sum = 0; O(1)
for (i=1; i<n; i=i*2) Executed lg n times
for (j=0; j<i; j++) Executed <= n times
sum++; O(1)

Running Time: O(n lg n). Also (n lg n) ?

No
02-54: Calculating Big-Oh
sum = 0;
for (i=1; i<n; i=i*2)
for (j=0; j<i; j++)
sum++;
# of times sum++ is executed: Hard, Revision Again

lg n
"
2i = 2lg n+1 2^(log8+1)-1
1 = 2^4 -1 = 15

i=0
= 2n 1
2(16)-1 = 15
(n)
02-55: Calculating Big-Oh
Of course, a little change can mess things up a bit ...
sum = 0;
for (i=1; i<=n; i=i+1)
for (j=1; j<=i; j=j*2)
sum++;
02-56: Calculating Big-Oh
Of course, a little change can mess things up a bit ...
sum = 0;
for (i=1; i<=n; i=i+1) Executed n times
for (j=1; j<=i; j=j*2) Executed <= lg n times
sum++; O(1)
So, this is code is O(n lg n) but is it also (n lg n)?
Yes!
02-57: Calculating Big-Oh
Of course, a little change can mess things up a bit ...
sum = 0;
for (i=1; i<=n; i=i+1) Executed n times
for (j=1; j<=i; j=j*2) Executed <= lg n times
sum++; O(1)
Total time sum++ is executed:
n
"
lg i Hard, Revision Again

i=1

This can be tricky to evaluate, but we only need a

bound ...

Text
02-58: Calculating Big-Oh
Total # of times sum++ is executed:

Hard, Revision Again

n n/21 n
" " "
lg i = lg i + lg i
i=1 i=1 i=n/2
n
"
lg i
i=n/2
n
"
lg n/2
i=n/2
Ans: theta(nlogn)
= n/2 lg n/2
(n lg n)