10 TÉCNICAS DE DISEÑO DE ALGORITMOS

6. Regla del producto: Si f1 ∈Θ(g) y f2 ∈Θ(h) ⇒ f1·f2 ∈Θ(g·h).

f (n)
7. Si existe lim = k, dependiendo de los valores que tome k obtenemos:
n →∞ g (n )
a) Si k ≠ 0 y k < ∞ entonces Θ(f) = Θ(g).
b) Si k = 0 los órdenes exactos de f y g son distintos.

1.3.4 Observaciones sobre las cotas asintóticas

1. La utilización de las cotas asintóticas para comparar funciones de tiempo de
ejecución se basa en la hipótesis de que son suficientes para decidir el mejor
algoritmo, prescindiendo de las constantes de proporcionalidad. Sin embargo,
esta hipótesis puede no ser cierta cuando el tamaño de la entrada es pequeño.
2. Para un algoritmo dado se pueden obtener tres funciones que miden su tiempo
de ejecución, que corresponden a sus casos mejor, medio y peor, y que
denominaremos respectivamente Tm(n), T1/2(n) y Tp(n). Para cada una de ellas
podemos dar tres cotas asintóticas de crecimiento, por lo que se obtiene un total
de nueve cotas para el algoritmo.
3. Para simplificar, dado un algoritmo diremos que su orden de complejidad es
O(f) si su tiempo de ejecución para el peor caso es de orden O de f, es decir,
Tp(n) es de orden O(f). De forma análoga diremos que su orden de complejidad
para el mejor caso es Ω(g) si su tiempo de ejecución para el mejor caso es de
orden Ω de g, es decir, Tm(n) es de orden Ω(g).
4. Por último, diremos que un algoritmo es de orden exacto Θ(f) si su tiempo de
ejecución en el caso medio T1/2(n) es de este orden.

1.4 RESOLUCIÓN DE ECUACIONES EN RECURRENCIA

En las secciones anteriores hemos descrito cómo determinar el tiempo de ejecución
de un algoritmo a partir del cómputo de sus operaciones elementales (OE). En
general, este cómputo se reduce a un mero ejercicio de cálculo. Sin embargo, para
los algoritmos recursivos nos vamos a encontrar con una dificultad añadida, pues la
función que establece su tiempo de ejecución viene dada por una ecuación en
recurrencia, es decir, T(n) = E(n), en donde en la expresión E aparece la propia
función T.
Resolver tal tipo de ecuaciones consiste en encontrar una expresión no recursiva
de T, y por lo general no es una labor fácil. Lo que veremos en esta sección es
cómo se pueden resolver algunos tipos concretos de ecuaciones en recurrencia, que
son las que se dan con más frecuencia al estudiar el tiempo de ejecución de los
algoritmos desarrollados según las técnicas aquí presentadas.

1.4.1 Recurrencias homogéneas

Son de la forma:
LA COMPLEJIDAD DE LOS ALGORITMOS 11

a 0 T(n) + a1 T (n − 1) + a2 T (n − 2) + ... + a k T (n − k) = 0
donde los coeficientes ai son números reales, y k es un número natural entre 1 y n.
Para resolverlas vamos a buscar soluciones que sean combinaciones de funciones
exponenciales de la forma:
k
T (n) = c1 p1 (n)r1 + c 2 p2 (n)r2 + ...+ c k pk (n)rk = ∑ c i pi (n)ri ,
n n n n

i =1

donde los valores c1, c2,...,cn y r1, r2, ...,rn son números reales, y p1(n),...,pk(n) son
polinomios en n con coeficientes reales. Si bien es cierto que estas ecuaciones
podrían tener soluciones más complejas que éstas, se conjetura que serían del
mismo orden y por tanto no nos ocuparemos de ellas.
Para resolverlas haremos el cambio xn = T(n), con lo cual obtenemos la
ecuación característica asociada:
k k −1 k− 2
a0 x + a1 x + a2 x + ... + ak = 0 .
Llamemos r1, r2,...,rk a sus raíces, ya sean reales o complejas. Dependiendo del
orden de multiplicidad de tales raíces, pueden darse los dos siguientes casos.

Caso 1: Raíces distintas

Si todas las raíces de la ecuación característica son distintas, esto es, ri ≠ rj si i ≠ j,

entonces la solución de la ecuación en recurrencia viene dada por la expresión:
k
T (n) = c1 r1 + c 2 r2 + ... + ck rk = ∑ ci ri
n n n n

i=1

donde los coeficientes ci se determinan a partir de las condiciones iniciales.

Como ejemplo, veamos lo que ocurre para la ecuación en recurrencia definida

para la sucesión de Fibonacci:
T(n) = T(n–1) + T(n–2), n ≥ 2
con las condiciones iniciales T(0) = 0, T(1) = 1. Haciendo el cambio x2 = T(n)
obtenemos su ecuación característica x2 = x + 1, o lo que es igual, x2 – x – 1 = 0,
cuyas raíces son:

1+ 5 1− 5
r1 = , r2 =
2 2
y por tanto
n n
1+ 5  1− 5 
T ( n ) = c1   + c2 


 2  .
 2   
12 TÉCNICAS DE DISEÑO DE ALGORITMOS

Para calcular las constantes c1 y c2 necesitamos utilizar las condiciones iniciales

de la ecuación original, obteniendo:

1+ 5 
0
1− 5 
0

T (0) = c1   + c2 
  2 
 = c1 + c2 = 0
 2     1
1 1  ⇒ c1 = − c2 = .
1+ 5  1− 5   5
T (1) = c1   + c2 
 
 =1
 
 2   2  
Sustituyendo entonces en la ecuación anterior, obtenemos
n n
1 1+ 5  1 1− 5 
T (n) =   −   ∈ Ο(ϕ n ).

5 2   
5  2 

Caso 2: Raíces con multiplicidad mayor que 1

Supongamos que alguna de las raíces (p.e. r1) tiene multiplicidad m>1. Entonces la
ecuación característica puede ser escrita en la forma
(x – r1)m(x – r2)...(x – rk–m+1)
en cuyo caso la solución de la ecuación en recurrencia viene dada por la expresión:
m k
T ( n ) = ∑ ci n i −1r1n + ∑c r n
i i −m +1
i =1 i =m +1

donde los coeficientes c i se determinan a partir de las condiciones iniciales.

Veamos un ejemplo en el que la ecuación en recurrencia es:
T(n) = 5T(n–1) – 8T(n–2) + 4T(n–3), n≥2
con las condiciones iniciales T(k) = k para k = 0, 1, 2. La ecuación característica
que se obtiene es x3 – 5x2 + 8x – 4 = 0, o lo que es igual (x–2)2(x–1) = 0 y por tanto,
T(n) = c12n + c2n2n + c31n.
De las condiciones iniciales obtenemos c1 = 2, c2 = –1/2 y c3 = –2, por lo que
T(n) = 2n+1 – n2n–1 – 2 ∈Θ(n2n).
Este caso puede ser generalizado de la siguiente forma. Si r1,r2,...,rk son las
raíces de la ecuación característica de una ecuación en recurrencia homogénea,
cada una de multiplicidad mi, esto es, si la ecuación característica puede expresarse
como:
m m m
(x − r1 ) 1 (x − r2 ) 2 ...(x − rk ) k = 0 ,
entonces la solución a la ecuación en recurrencia viene dada por la expresión:
LA COMPLEJIDAD DE LOS ALGORITMOS 13

m1 m2 mk
T (n) = ∑c
i =1
1i n r + ∑ c 2 i n r + ... + ∑ c ki n i −1 rkn .
i−1 n
1
i=1
i −1
2
n

i =1

1.4.2 Recurrencias no homogéneas

Consideremos una ecuación de la forma:
n
a 0 T(n) + a1 T(n −1) + ... + ak T(n − k) = b p(n)
donde los coeficientes ai y b son números reales, y p(n) es un polinomio en n de
grado d. Una primera idea para resolver la ecuación es manipularla para convertirla
en homogénea, como muestra el siguiente ejemplo.
Sea la ecuación T(n) – 2T(n–1) = 3n para n ≥ 2, con las condiciones iniciales
T(0) = 0 y T(1) = 1. En este caso b = 3 y p(n) = 1, polinomio en n de grado 0.
Podemos escribir la ecuación de dos formas distintas. En primer lugar, para n+1
tenemos que
T(n+1) – 2T(n) = 3n+1.
Pero si multiplicamos por 3 la ecuación original obtenemos:
3T(n) – 6T(n–1) = 3n+1
Restando ambas ecuaciones, conseguimos
T(n+1) – 5T(n) + 6T(n–1) = 0,
que resulta ser una ecuación homogénea cuya solución, aplicando lo visto
anteriormente, es
T(n) = 3n – 2n ∈Θ(3n).
Estos cambios son, en general, difíciles de ver. Afortunadamente, para este tipo
de ecuaciones también existe una fórmula general para resolverlas, buscando sus
soluciones entre las funciones que son combinaciones lineales de exponenciales, en
donde se demuestra que la ecuación característica es de la forma:
k k −1 k −2 d +1
(a0 x + a1 x + a2 x + ... + ak )(x − b) = 0,
lo que permite resolver el problema de forma similar a los casos anteriores.

Como ejemplo, veamos cómo se resuelve la ecuación en recurrencia que plantea

el algoritmo de las torres de Hanoi:
T(n) = 2T(n–1) + n.
Su ecuación característica es entonces (x–2)(x–1)2 = 0, y por tanto
T(n) = c12n + c21n +c3n1n ∈Θ(2n).
Generalizando este proceso, supongamos ahora una ecuación de la forma:
14 TÉCNICAS DE DISEÑO DE ALGORITMOS

n n n
a 0 T(n) + a1 T(n −1) + ... + ak T(n − k) = b1 p1 (n) + b 2 p2 (n) + ... + bs ps (n)
donde como en el caso anterior, los coeficientes ai y bi son números reales y pj(n)
son polinomios en n de grado dj. En este caso también existe una forma general de
la solución, en donde se demuestra que la ecuación característica es:
k k −1 k −2 d 1 +1 d 2 +1 d s +1
(a 0 x + a1 x + a2 x + ... + ak )(x − b1 ) (x − b2 ) ...(x − bs ) = 0.
Como ejemplo, supongamos la ecuación
T(n) = 2T(n–1) + n + 2n, n≥1,
con la condición inicial T(0) = 1. En este caso tenemos que b1 = 1, p1(n) = n,
b2 = 2 y p2(n) = 1, por lo que su ecuación característica es (x–2)2(x–1)2 = 0, lo que
da lugar a la expresión final de T(n):
T(n) = –2 – n + 2n+1 + n2n ∈Θ(n2n).

1.4.3 Cambio de Variable

Esta técnica se aplica cuando n es potencia de un número real a, esto es, n = ak. Sea
por ejemplo, para el caso a = 2, la ecuación T(n) = 4T(n/2) + n, donde n es una
potencia de 2 (n > 3), T(1) = 1, y T(2) = 6.
Si n = 2k podemos escribir la ecuación como:
T(2k) = 4T(2k–1) + 2k.
Haciendo el cambio de variable tk = T(2k) obtenemos la ecuación
tk = 4tk–1 + 2k
que corresponde a una de las ecuaciones estudiadas anteriormente, cuya solución
viene dada por la expresión
tk = c1(2k)2 + c22k.
Deshaciendo el cambio que realizamos al principio obtenemos que
T(n) = c1n2 + c2n.
Calculando entonces las constantes a partir de las condiciones iniciales:
T(n) = 2n2 – n ∈Θ(n2).

1.4.4 Recurrencias No Lineales

En este caso, la ecuación que relaciona T(n) con el resto de los términos no es
lineal. Para resolverla intentaremos convertirla en una ecuación lineal como las que
hemos estudiado hasta el momento.
Por ejemplo, sea la ecuación T(n) = nT 2(n/2) para n potencia de 2, n > 1, con la
condición inicial T(1) = 1/3. Llamando tk = T(2k), la ecuación queda como
LA COMPLEJIDAD DE LOS ALGORITMOS 15

k k 2 k −1 k 2
t k = T(2 ) = 2 T (2 ) = 2 t k −1 ,
que no corresponde a ninguno de los tipos estudiados. Necesitamos hacer un
cambio más para transformar la ecuación. Tomando logaritmos a ambos lados y
haciendo el cambio uk = log tk obtenemos
uk – 2uk–1 = k,
ecuación en recurrencia no homogénea cuya ecuación característica asociada es
(x–2)(x–1)2 = 0. Por tanto,
uk = c12k + c2 + c3k.
Necesitamos ahora deshacer los cambios hechos. Primero uk = log tk
k
+ c2 +c 3 k
t k = 2c1 2
y después tk = T(2k). En consecuencia
c1n +c 2 +c 3 log n
T(n) = 2 .
Para calcular las constantes necesitamos las condiciones iniciales. Como sólo
disponemos de una y tenemos tres incógnitas, usamos la ecuación en recurrencia
original para obtener las restantes:
T(2) = 2T 2(1) = 2/9.
T(4) = 4T 2(2) = 16/81.
Con esto llegamos a que c1 = log(4/3) = 2 – log3, c2 = –2, c3 = –1 y por
consiguiente:

22n
T (n) = .
4n3n
16 TÉCNICAS DE DISEÑO DE ALGORITMOS

1.5 PROBLEMAS PROPUESTOS

1.1. De las siguientes afirmaciones, indicar cuales son ciertas y cuales no:
(i) n2∈O(n3) (ix) n2∈Ω(n3)
(ii) n3∈O(n2) (x) n3∈Ω(n2)
n+1 n
(iii) 2 ∈O(2 ) (xi) 2n+1∈Ω(2n)
(iv) (n+1)!∈O(n!) (xii) (n+1)!∈Ω(n!)
(v) f(n)∈O(n) ⇒ 2f(n)∈O(2n) (xiii) f(n)∈Ω(n) ⇒ 2f(n)∈Ω(2n)
n n
(vi) 3 ∈O(2 ) (xiv) 3n∈Ω(2n)
(vii) logn ∈O(n1/2) (xv) logn ∈Ω(n1/2)
1/2
(viii) n ∈O(logn) (xvi) n1/2∈Ω(logn)

1.2. Sea a una constante real, 0<a<1. Usar las relaciones ⊂ y = para ordenar los
órdenes de complejidad de las siguientes funciones: nlogn, n2logn, n8, n1+a,
(1+a)n, (n2+8n+log3n)4, n2/logn, 2n.

1.3. La siguiente ecuación recurrente representa un caso típico de un algoritmo

recursivo:

cn k si 1 ≤ n ≤ b
T (n) = 
aT ( n − b) + cn si n > b
k

donde a,c,k son números reales, n,b son números naturales, y a>0, c>0,
k≥0. En general, la constante a representa el número de llamadas recursivas
que se realizan para un problema de tamaño n en cada ejecución del
algoritmo; n–b es el tamaño de los subproblemas generados; y cnk
representa el coste de las instrucciones del algoritmo que no son llamadas
recursivas.
Θ( n k ) si a < 1
 k +1
Demostrar que T ( n ) ∈ Θ( n ) si a = 1
Θ( a n div b ) si a > 1


1.4. La siguiente ecuación recurrente representa un caso típico de Divide y

Vencerás:

cn k si 1 ≤ n < b
T (n ) = 
aT ( n / b) + cn si n ≥ b
k

donde a,c,k son números reales, n,b son números naturales, y a>0, c>0,
k≥0, b>1. La expresión cnk representa en general el coste de descomponer
el problema inicial en a subproblemas y el de componer las soluciones para
producir la solución del problema original.
LA COMPLEJIDAD DE LOS ALGORITMOS 17

Θ( n k ) si a < b k

Demostrar que T ( n ) ∈ Θ( n k log n ) si a = b k
Θ( n logb a ) si a > b k


1.5. Supongamos que disponemos de la siguiente definición de tipo:

CONST n = ...;
TYPE vector = ARRAY [1..n] OF INTEGER;

Consideramos entonces los procedimientos y funciones siguientes:

PROCEDURE Algoritmo1(VAR a:vector);

VAR i,j:CARDINAL;
temp:INTEGER;
BEGIN
FOR i:=1 TO n-1 DO (* 1 *)
FOR j:=n TO i+1 BY -1 DO (* 2 *)
IF a[j-1]>a[j] THEN (* 3 *)
temp:=a[j-1]; (* 4 *)
a[j-1]:=a[j]; (* 5 *)
a[j]:=temp (* 6 *)
END (* 7 *)
END (* 8 *)
END (* 9 *)
END Algoritmo1;

PROCEDURE Algoritmo2(VAR a:vector;c:INTEGER):CARDINAL;

VAR inf,sup,i:CARDINAL;
BEGIN
inf:=1; sup:=n; (* 1 *)
WHILE (sup>=inf) DO (* 2 *)
i:=(inf+sup) DIV 2; (* 3 *)
IF a[i]=c THEN RETURN i (* 4 *)
ELSIF c<a[i] THEN sup:=i-1 (* 5 *)
ELSE inf:=i+1 (* 6 *)
END (* 7 *)
END; (* 8 *)
RETURN 0; (* 9 *)
END Algoritmo2;
18 TÉCNICAS DE DISEÑO DE ALGORITMOS

PROCEDURE Euclides(m,n:CARDINAL):CARDINAL;
VAR temp:CARDINAL;
BEGIN
WHILE m>0 DO (* 1 *)
temp:=m; (* 2 *)
m:=n MOD m; (* 3 *)
n:=temp (* 4 *)
END; (* 5 *)
RETURN n (* 6 *)
END Euclides;

PROCEDURE Misterio(n:CARDINAL);
VAR i,j,k,s:INTEGER;
BEGIN
s:=0; (* 1 *)
FOR i:=1 TO n-1 DO (* 2 *)
FOR j:=i+1 TO n DO (* 3 *)
FOR k:=1 TO j DO (* 4 *)
s:=s+2 (* 5 *)
END (* 6 *)
END (* 7 *)
END (* 8 *)
END Misterio;

a) Calcular sus tiempos de ejecución en el mejor, peor, y caso medio.

b) Dar cotas asintóticas O, Ω y Θ para las funciones anteriores.

1.6. Demostrar las siguientes inclusiones estrictas: O(1) ⊂ O(logn) ⊂ O(n) ⊂

O(nlogn) ⊂ O(n2) ⊂ O(n3) ⊂ O(nk) ⊂ O(2n) ⊂ O(n!).

1.7. a) Demostrar que f ∈O(g) ⇔ g ∈Ω(f).

b) Dar un ejemplo de funciones f y g tales que f∈O(g) pero que f∉Ω(g).
c) Demostrar que ∀a,b>1 se tiene que logan∈Θ(logbn).

1.8. Considérense las siguientes funciones de n:

f1(n) = n2; f2(n) = n2 + 1000n;
n, si n impar  n, si n≤ 100
f 3 (n) =  3 ; f 4 (n) =  3
n , si n par n , si n> 100

Para cada posible valor de i,j indicar si fi∈O(fj) y si fi∈Ω(fj).

LA COMPLEJIDAD DE LOS ALGORITMOS 19

1.9. Resolver las siguientes ecuaciones y dar su orden de complejidad:

a) T(n)=3T(n–1)+4T(n–2) si n>1; T(0)=0; T(1)=1.
n
b) T(n)=2T(n–1)–(n+5)3 si n>0; T(0)=0.
c) T(n)=4T(n/2)+n2 si n>4, n potencia de 2; T(1)=1; T(2)=8.
d) T(n)=2T(n/2)+nlogn si n>1, n potencia de 2.
e) T(n)=3T(n/2)+5n+3 si n>1, n potencia de 2.
f) T(n)=2T(n/2)+logn si n>1, n potencia de 2.
k
g) T(n)=2T(n1/2)+logn con n=22 ; T(2)=1.
h) T(n)=5T(n/2)+(nlogn)2 si n>1, n potencia de 2; T(1)=1.
i) T(n)=T(n–1)+2T(n–2)–2T(n–3) si n>2; T(n)=9n2–15n+106 si n=0,1,2.
j) T(n)=(3/2)T(n/2)–(1/2)T(n/4)–(1/n) si n>2; T(1)=1; T(2)=3/2.
k) T(n)=2T(n/4)+n1/2 si n>4, n potencia de 4.
2
l) T(n)=4T(n/3)+n si n>3, n potencia de 3.

1.10. Suponiendo que T1∈O(f) y que T2∈O(f), indicar cuáles de las siguientes
afirmaciones son ciertas:
a) T1 + T2 ∈O(f).
b) T1 – T2 ∈O(f).
c) T1 / T2 ∈O(1).
d) T1 ∈O(T2).

1.11. Encontrar dos funciones f(n) y g(n) tales que f ∉O(g) y g ∉Ο(f).

1.12. Demostrar que para cualquier constante k se verifica que logkn ∈O(n).

1.13. Consideremos los siguientes procedimientos y funciones sobre árboles.

Calcular sus tiempos de ejecución y sus órdenes de complejidad.

PROCEDURE Inorden(t:arbol); (* recorrido en inorden de t *)

BEGIN
IF NOT Esvacio(t) THEN (* 1
*)
Inorden(Izq(t)); (* 2 *)
Opera(Raiz(t)); (* 3 *)
Inorden(Der(t)) (* 4 *)
END; (* 5 *)
END Inorden;
20 TÉCNICAS DE DISEÑO DE ALGORITMOS

PROCEDURE Altura(t:arbol):CARDINAL; (* altura de t *)

BEGIN
IF Esvacio(t) THEN (* 1 *)
RETURN 0 (* 2 *)
ELSE (* 3 *)
RETURN 1+Max2(Altura(Izq(t)),Altura(Der(t))) (* 4 *)
END (* 5 *)
END Altura;

PROCEDURE Mezcla(t1,t2:arbol):arbol;
(* devuelve un arbol binario de busqueda con los elementos de
los dos arboles binarios de busqueda t1 y t2. La funcion Ins
inserta un elemento en un arbol binario de busqueda *)
BEGIN
IF Esvacio(t1) THEN (* 1 *)
RETURN t2 (* 2 *)
ELSIF Esvacio(t2) THEN (* 3 *)
RETURN t1 (* 4 *)
ELSE (* 5 *)
RETURN Mezcla(Mezcla(Ins(t1,Raiz(t2)),Izq(t2)),
Der(t2)) (* 6 *)
END (* 7 *)
END Mezcla;

Supondremos que las operaciones básicas del tipo abstracto de datos arbol
(Raiz, Izq, Der, Esvacio) son O(1), así como las operaciones Opera
(que no es relevante lo que hace) y Max2 (que calcula el máximo de dos
números). Por otro lado, supondremos que la complejidad de la función Ins
es O(logn).

1.14. Ordenar las siguientes funciones de acuerdo a su velocidad de crecimiento:

n, n , logn, loglogn, log2n, n/logn, n log2n, (1/3)n, (3/2)n, 17, n2.

1  n −1 
1.15. Resolver la ecuación T ( n ) =  ∑ T (i )  + cn, siendo T (0) = 0.
n  i =0 

1.16. Consideremos las siguientes funciones:

CONST n = ...;
TYPE vector = ARRAY[1..n] OF INTEGER;
LA COMPLEJIDAD DE LOS ALGORITMOS 21

PROCEDURE BuscBin(VAR a:vector;

prim,ult:CARDINAL;x:INTEGER):BOOLEAN;
VAR mitad:CARDINAL;
BEGIN
IF (prim>=ult) THEN RETURN a[ult]=x (* 1 *)
ELSE (* 2 *)
mitad:=(prim+ult)DIV 2; (* 3 *)
IF x=a[mitad] THEN RETURN TRUE (* 4 *)
ELSIF (x<a[mitad]) THEN (* 5 *)
RETURN BuscBin(a,prim,mitad-1,x) (* 6 *)
ELSE (* 7 *)
RETURN BuscBin(a,mitad+1,ult,x) (* 8 *)
END (* 9 *)
END (* 10 *)
END BuscBin;

PROCEDURE Sumadigitos(num:CARDINAL):CARDINAL;
BEGIN
IF num<10 THEN RETURN num (* 1 *)
ELSE RETURN (num MOD 10)+Sumadigitos(num DIV 10) (* 2 *)
END (* 3 *)
END Sumadigitos;

a) Calcular sus tiempos de ejecución y sus órdenes de complejidad.

b) Modificar los algoritmos eliminando la recursión.
c) Calcular la complejidad de los algoritmos modificados y justificar para
qué casos es más conveniente usar uno u otro.

1.17. Consideremos la siguiente función:

PROCEDURE Raro(VAR a:vector;prim,ult:CARDINAL):INTEGER;

VAR mitad,terc:CARDINAL;
BEGIN
IF (prim>=ult) THEN RETURN a[ult] END;
mitad:=(prim+ult)DIV 2; (* posicion central *)
terc :=(ult-prim)DIV 3; (* num. elementos DIV 3 *)
RETURN a[mitad]+Raro(a,prim,prim+terc)+Raro(a,ult-terc,ult)
END Raro;

a) Calcular el tiempo de ejecución de la llamada a la función Raro(a,1,n),

suponiendo que n es potencia de 3.
b) Dar una cota de complejidad para dicho tiempo de ejecución.