The Complexity of Algorithms: Selected Exercises

alida-meadow

Published 2026-06-17 · 13 slides · 0 views

↓ Download

The Complexity of Algorithms: Selected Exercises

The Complexity of Algorithms: Selected Exercises - slide 1 of 13

The Complexity of Algorithms: Selected Exercises - slide 2 of 13

The Complexity of Algorithms: Selected Exercises - slide 3 of 13

The Complexity of Algorithms: Selected Exercises - slide 4 of 13

The Complexity of Algorithms: Selected Exercises - slide 5 of 13

The Complexity of Algorithms: Selected Exercises - slide 6 of 13

The Complexity of Algorithms: Selected Exercises - slide 7 of 13

The Complexity of Algorithms: Selected Exercises - slide 8 of 13

The Complexity of Algorithms: Selected Exercises - slide 9 of 13

The Complexity of Algorithms: Selected Exercises - slide 10 of 13

The Complexity of Algorithms: Selected Exercises - slide 11 of 13

The Complexity of Algorithms: Selected Exercises - slide 12 of 13

The Complexity of Algorithms: Selected Exercises - slide 13 of 13

Description

The Complexity of Algorithms: Selected Exercises Goal: Introduce computational complexity analysis. 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,

Download this presentation From Below

"The Complexity of Algorithms: Selected Exercises" is the property of its rightful owner. Permission is granted to download and print the materials on this website for personal, non-commercial use only, and to display it on your personal computer provided you do not modify the materials and that you retain all copyright notices contained in the materials. By downloading content from our website, you accept the terms of this agreement.

Presentation Transcript

The Complexity of Algorithms: Selected Exercises Goal: Introduce computational complexity analysis.

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.

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.

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.

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.

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.)

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;
}

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 ) .

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.

Copyright © Peter Cappello 10 Program Notes Consider a faster algorithm for x2n.
(But which continues to ignore underflow/overflow.)

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.

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.

The Complexity of Algorithms: Selected Exercises

Related Topics

Share

Embed code

Download this presentation From Below

Presentation Transcript