Universidad Nacional Mayor de San Marcos

Facultad de Ingeniería de Sistemas e Informática

Escuela de Ingeniería de Sistemas

PRACTICA
CURSO : Diseño y Análisis de Algoritmos.
No. : Práctica No. 03
TEMA : Práctica de Algoritmos Recursivos
DURACIÓN ESTIMADA : 50 minutos aproximadamente.

I. Objetivos

La presente práctica tiene por objetivos:

● Realizar los ejemplos de Algoritmos Recursivos.
● El empleo eficiente de las matemáticas para asociar a una función conocida que
represente al algoritmo recursivo.

II. Resumen
Emplear adecuadamente las matemáticas para encontrar la función tiempo que representa al
algoritmo recursivo que se asocien a las funciones conocidas.

III. Planteamiento de los problemas y sus soluciones

Exponenciación
Sean a y n dos enteros. Deseamos calcular la exponenciación x = an. Por sencillez
supondremos en toda esta sección que n>0. Si n es pequeño, el algoritmo siguiente resulta
adecuado:

Método CNúmero.Potencia(a, n)
Rpta  1 t=1
Para x desde 1 hasta n hacer
Rpta  Rpta * n t = 6n + 4 ∑𝑛𝑥=1 6 + 4 = 6𝑛 + 4
fPara
Retornar Rpta t=1
fMétodo

• Este algoritmo requiere un tiempo que está en (n), puesto que la instrucción

Resu  Resu * xBase

Página. 1
 Universidad Nacional Mayor de San Marcos
Facultad de Ingeniería de Sistemas e Informática
Escuela de Ingeniería de Sistemas

• Se ejecuta exactamente n veces, siempre y cuando las multiplicaciones cuenten como opera-
ciones elementales (los factores que interviene en la multiplicación sean de un digito).

• Si deseamos manejar operandos más grandes, es preciso tener en cuenta el tiempo necesario
para la multiplicación.

• La observación clave para mejorar exposec consiste en an = (an/2)2 cuando n es par.

 a n =1
a n =  (a n / 2 )
 2
n, par
(a ( n −1) / 2 )2  a 1
 n, impar
Método CNúmero.Potencia(n) →
// a es el atributo con el Valor del Número.
// n es el exponente de la exponenciación.
Si (n = 1) entonces t=1
Retornar n t=1
Sino
Objeto Num ejemplar-de CNúmero t=1
Si (n mod 2 = 0) entonces t=2
Retornar [Num.ExpoDV(n/2)]2 t=3
sino
Retornar a * [Num.ExpoDV((n – 1)/2)]2 t=4
fSi
fSi
fMetodo

Análisis:
• Tenemos que todas las instrucciones a excepción de las llamadas recursivas tienen un tiempo
constante de 1. (incluyendo la multiplicación cuando n es impar)

• Entonces tenemos la función tiempo T(n) = f(n) + t(n/2), donde f(n) es el tiempo del algoritmo
Potencia sin tomar en cuenta las llamadas recursivas, y t(n/2) es el tiempo de la primera llamada
recursiva. Por lo tanto, T(n) = 4 + t(n/2) ...(A)

• Para las llamadas recursivas se tiene que se efectúa una llamada u otra.

• En la primera llamada recursiva se tiene que (Potencia(n/2))2 se tiene un tiempo de n/2

comparaciones para un n par.

Página. 2
 Universidad Nacional Mayor de San Marcos
Facultad de Ingeniería de Sistemas e Informática
Escuela de Ingeniería de Sistemas

• En la segunda llamada recursiva se tiene que (Potencia((n – 1)/2))2 se tiene un tiempo de n/2 -
1 comparaciones para un n impar.

• Por tanto, se tiene un tiempo total de la llamada recursiva es:

• El tiempo para la primera llamada recursiva t(n/2) = 4 + t(n/4)

• El tiempo para la segunda llamada recursiva t(n/4) = 4 + t(n/8)

• El tiempo para la tercera llamada recursiva ➔ t(n/8) = 4+ t(n/16)

Así sucesivamente:

• El tiempo para la penúltima llamada recursiva ➔ t(2) = 1 + t(n/2k)

Sumando todos los factores:

t(n/2) + t(n/4) + t(n/8) + ... + t(2) = 4+ 4+ 4+ ... + 4 + t(n/4) + t(n/8) + ... + t(n/2k)

Entonces:

t(n/2) = 4 + 4 + 4 + ... + 4 + t(n/2k) .. (B)

Pero, como es la última llamada es igual a 1

t(n/2k) = t(1) ➔ n = 2k ➔ log2n = log22k ➔ k = log2n ... (C)

Por tanto, es k = log2n es el número de ciclos requeridos y el número de llamadas recursivas.

(C) en (B)
t(n/2) = 4 + 4 + 4 + ... + 4 + t(1) .. (D)

(D) en (A)

T(n) = 4 + 4 + 4 + 4 + ... + 4 + t(1) = 4*k + t(1) = 4*log2n + 1 ➔ 4*log2n + 1 ∈ O(log2n)

• Siempre y cuando el número de dígitos de los multiplicando sean pequeños, en caso contrario
su tiempo será de cómo mínimo n.

Factoriales

El factorial de un número entero positivo n se define como el producto de los números

comprendidos entre 1 y n. La expresión n! simboliza el factorial de n.

 1 n =1
f (n) = 
n * (n − 1)! n  1
• Entonces, podemos plantear el siguiente ejemplo:

Página. 3
 Universidad Nacional Mayor de San Marcos
Facultad de Ingeniería de Sistemas e Informática
Escuela de Ingeniería de Sistemas

• El algoritmo recursivo del cálculo del factorial es:

Método CNúmero.FactorialRec()
Si (n <= 1) entonces t=1
Página. 4
 Universidad Nacional Mayor de San Marcos
Facultad de Ingeniería de Sistemas e Informática
Escuela de Ingeniería de Sistemas

Retornar 1 // Estado básico t=1

Sino
Objeto Num ejemplar-de CNúmero t=1
Num.EstValor(n-1) t=1
Retornar n*Num.FactorialRec() t=2
// Llamada recursiva
fSi
fMétodo

Análisis:
• Para la primeras instrucciones cuando n es 1 o 0 tenemos O(1)

• Para la llamada recursiva tenemos T(n) = 2 + T(n-1) para n > 1 ... (A)

• Si suponemos que n = n-1 en (A) ➔ T(n-1) = 2 + T(n-2) ....(B)

• Remplazando lo (B) en (A): ➔ T(n) = 2 + 2 + T(n-2) = 4 + T(n-2)

• Por tanto, tenemos: T(n) = 4 + T(n-2) para n > 2 ...(C)

• Si suponemos que n = n-2 en (A) ➔ T(n-2) = 2+ T(n-3) ... (D)

• Remplazando lo (D) en (C): ➔ T(n) = 4 + 2 + T(n-3) = 6 + T(n-3)

• En la siguiente llamada tenemos: T(n) = 6 + T(n-3) para n > 3 ... (E)

• Por tanto en la penúltima llamada tenemos: T(n) = 2*(n-1) + T(1)

• Con lo cual T(n) = 2*n – 2 + 1

• Entonces, O(2*n – 2 + 1 ) = O(n)

• Concluyendo con O(n)

Página. 5
 Universidad Nacional Mayor de San Marcos
Facultad de Ingeniería de Sistemas e Informática
Escuela de Ingeniería de Sistemas

Conversión de Recursivo a Iterativo de las Torres de Hanoi

Método CTorres.Hanoi (nDiscos, Origen, Destino, Auxiliar)

Tope  0
Band  Falso
Mientras (Band = Falso) Hacer
Mientras (nDiscos > 1) Hacer
// Guardar en la pila los valores actuales
Tope  Tope + 1
PilaN[Tope]  nDiscos
PilaO[Tope]  Origen
PilaD[Tope]  Destino
PilaA[Tope]  Auxiliar
// Mover N-1 discos de la torre de Origen a la torre Auxiliar
nDiscos  nDiscos - 1
VarAux  Destino
Destino  Auxiliar
Auxiliar  VarAux
fMientras
//Mover un Disco
Escribir “Mover de Origen a Destino”
Band  Verdadero
Si (Tope > 0) Entonces
nDiscos  PilaN[Tope]
Origen  PilaO[Tope]
Destino  PilaD[Tope]
Auxiliar  PilaA[Tope]
Tope  Tope – 1
//Mover un Disco
Escribir “Mover de Origen a Destino”
//Mover N-1 Discos de la Torre Auxiliar a Destino
nDiscos  nDiscos - 1
VarAux  Origen
Origen  Auxiliar
Auxiliar  VarAux
Band  Falso
fSi
fMientras
fMétodo

Página. 6