1.

Para los siguientes fragmentos de código algunos en Java, halle su

complejidad BIG O:
a) La complejidad de esta función es O(n^3) debido a que se tienen tres ciclos anidados que
ejecutan n veces cada uno.

b) La complejidad de esta función es O(n) si n es par, ya que solo se ejecutará un ciclo for que
se ejecutará n veces. Si n es impar, la función no ejecutará ningún ciclo for y la complejidad
será constante O(1).

c) La complejidad de esta función es O(n/2) o O(n) porque el ciclo while se ejecuta (n/2) veces.

d) La complejidad de esta función es O(log n) porque el valor de x se duplica en cada iteración,

lo que significa que se necesitan logaritmos base 2 iteraciones para que x sea mayor o igual
que n.

e) La complejidad de esta función es O(n^2) porque hay dos ciclos anidados, cada uno de los
cuales se ejecuta n veces.

f) La complejidad de esta función es O(n^2) porque hay dos ciclos anidados, uno que se ejecuta
n veces y otro que se ejecuta i veces. El peor caso ocurre cuando i=n, lo que da una
complejidad de O(n^2).

g) La complejidad de esta función es O(n log n) debido a que el primer ciclo se ejecuta log2(n)
veces y el segundo ciclo se ejecuta n veces. El producto de estas dos cantidades da una
complejidad de O(n log n).

h) La complejidad de esta función es O(log n log n) porque el primer ciclo se ejecuta log2(n/2)
veces y el segundo ciclo se ejecuta log3(n) veces. El producto de estas dos cantidades da una
complejidad de O(log n log n).

i) La complejidad de esta función es O(n log n) debido a que el primer ciclo se ejecuta n veces y
el segundo ciclo se ejecuta log2(i) veces. En el peor caso, el segundo ciclo se ejecuta log2(n)
veces, lo que da una complejidad de O(n log n).

2. Para los siguientes fragmentos de código algunos en Java, halle su

complejidad BIG O verificando la función T(n) de espacio:
j) La complejidad de este algoritmo es O(n), ya que se realiza un ciclo for que se ejecuta n
veces, y el espacio requerido para almacenar la variable "fact" es O(1).

T(n) = O(n) Espacio: O(1)

k) La complejidad de este algoritmo es O(n), ya que se realiza una llamada recursiva n veces, y
cada llamada requiere espacio para almacenar la variable "n", por lo que el espacio requerido
para la pila de llamadas recursivas es O(n).

T(n) = O(n) Espacio: O(n)

l) La complejidad de este algoritmo es O(n), ya que se realiza un ciclo for que se ejecuta n-1
veces, y el espacio requerido para almacenar las variables "a" y "b" es O(1).
T(n) = O(n) Espacio: O(1)

m) La complejidad de este algoritmo es O(2^n), ya que se realiza dos llamadas recursivas para
calcular el término siguiente de la secuencia de Fibonacci, lo que produce una explosión
exponencial de llamadas recursivas, aunque algunas llamadas pueden ser redundantes. El
espacio requerido para la pila de llamadas recursivas es O(n).

T(n) = O(2^n) Espacio: O(n)

n) La complejidad de este algoritmo es O(e), ya que se realiza un ciclo for que se ejecuta e
veces, y el espacio requerido para almacenar la variable "res" es O(1).

T(n) = O(e) Espacio: O(1)

o) La complejidad de este algoritmo es O(log(e)), ya que se realiza llamadas recursivas de

forma recursiva para calcular la potencia, lo que reduce a la mitad el exponente en cada
llamada recursiva. El espacio requerido para la pila de llamadas recursivas es O(log(e)).

T(n) = O(log(e)) Espacio: O(log(e))