1 Exercises and Solutions

Most of the exercises below have solutions but you should try first to solve
them. Each subsection with solutions is after the corresponding subsection
with exercises. T

1.1 Time complexity and Big-Oh notation: exercises

1. A sorting method with “Big-Oh” complexity O(n log n) spends exactly 1
millisecond to sort 1,000 data items. Assuming that time T (n) of sorting
n items is directly proportional to n log n, that is, T (n) = cn log n, derive
a formula for T (n), given the time T (N ) for sorting N items, and estimate
how long this method will sort 1,000,000 items.
2. A quadratic algorithm with processing time T (n) = cn2 spends T (N )
seconds for processing N data items. How much time will be spent for
processing n = 5000 data items, assuming that N = 100 and T (N ) = 1ms?
3. An algorithm with time complexity O(f (n)) and processing time T (n) =
cf (n), where f (n) is a known function of n, spends 10 seconds to process
1000 data items. How much time will be spent to process 100,000 data
items if f (n) = n and f (n) = n3 ?
4. Assume that each of the expressions below gives the processing time T (n)
spent by an algorithm for solving a problem of size n. Select the dominant
term(s) having the steepest increase in n and specify the lowest Big-Oh
complexity of each algorithm.

Expression Dominant term(s) O(. . .)

5 + 0.001n3 + 0.025n
500n + 100n1.5 + 50n log10 n
0.3n + 5n1.5 + 2.5 · n1.75
n2 log2 n + n(log2 n)2
n log3 n + n log2 n
3 log8 n + log2 log2 log2 n
100n + 0.01n2

0.01n + 100n2

2n + n0.5 + 0.5n1.25

0.01n log2 n + n(log2 n)2

100n log3 n + n3 + 100n

0.003 log4 n + log2 log2 n

1
 5. The statements below show some features of “Big-Oh” notation for the
functions f ≡ f (n) and g ≡ g(n). Determine whether each statement is
TRUE or FALSE and correct the formula in the latter case.

Is it TRUE If it is FALSE then write

Statement or FALSE? the correct formula

Rule of sums:
O(f + g) = O(f ) + O(g)

Rule of products:
O(f · g) = O(f ) · O(g)

Transitivity:
if g = O(f ) and h = O(f )
then g = O(h)

5n + 8n2 + 100n3 = O(n4 )

5n+8n2 +100n3 = O(n2 log n)

6. Prove that T (n) = a0 + a1 n + a2 n2 + a3 n3 is O(n3 ) using the formal

definition of the Big-Oh notation. Hint: Find a constant c and threshold
n0 such that cn3 ≥ T (n) for n ≥ n0 .
7. Algorithms A and B spend exactly TA (n) = 0.1n2 log10 n and TB (n) =
2.5n2 microseconds, respectively, for a problem of size n. Choose the al-
gorithm, which is better in the Big-Oh sense, and find out a problem size
n0 such that for any larger size n > n0 the chosen algorithm outperforms
the other. If your problems are of the size n ≤ 109 , which algorithm will
you recommend to use?

8. Algorithms A and B spend exactly TA (n) = cA n log2 n and TB (n) = cB n2

microseconds, respectively, for a problem of size n. Find the best algorithm
for processing n = 220 data items if the algoritm A spends 10 microseconds
to process 1024 items and the algorithm B spends only 1 microsecond to
process 1024 items.
9. Algorithms A and B spend exactly TA (n) = 5·n·log10 n and TB (n) = 25·n
microseconds, respectively, for a problem of size n. Which algorithm is
better in the Big-Oh sense? For which problem sizes does it outperform
the other?
10. One of the two software packages, A or B, should be chosen to process
very big databases, containing each up to 1012 records. Average process-
ing time of the package A is TA (n) = 0.1 · n · log2 n microseconds, and the
average processing time of the package B is TB (n) = 5 · n microseconds.

2
 Which algorithm has better performance in a ”Big-Oh” sense? Work out
exact conditions when these packages outperform each other.

11. One of the two software packages, A or B, should be chosen to process

data collections, containing each up to 109 records. Average processing
time of the package A is TA (n) = 0.001n milliseconds
√ and the average
processing time of the package B is TB (n) = 500 n milliseconds. Which
algorithm has better performance in a ”Big-Oh” sense? Work out exact
conditions when these packages outperform each other.

12. Software packages A and B of complexity O(n log n) and O(n), respec-
tively, spend exactly TA (n) = cA n log10 n and TB (n) = cB n milliseconds
to process n data items. During a test, the average time of processing
n = 104 data items with the package A and B is 100 milliseconds and 500
milliseconds, respectively. Work out exact conditions when one package
actually outperforms the other and recommend the best choice if up to
n = 109 items should be processed.
13. Let processing time of an algorithm of Big-Oh complexity O(f (n)) be
directly proportional to f (n). Let three such algorithms A, B, and C
have time complexity O(n2 ), O(n1.5 ), and O(n log n), respectively. During
a test, each algorithm spends 10 seconds to process 100 data items. Derive
the time each algorithm should spend to process 10,000 items.
14. Software packages A and B have processing time exactly TEP = 3n1.5 and
TWP = 0.03n1.75 , respectively. If you are interested in faster processing of
up to n = 108 data items, then which package should be choose?

1.2 Time complexity and Big-Oh notation: solutions

T (N )
1. Because processing time is T (n) = cn log n, the constant factor c = N log N ,
and T (n) = T (N ) Nn log
log n
N.
Ratio of logarithms of the same base is indepen-
dent of the base (see Appendix in the textbook), hence, any appropriate
base can be used in the above formula (say, base of 10). Therefore, for
n = 1000000 the time is T (1, 000, 000) = T (1, 000) · 1000000 log10 1000000
1000 log10 1000 =
1000000·6
1 · 1000·3 = 2, 000 ms
2
T (N ) n n2
2. The constant factor c = N2 , therefore T (n) = T (N ) N 2 = 10000 ms and
T (5000) = 2, 500 ms.
T (1000) 10
3. The constant factor c = f (1000) = f (1000) milliseconds per item. There-
f (n)
fore, T (n) = ms and T (100, 000) = 10 f (100,000)
10 f (1000) f (1000) ms. If f (n) = n
then T (100, 000) = 1000 ms. If f (n) = n , then T (100, 000) = 107 ms.
3

3
 Expression Dominant term(s) O(. . .)
5 + 0.001n3 + 0.025n 0.001n3 O(n3 )
500n + 100n1.5 + 50n log10 n 100n1.5 O(n1.5 )
0.3n + 5n1.5 + 2.5 · n1.75 2.5n1.75 O(n1.75 )
n2 log2 n + n(log2 n)2 n2 log2 n O(n2 log n)
n log3 n + n log2 n n log3 n, n log2 n O(n log n)
3 log8 n + log2 log2 log2 n 3 log8 n O(log n)
4. 100n + 0.01n2 0.01n2 O(n2 )

0.01n + 100n2 100n2 O(n2 )

2n + n0.5 + 0.5n1.25 0.5n1.25 O(n1.25 )

0.01n log2 n + n(log2 n)2 n(log2 n)2 O(n(log n)2 )

100n log3 n + n3 + 100n n3 O(n3 )

0.003 log4 n + log2 log2 n 0.003 log4 n O(log n)

If it is FALSE then
Is it TRUE
Statement write
or FALSE?
the correct formula

Rule of sums: O(f + g) =

O(f + g) = O(f ) + O(g) FALSE max {O(f ), O(g)}

Rule of products:
O(f · g) = O(f ) · O(g) TRUE

5. Transitivity: if g = O(f ) and

if g = O(f ) and h = O(f ) FALSE f = O(h) then
then g = O(h) g = O(h)

5n + 8n2 + 100n3 = O(n4 )

TRUE

5n + 8n2 + 100n3 =
5n + 8n2 + 100n3 = O(n3 )
O(n2 log n) FALSE

6. It is obvious that T (n) ≤ |a0 | + |a1 |n + |a2 |n2 + |a3 |n3 . Thus if n ≥ 1,
then T (n) ≤ cn3 where c = |a0 | + |a1 | + |a2 | + |a3 | so that T (n) is O(n3 ).
7. In the Big-Oh sense, the algorithm B is better. It outperforms the algo-

4
 rithm A when TB (n) ≤ TA (n), that is, when 2.5n2 ≤ 0.1n2 log10 n. This
inequality reduces to log10 n ≥ 25, or n ≥ n0 = 1025 . If n ≤ 109 , the
algorithm of choice is A.
8. The constant factors for A and B are:
10 1 1
cA = = ; cB =
1024 log2 1024 1024 10242

Thus, to process 220 = 10242 items the algorithms A and B will spend
1 20 1
TA (220 ) = 2 log2 (220 ) = 20280µs and TB (220 ) = 240 = 220 µs,
1024 10242
respectively. Because TB (220 )  TA (220 ), the method of choice is A.
9. In the Big-Oh sense, the algorithm B is better. It outperforms the algo-
rithm A if TB (n) ≤ TA (n), that is, if 25n ≤ 5n log10 n, or log10 n ≥ 5, or
n ≥ 100, 000.
10. In the “Big-Oh” sense, the algorithm B of complexity O(n) is better than
A of complexity O(n log n). he package B has better performance in a
The package B begins to outperform A when (TA (n) ≥ TB (n), that is,
when 0.1n log2 n ≥ 5 · n. This inequality reduces to 0.1 log2 n ≥ 5, or
n ≥ 250 ≈ 1015 . Thus for processing up to 1012 data items, the package
of choice is A.
11. In the “Big-Oh” sense, the package B of complexity O(n0.5 ) is better
than A of complexity O(n). The package B begins √ to outperform A when
(TA√(n) ≥ TB (n), that is, when 0.001n ≥ 500 n. This inequality reduces
to n ≥ 5 · 105 , or n ≥ 25 · 1010 . Thus for processing up to 109 data items,
the package of choice is A.
12. In the “Big-Oh” sense, the package B of linear complexity O(n) is better
than the package A of O(n log n) complexity. The processing times of the
packages are TA (n) = cA n log10 n and TB (n) = cB n, respectively. The
tests allows us to derive the constant factors:
100 1
cA = 104 log10 104 = 400
500 1
cB = 104 = 20

The package B begins to outperform A when we must estimate the data

size n0 that ensures TA (n) ≥ TB (n), that is, when n log
400
10 n n
≥ 20 . This
400 20
inequality reduces to log10 n ≥ 20 , or n ≥ 10 . Thus for processing up
to 109 data items, the package of choice is A.
Complexity Time to process 10,000 items
2
A1 O(n2 ) T (10, 000) = T (100) · 10000
1002 1.5= 10 · 10000 = 100, 000 sec.
13.
A2 O(n1.5 ) T (10, 000) = T (100) · 10000
1001.5 = 10 · 1000 = 10, 000 sec.
10000 log 10000
A3 O(n log n) T (10, 000) = T (100) · 100 log 100 = 10 · 200 = 2, 000 sec.

5
 14. In the Big-Oh sense, the package A is better. But it outperforms the
package B when TA (n) ≤ TB (n), that is, when 3n1.5 ≤ 0.03n1.75 . This in-
equality reduces to n0.25 ≥ 3/0.03(= 100), or n ≥ 108 . Thus for processing
up to 108 data items, the package of choice is B.

1.3 Recurrences and divide-and-conquer paradigm: exer-

cises
1. Running time T (n) of processing n data items with a given algorithm is
described by the recurrence:
n
T (n) = k · T + c · n; T (1) = 0.
k
Derive a closed form formula for T (n) in terms of c, n, and k. What is the
computational complexity of this algorithm in a “Big-Oh” sense? Hint:
To have the well-defined recurrence, assume that n = k m with the integer
m = logk n and k.

2. Running time T (n) of processing n data items with another, slightly dif-
ferent algorithm is described by the recurrence:
n
T (n) = k · T + c · k · n; T (1) = 0.
k
Derive a closed form formula for T (n) in terms of c, n, and k and detemine
computational complexity of this algorithm in a “Big-Oh” sense. Hint:
To have the well-defined recurrence, assume that n = k m with the integer
m = logk n and k.

3. What value of k = 2, 3, or 4 results in the fastest processing with the

above algorithm? Hint: You may need a relation logk n = ln n
ln k where ln
denotes the natural logarithm with the base e = 2.71828 . . .).

4. Derive the recurrence that describes processing time T (n) of the recursive
method:

public static int recurrentMethod(

int[] a, int low, int high, int goal ) {
int target = arrangeTarget( a, low, high );
if ( goal < target )
return recurrentMethod( a, low, target-1, goal );
else if ( goal > target )
return recurrentMethod( a, target+1, high, goal );
else
return a[ target ];
}

6
 The range of input variables is 0 ≤ low ≤ goal ≤ high ≤ a.length − 1.
A non-recursive method arrangeTarget() has linear time complexity
T (n) = c · n where n = high − low + 1 and returns integer target in
the range low ≤ target ≤ high. Output values of arrangeTarget()
are equiprobable in this range, e.g. if low = 0 and high = n − 1, then
every target = 0, 1, . . . , n − 1 occurs with the same probability n1 . Time
for performing elementary operations like if–else or return should not be
taken into account in the recurrence.

Hint: consider a call of recurrentMethod() for n = a.length data items,

e.g. recurrentMethod( a, 0, a.length - 1, goal ) and analyse all
recurrences for T (n) for different input arrays. Each recurrence involves
the number of data items the method recursively calls to.

5. Derive an explicit (closed–form) formula for time T (n) of processing an

array of size n if T (n) is specified implicitly by the recurrence:
1
T (n) = (T (0) + T (1) + · · · + T (n − 1)) + c · n; T (0) = 0
n
Hint: You might need the n-th harmonic number Hn = 1+ 21 + 13 +· · ·+ n1 ≈
ln n + 0.577 for deriving the explicit formula for T (n).

6. Determine an explicit formula for the time T (n) of processing an array of

size n if T (n) relates to the average of T (n − 1), . . . , T (0) as follows:
2
T (n) = (T (0) + · · · + T (n − 1)) + c
n
where T(0) = 0.

1 1 1 n
Hint: You might need the equation 1·2 + 2·3 + ··· + n(n+1) = n+1 for
deriving the explicit formula for T (n).

7. The obvious linear algorithm for exponentiation xn uses n − 1 multiplica-

tions. Propose a faster algorithm and find its Big-Oh complexity in the
case when n = 2m by writing and solving a recurrence formula.

1.4 Recurrences and divide-and-conquer paradigm: solu-

tions
1. The closed-form formula can be derived either by “telescoping”1 or by
guessing from a few values and using then math induction.
1 If you know difference equations in math, you will easily notice that the recurrences are the

difference equations and ”telescoping” is their solution by substitution of the same equation
for gradually decreasing arguments: n − 1 or n/k.

7
(a) Derivation with “telescoping”: the recurrence T (k m ) = k · T (k m−1 ) +
c · k m can be represented and “telescoped” as follows:
T (k m ) T (k m−1 )
= +c
km k m−1
m−1
T (k ) T (k m−2 )
= +c
k m−1 k m−2
··· ··· ···
T (k) T (1)
= +c
k 1
m
Therefore, T (k
km
)
= c·m, or T (k m ) = c·k m ·m, or T (n) = c·n·logk n.
The Big-Oh complexity is O(n log n).
(b) Another version of telescoping: the like substitution can be applied
directly to the initial recurrence:

T (k m ) = k · T (k m−1 ) + c · k m
k · T (k m−1 ) = k 2 · T (k m−2 ) + c · k m
··· ··· ···
k m−1 · T (k) = k m · T (1) + c · k m so that T (k m ) = c · m · k m

(c) Guessing and math induction: let us construct a few initial values
of T (n), starting from the given T (1) and successively applying the
recurrence:

T (1) = 0
T (k) = k · T (1) + c · k = c · k
T (k 2 ) = k · T (k) + c · k 2 = 2 · c · k 2
T (k 3 ) = k · T (k 2 ) + c · k 3 = 3 · c · k 3

This sequence leads to an assumption that T (k m ) = c · m · k m . Let us

explore it with math induction. The inductive steps are as follows:
(i) The base case T (1) ≡ T (k 0 ) = c · 0 · k 0 = 0 holds under our
assumption.

(ii) Let the assumption holds for l = 0, . . . , m − 1. Then

T (k m ) = k · T (k m−1 ) + c · k m
= k · c · (m − 1) · k m−1 + c · k m
= c · (m − 1 + 1) · k m = c · m · k m

Therefore, the assumed relationship holds for all values m = 0, 1, . . . , ∞,

so that T (n) = c · n · logk n.

8
 The Big-Oh complexity of this algorithm is O(n log n).
2. The recurrence T (k m ) = k · T (k m−1 ) + c · k m+1 telescopes as follows:
T (km ) T (km−1 )
km+1 = km +c
T (km−1 ) T (km−2 )
km = km−1 +c
··· ··· ···
T (k) T (1)
k2 = k +c
m
Therefore, Tk(k )
m+1 = c · m, or T (k
m
) = c · k m+1 · m, or T (n) = c · k · n · logk n.
The complexity is O(n log n) because k is constant.
3. Processing time T (n) = c · k · n · logk n can be easily rewritten as T (n) =
c lnkk · n · ln n to give an explicit dependence of k. Because ln22 = 2.8854,
3 4
ln 3 = 2.7307, and ln 4 = 2.8854, the fastest processing is obtained for
k = 3.
4. Because all the variants:
T (n) = T (0) + cn or T (n) = T (n − 1) + cn if target = 0
T (n) = T (1) + cn or T (n) = T (n − 2) + cn if target = 1
T (n) = T (2) + cn or T (n) = T (n − 3) + cn if target = 2
... ... ...
T (n) = T (n − 1) + cn or T (n) = T (0) + cn if target = n − 1

are equiprobable, then the recurrence is

1
T (n) = (T (0) + . . . + T (n − 1)) + c · n
n

5. The recurrence suggests that nT (n) = T (0)+T (1)+· · ·+T (n−2)+T (n−
1)+cn2 . It follows that (n−1)T (n−1) = T (0)+. . .+T (n−2)+c·(n−1)2 ,
and by subtracting the latter equation from the former one, we obtain the
following basic recurrence: nT (n) − (n − 1)T (n − 1) = T (n − 1) + 2cn − c.
It reduces to nT (n) = n · T (n − 1) + 2cn − c, or T (n) = T (n − 1) + 2c − nc .
Telescoping results in the following system of equalities:

T (n) = T (n − 1) +2c − nc
c
T (n − 1) = T (n − 2) +2c − n−1
··· ··· ··· ··· ···
T (2) = T (1) +2c − 2c
T (1) = T (0) +2c −c

Because T (0) = 0, the explicit expression for T (n) is:

 
1 1
T (n) = 2cn − c · 1 + + · · · + = 2cn − Hn ≡ 2cn − ln n − 0.577
2 n

9
6. The recurrence suggests that nT (n) = 2(T (0)+T (1)+. . .+T (n−2)+T (n−
1)) + c · n. Because (n − 1)T (n − 1) = 2(T (0) + . . . + T (n − 2)) + c · (n − 1),
the subtraction of the latter equality from the former one results in the
following basic recurrence nT (n) − (n − 1)T (n − 1) = 2T (n − 1) + c. It
reduces to nT (n) = (n + 1)T (n − 1) + c, or Tn+1 (n)
= T (n−1)
n
c
+ n(n+1) .
Telescoping results in the following system of equalities:
T (n) T (n−1) c
n+1 = n + n(n+1)
T (n−1) T (n−2) c
n = n−1 + (n−1)n
··· ··· ··· ··· ···
T (2) T (1) c
3 = 2 + 2·3
T (1) T (0) c
2 = 1 + 1·2

Because T (0) = 0, the explicit expression for T (n) is:

T (n) 1 c 1 c n
= + + ··· + =c·
n+1 1·2 2·3 (n − 1)n n(n + 1) n+1

so that T (n) = c · n.

An alternative approach (guessing and math induction):

T (0) = 0
T (1) = 12 · 0 + c = c
T (2) = 22 (0 + c) + c = 2c
T (3) = 23 (0 + c + 2c) + c = 3c
T (4) = 24 (0 + c + 2c + 3c) + c = 4c

It suggests an assumption T (n) = cn to be explored with math induction:

(i) The assumption is valid for T (0) = 0.

(ii) Let it be valid for k = 1, . . . , n − 1, that is, T (k) = kc for k =
1, . . . , n − 1. Then

T (n) = n2 (0 + c + 2c + . . . + (n − 1)c) + c
= n2 (n−1)n
2 c+c
= (n − 1)c + c = cn

The assumption is proven, and T (n) = cn.

7. A straightforward linear exponentiation needs n2 = 2m−1 multiplications
n n n
to produce xn after having already x 2 . But because xn = x 2 · x 2 , it
n
can be computed with only one multiplication more than to compute x 2 .
Therefore, more efficient exponentiation is performed as follows: x2 = x·x,
x4 = x2 · x2 , x8 = x4 · x4 , etc. Processing time for such more efficient

10
 algorithm corresponds to a recurrence: T (2m ) = T (2m−1 ) + 1, and by
telescoping one obtains:

T (2m ) = T (2m−1 ) + 1
T (2m−1 ) = T (2m−2 ) + 1
··· ···
T (2) = T (1) + 1
T (1) = 0

that is, T (2m ) = m, or T (n) = log2 n. The “Big-Oh” complexity of such

algorithm is O(log n).

1.5 Time complexity of code: exercises

1. Work out the computational complexity of the following piece of code:

for( int i = n; i > 0; i /= 2 ) {

for( int j = 1; j < n; j *= 2 ) {
for( int k = 0; k < n; k += 2 ) {
... // constant number of operations
}
}
}

2. Work out the computational complexity of the following piece of code.

for ( i=1; i < n; i *= 2 ) {

for ( j = n; j > 0; j /= 2 ) {
for ( k = j; k < n; k += 2 ) {
sum += (i + j * k );
}
}
}

3. Work out the computational complexity of the following piece of code

assuming that n = 2m :

for( int i = n; i > 0; i-- ) {

for( int j = 1; j < n; j *= 2 ) {
for( int k = 0; k < j; k++ ) {
... // constant number C of operations
}
}
}

11
4. Work out the computational complexity (in the “Big-Oh” sense) of the
following piece of code and explain how you derived it using the basic
features of the “Big-Oh” notation:

for( int bound = 1; bound <= n; bound *= 2 ) {

for( int i = 0; i < bound; i++ ) {
for( int j = 0; j < n; j += 2 ) {
... // constant number of operations
}
for( int j = 1; j < n; j *= 2 ) {
... // constant number of operations
}
}
}

5. Determine the average processing time T (n) of the recursive algorithm:

1 int myTest( int n ) {

2 if ( n <= 0 ) return 0;
3 else {
4 int i = random( n - 1 );
5 return myTest( i ) + myTest( n - 1 - i );
6 }
7 }

providing the algorithm random( int n ) spends one time unit to return
a random integer value uniformly distributed in the range [0, n] whereas
all other instructions spend a negligibly small time (e.g., T (0) = 0).

Hints: derive and solve the basic recurrence relating T (n) in average to
1 1 1
T (n−1), . . . , T (0). You might need the equation 1·2 + 2·3 +· · ·+ n(n+1) =
n
n+1 for deriving the explicit formula for T (n).
6. Assume that the array a contains n values, that the method randomValue
takes constant number c of computational steps to produce each output
value, and that the method goodSort takes n log n computational steps
to sort the array. Determine the Big-Oh complexity for the following
fragments of code taking into account only the above computational steps:

for( i = 0; i < n; i++ ) {

for( j = 0; j < n; j++ )
a[ j ] = randomValue( i );
goodSort( a );
}

12
1.6 Time complexity of code: solutions
1. In the outer for-loop, the variable i keeps halving so it goes round log2 n
times. For each i, next loop goes round also log2 n times, because of dou-
bling the variable j. The innermost loop by k goes round n2 times. Loops
are nested, so

the bounds may be multiplied to give that the algorithm is
O n(log n)2 .
2. Running time of the inner, middle, and outer loop is proportional to
n, log n, and log n, respectively. Thus the overall Big-Oh complexity is
O(n(log n)2 ).

More detailed optional analysis gives the same value. Let n = 2k . Then
the outer loop is executed k times, the middle loop is executed k + 1
times, and for each value j = 2k , 2k−1 , . . . , 2, 1, the inner loop has different
execution times:
j Inner iterations
2k 1
2k−1 (2k − 2k−1 ) 12
2k−2 (2k − 2k−2 ) 12
... ...
21 (2k − 21 ) 12
2 0
(2k − 20 ) 12
In total, the number of inner/middle steps is
1 1
1 + k · 2k−1 − (1 + 2 + . . . + 2k−1 ) = 1 + k · 2k−1 − (2k − 1)
2 2
n
= 1.5 + (k − 1) · 2k−1 ≡ (log2 n − 1)
2
= O(n log n)

Thus, the total complexity is O(n(log n)2 ).

3. The outer for-loop goes round n times. For each i, the next loop goes
round m = log2 n times, because of doubling the variable j. For each j,
the innermost loop by k goes round j times, so that the two inner loops
together go round 1 + 2 + 4 + . . . + 2m−1 = 2m − 1 ≈ n times. Loops
are nested,

so the bounds may be multiplied to give that the algorithm is
O n2 .

4. The first and second successive innermost loops have O(n) and O(log n)
complexity, respectively. Thus, the overall complexity of the innermost
part is O(n). The outermost and middle loops have complexity O(log n)
and O(n), so a straightforward (and valid) solution is that the overall
complexity is O(n2 log n).

13
 More detailed analysis shows that the outermost and middle loops are
interrelated, and the number of repeating the innermost part is as follows:

1 + 2 + . . . + 2m = 2m+1 − 1

where m = blog2 nc is the smallest integer such that 2m+1 > n. Thus
actually this code has quadratic complexity O(n2 ). But selection of either
answer (O(n2 log n) and O(n2 ) is valid.
5. The algorithm suggests that T (n) = T (i) + T (n − 1 − i) + 1. By summing
this relationship for all the possible random values i = 0, 1, . . . , n − 1, we
obtain that in average nT (n) = 2(T (0)+T (1)+. . .+T (n−2)+T (n−1))+n.
Because (n − 1)T (n − 1) = 2(T (0) + . . . + T (n − 2)) + (n − 1), the basic
recurrence is as follows: nT (n) − (n − 1)T (n − 1) = 2T (n − 1) + 1, or
nT (n) = (n + 1)T (n − 1) + 1, or Tn+1
(n)
= T (n−1)
n
1
+ n(n+1) . The telescoping
results in the following system of expressions:
T (n) T (n−1) 1
n+1 = n + n(n+1)
T (n−1) T (n−2) 1
n = n−1 + (n−1)n
··· ··· ··· ··· ···
T (2) T (1) 1
3 = 2 + 2·3
T (1) T (0) 1
2 = 1 + 1·2

Because T (0) = 0, the explicit expression for T (n) is:

T (n) 1 1 1 1 n
= + + ··· + =
n+1 1·2 2·3 (n − 1)n n(n + 1) n+1

so that T (n) = n.
6. The inner loop has linear complexity cn, but the next called method is
of higher complexity n log n. Because the outer loop is linear in n, the
overall complexity of this piece of code is n2 log n.

14