ads Some Common Recurrence Relations

Section 8.4 Some Common Recurrence Relations

In this section we intend to examine a variety of recurrence relations that are not finite-order linear with constant coefficients. For each part of this section, we will consider a concrete example, present a solution, and, if possible, examine a more general form of the original relation.

🔗

Subsection 8.4.1 A First Basic Example

Consider the homogeneous first-order linear relation without constant coefficients,

S (n) - n S (n - 1) = 0,

n \geq 1,

with initial condition

S (0) = 1 .

Upon close examination of this relation, we see that the

n

th term is

n

times the

(n - 1)^{s t}

term, which is a property of

n

factorial.

S (n) = n!

is a solution of this relation, for if

n \geq 1,

S (n) = n! = n \cdot (n - 1)! = n \cdot S (n - 1)

In addition, since

0! = 1,

the initial condition is satisfied. It should be pointed out that from a computational point of view, our “solution” really isn’t much of an improvement since the exact calculation of

n!

takes

n - 1

multiplications.

🔗

If we examine a similar relation,

G (k) - 2^{k} G (k - 1) = 0,

k \geq 1

with

G (0) = 1,

a table of values for

G

suggests a possible solution:

\begin{array}{ccccccc} k & 0 & 1 & 2 & 3 & 4 & 5 \\ G (k) & 1 & 2 & 2^{3} & 2^{6} & 2^{10} & 2^{15} \end{array}

The exponent of 2 in

G (k)

is growing according to the relation

E (k) = E (k - 1) + k,

with

E (0) = 0 .

Thus

E (k) = \frac{k (k + 1)}{2}

and

G (k) = 2^{k (k + 1) / 2} .

Note that

G (k)

could also be written as

2^{0} 2^{1} 2^{2} \dots 2^{k},

for

k \geq 0,

but this is not a closed form expression.

🔗

In general, the relation

P (n) = f (n) P (n - 1)

for

n \geq 1

with

P (0) = f (0),

where

f

is a function that is defined for all

n \geq 0,

has the “solution”

P (n) = \prod_{k = 0}^{n} f (k)

This product form of

P (n)

is not a closed form expression because as

n

grows, the number of multiplications grow. Thus, it is really not a true solution. Often, as for

G (k)

above, a closed form expression can be derived from the product form.

🔗

Subsection 8.4.2 An Analysis of the Binary Search Algorithm

Subsubsection 8.4.2.1

Suppose you intend to use a binary search algorithm (see Subsection 8.1.3) on lists of zero or more sorted items, and that the items are stored in an array, so that you have easy access to each item. A natural question to ask is “How much time will it take to complete the search?” When a question like this is asked, the time we refer to is often the so-called worst-case time. That is, if we were to search through

n

items, what is the longest amount of time that we will need to complete the search? In order to make an analysis such as this independent of the computer to be used, time is measured by counting the number of steps that are executed. Each step (or sequence of steps) is assigned an absolute time, or weight; therefore, our answer will not be in seconds, but in absolute time units. If the steps in two different algorithms are assigned weights that are consistent, then analyses of the algorithms can be used to compare their relative efficiencies. There are two major steps that must be executed in a call of the binary search algorithm:

🔗

If the lower index is less than or equal to the upper index, then the middle of the list is located and its key is compared to the value that you are searching for.
🔗

🔗
In the worst case, the algorithm must be executed with a list that is roughly half as large as in the previous execution. If we assume that Step 1 takes one time unit and $T (n)$ is the worst-case time for a list of $n$ items, then

$\begin{matrix} (8.4.1) & T (n) = 1 + T (⌊ n / 2 ⌋), n > 0 \end{matrix}$

For simplicity, we will assume that

$\begin{matrix} (8.4.2) & T (0) = 0 \end{matrix}$

even though the conditions of Step 1 must be evaluated as false if $n = 0 .$ You might wonder why $n / 2$ is truncated in (8.4.1). If $n$ is odd, then $n = 2 k + 1$ for some $k \geq 0,$ the middle of the list will be the $(k + 1)^{s t}$ item, and no matter what half of the list the search is directed to, the reduced list will have $k = ⌊ n / 2 ⌋$ items. On the other hand, if $n$ is even, then $n = 2 k$ for $k > 0 .$ The middle of the list will be the $k^{t h}$ item, and the worst case will occur if we are directed to the $k$ items that come after the middle (the $(k + 1)^{s t}$ through $(2 k)^{t h}$ items). Again the reduced list has $⌊ n / 2 ⌋$ items.

🔗

🔗

🔗

Solution to (8.4.1) and (8.4.2). To determine

T (n),

the easiest case is when

n

is a power of two. If we compute

T (2^{m}),

m \geq 0

, by iteration, our results are

\begin{matrix} T (1) = 1 + T (0) = 1 \\ T (2) = 1 + T (1) = 2 \\ T (4) = 1 + T (2) = 3 \\ T (8) = 1 + T (4) = 4 \end{matrix}

The pattern that is established makes it clear that

T (2^{m}) = m + 1 .

This result would seem to indicate that every time you double the size of your list, the search time increases by only one unit.

🔗

A more complete solution can be obtained if we represent

n

in binary form. For each

n \geq 1,

there exists a non-negative integer

r

such that

\begin{matrix} (8.4.3) & 2^{r - 1} \leq n < 2^{r} \end{matrix}

For example, if

n = 21,

2^{4} \leq 21 < 2^{5};

therefore,

r = 5 .

n

satisfies (8.4.3), its binary representation requires

r

digits. For example,

21_{ten}

10101_{two} .

🔗

In general,

n = {(a_{1} a_{2} \dots a_{r})}_{two} .

where

a_{1} = 1 .

Note that in this form,

⌊ n / 2 ⌋

is easy to describe: it is the

r - 1

digit binary number

{(a_{1} a_{2} \dots a_{r - 1})}_{two}

🔗

Therefore,

\begin{aligned} T (n) & = T (a_{1} a_{2} \dots a_{r}) \\ = 1 + T (a_{1} a_{2} \dots a_{r - 1}) \\ = 1 + (1 + T (a_{1} a_{2} \dots a_{r - 2})) \\ = 2 + T (a_{1} a_{2} \dots a_{r - 2}) \\ ⋮ \\ = (r - 1) + T (a_{1}) \\ = (r - 1) + 1 since T (1) = 1 \\ = r \end{aligned} .

🔗

From the pattern that we’ve just established,

T (n)

reduces to

r .

A formal inductive proof of this statement is possible. However, we expect that most readers would be satisfied with the argument above. Any skeptics are invited to provide the inductive proof.

🔗

For those who prefer to see a numeric example, suppose

n = 21 .

\begin{aligned} T (21) & = T (10101) \\ = 1 + T (1010) \\ = 1 + (1 + T (101)) \\ = 1 + (1 + (1 + T (10))) \\ = 1 + (1 + (1 + (1 + T (1)))) \\ = 1 + (1 + (1 + (1 + (1 + T (0))))) \\ = 5 \end{aligned}

🔗

Our general conclusion is that the solution to (8.4.1) and (8.4.2) is that for

n \geq 1,

T (n) = r,

where

2^{r - 1} \leq n < 2^{r} .

🔗

A less cumbersome statement of this fact is that

T (n) = ⌊ \log_{2} n ⌋ + 1 .

For example,

T (21) = ⌊ \log_{2} 21 ⌋ + 1 = 4 + 1 = 5 .

🔗

Subsubsection 8.4.2.2 Review of Logarithms

Any discussion of logarithms must start by establishing a base, which can be any positive number other than 1. With the exception of Theorem 5, our base will be 2. We will see that the use of a different base (10 and

e \approx 2.171828

are the other common ones) only has the effect of multiplying each logarithm by a constant. Therefore, the base that you use really isn’t very important. Our choice of base 2 logarithms is convenient for the problems that we are considering.

🔗

Definition 8.4.1. Base 2 logarithm.

The base 2 logarithm of a positive number represents an exponent and is defined by the following equivalence for any positive real numbers

a .

\log_{2} a = x \Leftrightarrow 2^{x} = a .

🔗

described in detail following the image — Figure 8.4.2. Plot of the logarithm, bases 2, function
🔗

For example,

\log_{2} 8 = 3

because

2^{3} = 8

and

\log_{2} 1.414 \approx 0.5

because

2^{0.5} \approx 1.414 .

A graph of the function

f (x) = \log_{2} x

in Figure 8.4.2 shows that if

a < b,

the

\log_{2} a < \log_{2} b;

that is, when

x

increases,

\log_{2} x

also increases. However, if we move

x

from

2^{10} = 1024

2^{11} = 2048,

\log_{2} x

only increases from 10 to 11. This slow rate of increase of the logarithm function is an important point to remember. An algorithm acting on

n

pieces of data that can be executed in

\log_{2} n

time units can handle significantly larger sets of data than an algorithm that can be executed in

n / 100

\sqrt{n}

time units. The graph of

T (n) = ⌊ \log_{2} n ⌋ + 1

would show the same behavior.

🔗

A few more properties that we will use in subsequent discussions involving logarithms are summarized in the following theorem.

🔗

Theorem 8.4.3. Fundamental Properties of Logarithms.

Let

a

and

b

be positive real numbers, and

r

a real number.

\begin{matrix} (8.4.4) & \log_{2} 1 = 0 \\ (8.4.5) & \log_{2} a b = \log_{2} a + \log_{2} b \\ (8.4.6) & \log_{2} \frac{a}{b} = \log_{2} a - \log_{2} b \\ (8.4.7) & \log_{2} a^{r} = r \log_{2} a \\ (8.4.8) & 2^{\log_{2} a} = a \end{matrix}

🔗

Definition 8.4.4. Logarithms base $b$ .

b > 0,

b \neq 1,

then for

a > 0,

\log_{b} a = x \Leftrightarrow b^{x} = a

🔗

Note 8.4.6.

\log_{2} 10 \approx 3.32192

and

\log_{2} e \approx 1.4427 .

🔗

Subsubsection 8.4.2.3

Returning to the binary search algorithm, we can derive the final expression for

T (n)

using the properties of logarithms, including that the logarithm function is increasing so that inequalities are maintained when taking logarithms of numbers.

🔗

\begin{aligned} T (n) = r & \Leftrightarrow 2^{r - 1} \leq n < 2^{r} \\ \Leftrightarrow \log_{2} 2^{r - 1} \leq \log_{2} n < \log_{2} 2^{r} \\ \Leftrightarrow r - 1 \leq \log_{2} n < r \\ \Leftrightarrow r - 1 = ⌊ \log_{2} n ⌋ \\ \Leftrightarrow T (n) = r = ⌊ \log_{2} n ⌋ + 1 \end{aligned}

🔗

We can apply several of these properties of logarithms to get an alternate expression for

T (n) :

\begin{aligned} ⌊ \log_{2} n ⌋ + 1 & = ⌊ \log_{2} n + 1 ⌋ \\ = ⌊ \log_{2} n + \log_{2} 2 ⌋ \\ = ⌊ \log_{2} 2 n ⌋ \end{aligned}

🔗

If the time that was assigned to Step 1 of the binary search algorithm is changed, we wouldn’t expect the form of the solution to be very different. If

T (n) = a + T (⌊ n / 2 ⌋)

with

T (0) = c,

then

T (n) = c + a ⌊ \log_{2} 2 n ⌋ .

🔗

A further generalization would be to add a coefficient to

T (⌊ n / 2 ⌋) :

T (n) = a + b T (⌊ n / 2 ⌋)

with

T (0) = c,

where

a, b, c \in R,

and

b \neq 0

is not quite as simple to derive. First, if we consider values of

n

that are powers of 2:

\begin{matrix} T (1) = a + b T (0) = a + b c \\ T (2) = a + b (a + b c) = a + a b + c b^{2} \\ T (4) = a + b (a + a b + c b^{2}) = a + a b + a b^{2} + c b^{3} \\ ⋮ \\ T (2^{r}) = a + a b + a b^{2} + \dots + a b^{r} + c b^{r + 1} \end{matrix}

n

is not a power of 2, by reasoning that is identical to what we used to (8.4.1) and (8.4.2),

T (n) = \sum_{k = 0}^{r} a b^{k} + c b^{r + 1}

where

r = ⌊ \log_{2} n ⌋ .

🔗

The first term of this expression is a geometric sum, which can be written in closed form. Let

x

be that sum:

\begin{matrix} x = a + a b + a b^{2} + \dots + a b^{r} \\ b x = a b + a b^{2} + \dots + a b^{r} + a b^{r + 1} \end{matrix}

We’ve multiplied each term of

x

b

and aligned the identical terms in

x

and

b x .

Now if we subtract the two equations,

x - b x = a - a b^{r + 1} \Rightarrow x (1 - b) = a (1 - b^{r + 1})

Therefore,

x = a \frac{b^{r + 1} - 1}{b - 1} .

🔗

A closed form expression for

T (n)

T (n) = a \frac{b^{r + 1} - 1}{b - 1} + c b^{r + 1} where r = ⌊ \log_{2} n ⌋

🔗

Subsection 8.4.3 Analysis of Bubble Sort and Merge Sort

The efficiency of any search algorithm such as the binary search relies on fact that the search list is sorted according to a key value and that the search is based on the key value. There are several methods for sorting a list. One example is the bubble sort. You might be familiar with this one since it is a popular “first sorting algorithm.” A time analysis of the algorithm shows that if

B (n)

is the worst-case time needed to complete the bubble sort on

n

items, then

B (n) = (n - 1) + B (n - 1)

and

B (1) = 0 .

The solution of this relation is a quadratic function

B (n) = \frac{1}{2} (n^{2} - n) .

The growth rate of a quadratic function such as this one is controlled by its squared term. Any other terms are dwarfed by it as

n

gets large. For the bubble sort, this means that if we double the size of the list that we are to sort,

n

changes to

2 n

and so

n^{2}

becomes

4 n^{2}

. Therefore, the time needed to do a bubble sort is quadrupled. One alternative to bubble sort is the merge sort. Here is a simple version of this algorithm for sorting

F = {r (1), r (2), \dots, r (n)},

n \geq 1 .

n = 1,

the list is sorted trivially. If

n \geq 2

then:

🔗

Divide $F$ into $F_{1} = {r (1), \dots, r (⌊ n / 2 ⌋)}$ and $F_{2} = {r (⌊ n / 2 ⌋ + 1), \dots, r (n)} .$
🔗

🔗
Sort $F_{1}$ and $F_{2}$ using a merge sort.
🔗

🔗
Merge the sorted lists $F_{1}$ and $F_{2}$ into one sorted list. If the sort is to be done in descending order of key values, you continue to choose the higher key value from the fronts of $F_{1}$ and $F_{2}$ and place them in the back of $F .$
🔗

🔗

🔗

Note that

F_{1}

will always have

⌊ n / 2 ⌋

items and

F_{2}

will have

⌈ n / 2 ⌉

items; thus, if

n

is odd,

F_{2}

gets one more item than

F_{1} .

We will assume that the time required to perform Step 1 of the algorithm is insignificant compared to the other steps; therefore, we will assign a time value of zero to this step. Step 3 requires roughly

n

comparisons and

n

movements of items from

F_{1}

and

F_{2}

F;

thus, its time is proportional to

n .

For this reason, we will assume that Step 3 takes

n

time units. Since Step 2 requires

T (⌊ n / 2 ⌋) + T (⌈ n / 2 ⌉)

time units,

\begin{matrix} (8.4.9) & T (n) = n + T (⌊ n / 2 ⌋) + T (⌈ n / 2 ⌉) \end{matrix}

with the initial condition

\begin{matrix} (8.4.10) & T (1) = 0 \end{matrix}

🔗

Instead of an exact solution of these equations, we will be content with an estimate for

T (n) .

First, consider the case of

n = 2^{r},

r \geq 1 :

\begin{matrix} T (2^{1}) = T (2) = 2 + T (1) + T (1) = 2 = 1 \cdot 2 \\ T (2^{2}) = T (4) = 4 + T (2) + T (2) = 8 = 2 \cdot 4 \\ T (2^{3}) = T (8) = 8 + T (4) + T (4) = 24 = 3 \cdot 8 \\ ⋮ \\ T (2^{r}) = r 2^{r} = 2^{r} \log_{2} 2^{r} \end{matrix}

🔗

Thus, if

n

is a power of 2,

T (n) = n \log_{2} n .

Now if, for some

r \geq 2,

2^{r - 1} \leq n \leq 2^{r},

then

(r - 1) 2^{r - 1} \leq T (n) < r 2^{r} .

This can be proved by induction on

r .

n

increases from

2^{r - 1}

2^{r},

T (n)

increases from

(r - 1) 2^{r - 1}

r 2^{r}

and is slightly larger than

⌊ n \log_{2} n ⌋ .

The discrepancy is small enough so that

T_{e} (n) = ⌊ n \log_{2} n ⌋

can be considered a solution of (8.4.9) and (8.4.10) for the purposes of comparing the merge sort with other algorithms. Table 8.4.7 compares

B (n)

with

T_{e} (n)

for selected values of

n .

🔗

Table 8.4.7. Comparison of Times for Bubble Sort and Merge Sort

🔗

n	$B (n)$	$T_{e} (n)$
10	45	34
50	1225	283
100	4950	665
500	124750	4483
1000	499500	9966

🔗

Subsection 8.4.4 Derangements

A derangement is a permutation on a set that has no “fixed points”. Here is a formal definition:

🔗

Definition 8.4.8. Derangement.

A derangement of a nonempty set

A

is a permutation of

A

(i.e., a bijection from

A

into

A

) such that

f (a) \neq a

for all

a \in A .

🔗

A = {1, 2, . . ., n},

an interesting question might be “How many derangements are there of

A ?

” We know that our answer is bounded above by

n! .

We can also expect our answer to be quite a bit smaller than

n!

since

n

is the image of itself for

(n - 1)!

of the permutations of

A .

🔗

Let

D (n)

be the number of derangements of

{1, 2, . . ., n} .

Our answer will come from discovering a recurrence relation on

D .

Suppose that

n \geq 3 .

If we are to construct a derangement of

{1, 2, \dots, n},

f,

then

f (n) = k \neq n .

Thus, the image of

n

can be selected in

n - 1

different ways. No matter which of the

n - 1

choices we make, we can complete the definition of

f

in one of two ways. First, we can decide to make

f (k) = n,

leaving

D (n - 2)

ways of completing the definition of

f,

since

f

will be a derangement of

{1, 2, \dots, n} - {n, k} .

Second, if we decide to select

f (k) \neq n,

each of the

D (n - 1)

derangements of

{1, 2, \dots, n - 1}

can be used to define

f .

g

is a derangement of

{1, 2, \dots, n - 1}

such that

g (p) = k,

then define f by

f (j) = {\begin{array}{cc} n & if j = p \\ k & if j = n \\ g (j) & otherwise \end{array}

🔗

Note that with our second construction of

f,

f (f (n)) = f (k) \neq n,

while in the first construction,

f (f (n)) = f (k) = n .

Therefore, no derangement of

{1, 2, . . ., n}

with

f (n) = k

can be constructed by both methods.

🔗

To recap our result, we see that

f

is determined by first choosing one of

n - 1

images of

n

and then constructing the remainder of

f

in one of

D (n - 2) + D (n - 1)

ways. Therefore,

\begin{matrix} (8.4.11) & D (n) = (n - 1) (D (n - 2) + D (n - 1)) \end{matrix}

🔗

This homogeneous second-order linear relation with variable coefficients, together with the initial conditions

D (1) = 0

and

D (2) = 1,

completely defines

D .

Instead of deriving a solution of this relation by analytical methods, we will give an empirical derivation of an approximation of

D (n) .

Since the derangements of

{1, 2 . . ., n}

are drawn from a pool of

n!

permutations, we will see what percentage of these permutations are derangements by listing the values of

n!,

D (n),

and

\frac{D (n)}{n!} .

The results we observe will indicate that as

n

grows,

\frac{D (n)}{n!}

hardly changes at all. If this quotient is computed to eight decimal places, for

n \geq 12,

D (n) / n! = 0.36787944 .

The reciprocal of this number, which

D (n) / n!

seems to be tending toward, is, to eight places, 2.7182818. This number appears in so many places in mathematics that it has its own name,

e .

An approximate solution of our recurrence relation on

D

is then

D (n) \approx \frac{n!}{e} .

🔗

xxxxxxxxxx
 
def D(n):
    if n<=2:
        return n-1
    else:
        return (n-1)*(D(n-2)+D(n-1))
​
list(map(lambda k:[k,D(k),(D(k)/factorial(k)).n(digits=8)],range(1,16)))

🔗

Exercises 8.4.5 Exercises

1.

Solve the following recurrence relations. Indicate whether your solution is an improvement over iteration.

🔗

$n S (n) - S (n - 1) = 0,$ $S (0) = 1 .$
🔗

🔗
$T (k) + 3 k T (k - 1) = 0,$ $T (0) = 1 .$
🔗

🔗
$U (k) - \frac{k - 1}{k} U (k - 1) = 0,$ $k \geq 2,$ $U (1) = 1 .$
🔗

🔗

🔗

Answer.

$S (n) = 1 / n!$
🔗

🔗
$U (k) = 1 / k,$ an improvement.
🔗

🔗
$T (k) = (- 3)^{k} k!,$ no improvement.
🔗

🔗

🔗

2.

Prove that if

n \geq 0,

⌊ n / 2 ⌋ + ⌈ n / 2 ⌉ = n .

(Hint: Consider the cases of

n

odd and

n

even separately.)

🔗

3.

Solve as completely as possible:

🔗

$T (n) = 3 + T (⌊ n / 2 ⌋),$ $T (0) = 0 .$
🔗

🔗
$T (n) = 1 + \frac{1}{2} T (⌊ n / 2 ⌋),$ $T (0) = 2 .$
🔗

🔗
$V (n) = 1 + V ⌊ n / 8 ⌋),$ $V (0) = 0 .$ (Hint: Write $n$ in octal form.)
🔗

🔗

🔗

Answer.

$T (n) = 3 (⌊ \log_{2} n ⌋ + 1)$
🔗

🔗
$T (n) = 2$
🔗

🔗
$V (n) = ⌊ \log_{8} n ⌋ + 1$
🔗

🔗

🔗

4.

Prove by induction that if

T (n) = 1 + T (⌊ n / 2 ⌋),

T (0) = 0,

and

2^{r - 1} \leq n < 2^{r}

r \geq 1,

then

T (n) = r .

🔗

Hint.

Prove by induction on

r .

🔗

5.

Use the substitution

S (n) = T (n + 1) / T (n)

to solve

T (n) T (n - 2) = T (n - 1)^{2}

for

n \geq 2,

with

T (0) = 1,

T (1) = 6,

and

T (n) \geq 0 .

🔗

Answer.

The indicated substitution yields

S (n) = S (n + 1) .

Since

S (0) = T (1) / T (0) = 6,

S (n) = 6

for all

n .

Therefore

T (n + 1) = 6 T (n) \Rightarrow T (n) = 6^{n} .

🔗

6.

Consider the sequence

S

defined by

T (n)^{2} - T (n - 1)^{2} = 1

for

n \geq 1,

with the conditions

T (0) = 10

and

T (n) \geq 0

for all

n .

Use the substitution

G (n) = T (n)^{2}

to solve for

S .

🔗

7.

Solve as completely as possible:

🔗

$Q (n) = 1 + Q (⌊ \sqrt{n} ⌋),$ $n \geq 2,$ $Q (1) = 0 .$
🔗

🔗
$R (n) = n + R (⌊ n / 2 ⌋),$ $n \geq 1,$ $R (0) = 0 .$
🔗

🔗

🔗

Answer.

A good approximation to the solution of this recurrence relation is based on the following observation: $n$ is a power of a power of two; that is, $n$ is $2^{m},$ where $m = 2^{k}$ , then $Q (n) = 1 + Q (2^{m / 2}) .$ By applying this recurrence relation $k$ times we obtain $Q (n) = k .$ Going back to the original form of $n,$ $\log_{2} n = 2^{k}$ or $\log_{2} (\log_{2} n) = k .$ We would expect that in general, $Q (n)$ is $⌊ \log_{2} (\log_{2} n) ⌋ .$ We do not see any elementary method for arriving at an exact solution.
🔗

🔗
Suppose that $n$ is a positive integer with $2^{k - 1} \leq n < 2^{k} .$ Then $n$ can be written in binary form, ${(a_{k - 1} a_{k - 2} \dots a_{2} a_{1} a_{0})}_{two}$ with $a_{k - 1} = 1$ and $R (n)$ is equal to the sum $\underset{i = 0}{\overset{k - 1}{Σ}}$ ${(a_{k - 1} a_{k - 2} \dots a_{i})}_{two} .$ If $2^{k - 1} \leq n < 2^{k},$ then we can estimate this sum to be between $2 n - 1$ and $2 n + 1 .$ Therefore, $R (n) \approx 2 n .$
🔗

🔗

🔗

8.

Suppose Step 1 of the merge sort algorithm did take a significant amount of time. Assume it takes 0.1 time unit, independent of the value of

n .

🔗

Write out a new recurrence relation for $T (n)$ that takes this factor into account.
🔗

🔗
Solve for $T (2^{r}),$ $r \geq 0 .$
🔗

🔗
Assuming the solution for powers of 2 is a good estimate for all $n,$ compare your result to the solution in the text. As $n$ gets large, is there really much difference?
🔗

🔗

🔗

You have attempted 1 of 1 activities on this page.

🔗

Prev Top Next

Section 8.4 Some Common Recurrence Relations

Subsection 8.4.1 A First Basic Example

Subsection 8.4.2 An Analysis of the Binary Search Algorithm

Subsubsection 8.4.2.1

Subsubsection 8.4.2.2 Review of Logarithms

Definition 8.4.1. Base 2 logarithm.

Theorem 8.4.3. Fundamental Properties of Logarithms.

Definition 8.4.4. Logarithms base b.

Theorem 8.4.5. How logarithms with different bases are related.

Proof.

Note 8.4.6.

Subsubsection 8.4.2.3

Subsection 8.4.3 Analysis of Bubble Sort and Merge Sort

Subsection 8.4.4 Derangements

Definition 8.4.8. Derangement.

Exercises 8.4.5 Exercises

1.

2.

3.

4.

5.

6.

7.

8.

Definition 8.4.4. Logarithms base $b$ .