The Complexity of Algorithms: Selected Exercises

slide1. The Complexity of Algorithms: Selected Exercises Goal: Introduce computational complexity analysis.<br>
slide2. Copyright © Peter Cappello 2 2 Exercise 10 How much time does an algorithm take for a problem of size n, if it uses 2n2 + 2n bit operations, each taking 10-9 second?
n = 10: ( 2(10)2 + 210 )10-9 sec ≈ 1.224 *10-6 sec.<br>
slide3. 3 Copyright © Peter Cappello 3 Exercise 10 How much time does an algorithm take for a problem of size n, if it uses 2n2 + 2n bit operations, each taking 10-9 second?
n = 10: ( 2(10)2 + 210 )10-9 sec ≈ 1.224 *10-6 sec.
n = 20: ( 2(20)2 + 220 )10-9 sec ≈ 1.05 *10-3 sec.<br>
slide4. 4 Copyright © Peter Cappello 4 Exercise 10 How much time does an algorithm take for a problem of size n, if it uses 2n2 + 2n bit operations, each taking 10-9 second?
n = 10: ( 2(10)2 + 210 )10-9 sec ≈ 1.224 *10-6 sec.
n = 20: ( 2(20)2 + 220 )10-9 sec ≈ 1.05 *10-3 sec.
n = 50: ( 2(50)2 + 250 )10-9 sec ≈ 1.13 *106 sec ≈ 13 days.<br>
slide5. 5 Copyright © Peter Cappello 5 Exercise 10 How much time does an algorithm take for a problem of size n, if it uses 2n2 + 2n bit operations, each taking 10-9 second?
n = 10: ( 2(10)2 + 210 )10-9 sec ≈ 1.224 *10-6 sec.
n = 20: ( 2(20)2 + 220 )10-9 sec ≈ 1.05 *10-3 sec.
n = 50: ( 2(50)2 + 250 )10-9 sec ≈ 1.13 *106 sec ≈ 13 days.
n = 100: ( 2(100)2 + 2100 )10-9 sec ≈ 1.27 *1021 sec ≈ 4 *1013 years.<br>
slide6. Copyright © Peter Cappello 6 Exercise 20 Analyze the worst-case [time] complexity of the program on the following slide, in terms of the number of elements in the input array.
(That is, give a O() estimate of the time.)<br>
slide7. Copyright © Peter Cappello 7 Method (not compiled) List<Integer> getBiggersList( int[] intArray )
{
List<Integer> biggers = new LinkedList<Integer>();
int sum = 0;
for ( int item : intArray )
{
if ( item > sum )
biggers.add( item );
sum += item;
}
return biggers;
}<br>
slide8. Copyright © Peter Cappello 8 Exercise 20 continued Let n = intArray.length.
The statements outside the for statement complete in constant time (i.e., do not depend on n), say c1 sec.
The body of the for statement executes n times.
Each iteration of the body takes constant time, say c2 sec.
Only if the List add operation requires constant time (i.e., does not depend on n).
Total time, in seconds, is c1 + c2 n, which is O( n ) .<br>
slide9. Copyright © Peter Cappello 9 Exponentiation revisited double x2n( double x, int n )
{
double x2n = 1.0;
for ( int i = 0; i < n; i++ )
x2n *= x;
return x2n;
}

double x2z( double x, int z )
{
return ( z < 0 ) ? 1.0 / x2n( x, -z ) : x2n( x, z );
}

Give a O() estimate for the time to compute x2n as a function of n.<br>
slide10. Copyright © Peter Cappello 10 Program Notes Consider a faster algorithm for x2n.
(But which continues to ignore underflow/overflow.)<br>
slide11. Copyright © Peter Cappello 11 Faster algorithm for x2n double x2n( double x, int n )
{
double x2n = 1.0, factor = x;
while ( n > 0 )
{
if ( n % 2 == 1 )
x2n *= factor;
n /= 2;
factor *= factor;
}
return x2n;
}

Evaluate the algorithm for n = 21.
Give a O() estimate for the time to compute x2n as a function of n.<br>
slide12. Copyright © Peter Cappello 12 Recursive version of faster algorithm double x2n( double x, int n )
{
if ( n == 0 )
return 1.0;
return ( ( n % 2 == 0 ) ? 1 : x ) * x2n( x * x, n / 2 );
}

Evaluate x2n( 2.0, 21 ) .
How many times is x2n invoked, as a function of n?
We address this question when we study recurrence relations.<br>
slide13. Copyright © Peter Cappello 2011 13 END Copyright © Peter Cappello 2011 13<br>