TALLER DE EJERCICIOS - ALGORITMICA III

DOCENTE: MSc Ing Yudi Guzmán Ejercicios Nro 05 Fecha: 29-04-2019

REALIZAR EL ANÁLISIS DE EFICIENCIA DE LOS SIGUIENTES ALGORITMOS:

1. Realizar el análisis del siguiente algoritmo que halla el máximo de un conjunto de n

números naturales {a1,…,an}

//ENTRADA: La lista L={a1,…,an}

• PASO1: m ← a1, i ← 2
• PASO2: Si m < ai entonces m ← ai
• PASO3: i ← i + 1
• PASO4:Si i > n FIN; en caso contrario volver al paso 2
//SALIDA: El máximo es m

Análisis del algoritmo:

En el paso 1 se realizan dos operaciones, en el paso 2, en el peor caso, otras dos, en el

paso 3 una y en el paso 4, en el peor caso, dos. Por tanto, cada vez que del paso 4
volvemos al paso 2, serán necesarias 5 operaciones; como, tras aplicar el paso 1, el
bucle 2-4 se ejecuta n -1 veces (hasta que i toma el valor n + 1), el número total de
operaciones que requiere este algoritmo en el peor caso será:

T(n) = 2 + 5(n -1)

Por tanto, el comportamiento asintótico viene dado por la expresión:

T(n) € O(n)

2. Realizar el análisis del siguiente algoritmo, que dado una lista con n números naturales,
se requiere ordenarla de menor a mayor, utilizando el método select sort.

selection_sort (Lista [1…n])

PASO1: Para i ← 1 hasta n - 1 hacer
PASO2: mínimo ← i
PASO3: Para j ← i+1 hasta n hacer
PASO4: Si lista[j] < lista[mínimo] entonces mínimo ← lista [j]
 PASO5: FinSi
PASO6: FinPara
PASO5: Intercambiar (lista[j] y lista[mínimo])
PASO6: FinPara

Análisis del algoritmo:

En la primera iteración, se busca uno por uno en todos los elementos del arreglo, para
ubicar el menor (ascendente)/ mayor (descendente) <según corresponda>; y lo lleva a
la posición 0. Por lo tanto, realiza n -1 comparaciones.

En la segunda iteración, hace lo mismo, pero desde el índice 1 en adelante, se

encuentra que es menor; lo lleva al índice 1 y hace el intercambio. Por lo tanto, realiza
n -2 comparaciones.

En la tercera iteración, hace lo mismo, pero des el índice 2 en adelante, si encuentra el

menor entonces intercambia. Por lo tanto, realiza n -3 comparaciones.

Así sucesivamente, n – i comparaciones

Luego, se determina el total de comparaciones:
(n - 1) + (n - 2) + (n - 3) + … + 1
Luego:
= n(n + 1)/2 – n
= (n2 + n – 2n)/2
=(n2 - n)/2

El select sort realiza (n2 - n)/2 comparaciones.

Teorema: En muchas ocasiones el tiempo requerido por un algoritmo es igual a la suma
de los tiempos parciales de diferentes operaciones que debe realizar; y frecuentemente
los tiempos parciales son o bien constantes, o bien forman una progresión aritmética,
o bien son los cuadrados de los n primeros números naturales. Luego, si c es una
constante, se verifica:
n
Σ i € O(n2)
i=1

El orden de complejidad está en n2.

Entonces: T(n) € O(n2)

3. Realizar el análisis del siguiente algoritmo burbuja, que dada una lista con n números
naturales, se requiere ordenarla de menor a mayor, utilizando el método bubble sort.

//ENTRADA: La lista L={a1,a2,…,an} de n números naturales

 • PASO1: Asignar j ← n, i ← 1
• PASO2: Si i < j entonces (si ai > ai+1 intercambiar ai con ai +1). En caso contrario
(i >= j) ir al PASO4
• PASO3: Asignar i ← i+1 y volver al PASO2
• PASO4: Si j > 2 asignar j ← j - 1 y i ← 1 y volver al PASO2
• PASO5: FIN (La lista L está ordenada)

Análisis del algoritmo:

Los cinco pasos del algoritmo requieren una cantidad constante de operaciones para
ser ejecutados. Sea c la suma de dichas constantes.
El bucle principal del algoritmo (paso 2-4) se ejecuta hasta que j toma el valor 2, y, en
cada ejecución de dicho bucle, se ejecuta el bucle formado por los pasos 2 y 3 siempre
que i sea menor que j.

Por tanto, el tiempo de ejecución del algoritmo verificará el peor caso en:

T(n) <= c(1 + 2 + 3 + … + (n - 1) + n)

<= c ((1 + n)n)/2
<= c/2 n2 + c/2

Y por tanto, se verifica, por el teorema anterior.

Por consiguiente: T(n) € O(n2)

4. Realizar el análisis del siguiente algoritmo recursivo del tipo “divide y vencerás”, que
halla el máximo binario de un conjunto de n números naturales {a i,ai+1,…,aj}, donde n=
2n.

//ENTRADA: La lista L={ai,ai+1,…,aj}

• PASO0: Si i = j entonces mparcial ← ai e ir al paso 5
• PASO1: k ← [ i + j/2] //parte entera de i + j/2
• PASO2: L1 ← {ai,…,ak}, L2 ← {ak+1,…,aj}
• PASO3: m1 ← MAXIMO BINARIO(L1), m2 ← MAXIMO BINARIO(L2)
• PASO4: Si m1>m2 entonces m ← m1. En caso contrario m ← m2
• PASO5: FIN
//SALIDA: El máximo es m

Análisis del algoritmo:

Si llamamos T(n) al tiempo que requiere el algoritmo para hallar el máximo de una lista
de n números, se verifica que el tiempo requerido para ejecutar el paso 3 será 2.T(n/2)
(cuando n sea potencia de dos). Como el número de operaciones que requieren los
pasos 0, 1, 2, 4 y 5 es constante, se verificará que:
 T(n) <= 2.T(n/2) + c

Donde c es una constante. Como t(1) es constante, podemos suponer que T(1) <= c. Por
el teorema:

Teorema del caso donde h(n) = c: Sean a, b, c, números naturales tales que a>=1 y b >
1 y sea f: N → R una función tal que:

f(n) <= a.f(n/b) + c, para todo n=b k, k>0 y f(1)<=c

Y sea S el subconjunto de N: S = {bk / k>=0}

Entonces, se verifica:
(i) Si a = 1, f € O(log n) en S
(ii) Si a <> 1, f € O(nlogba) en S

En consecuencia, por el citado teorema, reemplazando los valores de a y b en T(n); (nlog

22
)=n

T(n) € O(n)

Nótese que algoritmos “divide y vencerás” no es necesario obtener la función tiempo.

5. Método de ordenamiento por mezcla: Realizar el análisis del algoritmo que dados dos
listas de números naturales ordenadas de menor a mayor L 1 = {a1, …, ar} y L2 = {b1, …,
bs} obtener una lista L con los r + s elementos de L1 U L2 ordenados de menor a mayor.

Algoritmo Mezcla (L1, L2)

• PASO1: Asignar i ← 1, j ← 1, k ← 1
• PASO2:
a) Si ai <= bj entonces asignar ck ← ai y si i < r asignar i ← i+1. En caso
contrario asignar ck ← bj y si j < s, asignar j ← j+1
b) Si i = r asignar ar ← bs y si j = s asignar bs ← ar
• PASO3: Asignar k ← k + 1
• PASO4: Si k <= r + s entonces volver al PASO2
• PASO5: FIN
//SALIDA: La lista L = {c1, c2, …, cr+s}

Análisis del algoritmo:

Sea n = r+s. Los cinco pasos del algoritmo requieren en el peor caso una cantidad
constante de operaciones para ser ejecutados. Sea c la suma de dichas constantes
(h(n)=c).
 Por otra parte, el único bucle del algoritmo (paso 2-4) se ejecuta siempre que k sea
menor o igual que r + s + 1, es decir n + 1 veces.
n = r+s
Donde: n representa k elementos, tal como L1 representa r elementos y L2 representa
s elementos, entonces:
k = r + s, el paso 3: k = k + 1
k=r+s+1
en el paso 4, el bucle 2-4 se ejecuta mientras que k <= r+s+1, es decir, se ejecutará n+1
veces.

En consecuencia, el número de operaciones T(n) que requiere el proceso del algoritmo

verifica:
T(n) <= (n + 1).c

Por lo tanto: T(n) € O(n)

6. Analizar el algoritmo Mezclas: (algoritmo Mezcla pero en modo recursivo)

//ENTRADA: La lista L = {ai, ai+1, …, aj} de n números naturales

• PASO 0: Si L tiene un solo elemento la lista está ordenada. FIN

• PASO 1: Dividir la lista L en dos listas L1 y L2
Asignar k ← (i+j/2). Donde (i+j/2) representa al mayor entero menor que
(i+j/2).
Sean L1 = { ai, ai+1, …, ak} y L2= { ak+1, ak+2, …, aj}
• PASO 2: Ordenar por separado las listas L1 y L2 utilizando el algoritmo
Mezclas.
• PASO 3: (Mezclar las listas ordenadas obtenidas en el paso 2). Hallar la lista
Mezcla (L1, L2)

Análisis del algoritmo:

Si T(n) es el tiempo que requiere el algoritmo para ordenar una lista de n números en
el peor caso, el paso 2 del algoritmo requerirá un tiempo 2.T(n/2) cuando n sea
potencia de dos. El paso 3, como se acaba de ver en el ejercicio anterior, requiere un
tiempo O(n) y los pasos 1 y 2 se ejecutan en tiempos constantes. Como el paso 3
depende del tamaño de las listas que ordene el paso 2, entonces se verifica que
h(n)=c.n. Por lo tanto, para valores de n que sean potencias de 2 se verifica que:

T(n) <= 2.T(n/2) + c.n

T(1)<=c

En consecuencia, por el teorema (donde h(n)=c.n) que se cita abajo, se verifica:

 T(n) € O(n log n)

Teorema del caso h(n) = c.n

Sean a, b, c, números naturales tales que a>= 1 y b>1 y sea f: N→R una función
monótona creciente tal que f(1)<=c y para todo n=bk, k>0:
f(n) <= a.f(n/b) + c.n

Entonces se verifica:
(i) Si a < b, f € O(n)
(ii) Si a > b, f € O(nlogb a)
(iii) Si a = b, f € O(n logb n)

Nota: El comportamiento asintótico del algoritmo Mezclas es en el peor caso, mejor

que el comportamiento asintótico del algoritmo Burbuja para ordenar una lista de n
números.

7. Realizar el análisis del algoritmo QuickSort, para una lista de n elementos, utilizando el
método de ubicar el pivote en el medio de la lista.

Análisis medio del algoritmo QuickSort:

Suponiendo que se ha determinado el punto medio de la lista para ubicar el Pivote y
que el número total de elementos a ordenar es potencia de dos, es decir, n = 2k. Donde:
k = log2(n), es el número de divisiones que realizará el algoritmo.

Inicialmente, la lista creará dos sub listas aproximadamente de tamaño n/2. El número
total de comparaciones de estas dos sub listas es: 2(n/2) = n.
En la segunda división, el algoritmo procesará 4 sub listas, por tanto, el número total
de comparaciones en esta fase es 4(n/4) = n.
En la tercera división, el algoritmo procesará 8 sub listas, por tanto, el número total de
comparaciones en esta fase es 8(n/8) = n y así sucesivamente hasta i=j, es decir, la lista
ya no se pueda dividir más.

En conclusión, el número total de comparaciones que hace el algoritmo es:

n + n + n + ..... + n = k.n, donde k = log2(n), por tanto el tiempo de ejecución del algoritmo
en el caso medio es O(n.log2n)

De forma similar, si aplicamos el teorema:

Teorema del caso h(n) = c.n
Sean a, b, c, números naturales tales que a>= 1 y b>1 y sea f: N→R una función
monótona creciente tal que f(1)<=c y para todo n=bk, k>0:
f(n) <= a.f(n/b) + c.n
 Entonces se verifica que a = b:
Si a = b, f € O(n logb n)

Por lo tanto, T(n) € O(n log n)

8. Realizar el análisis de algoritmo de búsqueda secuencial, donde dada una lista de n

números naturales L ={a1, …, an} y dado un número natural x, averiguar si x pertenece
a L.

//ENTRADA: La lista L={a1,a2,…,an} de n números naturales y un número

natural x
• PASO1: (Inicialización de variables) Asignar i ← 1
• PASO2: Si ai = x entonces la respuesta es “SI”. FIN
• PASO3: Si i < n entonces asignar i ← i + 1 y volver al PASO2
• PASO4: La respuesta es “NO”. FIN

Análisis del algoritmo:

Los cuatro pasos requieren para su ejecución una cantidad constante de operaciones.
Si llamamos c a la suma de dichas constantes y tenemos en cuenta que la vuelta al paso
2 que aparece en el paso 3 se ejecuta siempre que el valor de i sea menor que n, resulta
entonces que la función tiempo T(n) verificará:

T(n) <= (n – 1).c + c

Por lo que T(n) € O(n)

9. Realizar el análisis de algoritmo Buscar recursivo, donde dada una lista de n números
naturales L ={a1, …, an} y dado un número natural x, averiguar si x pertenece a L.

Algoritmo Buscar (x, L)

//ENTRADA: La lista L={a1,a2,…,an} de n números naturales (n>=1) y un número
natural x
• PASO1: Asignar j ← n
• PASO2: Si aj = x entonces la respuesta es “SI”. FIN
• PASO3: Si j < 1 entonces suprimir aj de la lista L; en caso contrario ir al
PASO5
• PASO4: Buscar (x, L)
• PASO5: La respuesta es “NO”. FIN
//SALIDA: La respuesta obtenida en el paso 2 o en el paso 5.

Análisis del algoritmo Buscar (x, L):

 Todos los pasos salvo el cuarto requieren una cantidad constante de operaciones. Sea
c la suma de todas ellas. Si T(n) es la función tiempo en el peor caso, se verificará:

T(n) <= T(n-1) + c

T(1) <= 1

En consecuencia, T(n) € O(n)

10. Realizar el análisis de algoritmo de búsqueda binaria, asumiendo que los elementos de
la lista L están ordenados de menor a mayor (es decir i < j, entonces a i < aj).

//ENTRADA: La lista L={ai,a i+1,…,a j} de n números naturales ordenados de

menor a mayor y un elemento x
• PASO1: Si i = j comparar ai con x. Si ai = x la respuesta es “SI” y terminar el
algoritmo. Si ai <> x la respuesta es “NO” y termina el algoritmo
• PASO2: Asignar m ← [ i + j/2] // Siendo [ i + j/2] el mayor entero menor que
i + j/2
• PASO3: Comparar x con am. Si x = am la respuesta es “SI” y termina el
algoritmo.
• PASO4: Si x < am asignar j ← m – 1 y volver al PASO1
• PASO5: Si x > am asignar i ← m + 1 y volver al PASO1

Análisis del algoritmo:

Los cinco pasos del algoritmo requieren un tiempo constante para su ejecución. Sea c
la suma de dichas constantes.
Aunque en dos de los pasos está contenida la instrucción “volver al paso 1”; dichos
pasos son mutuamente excluyentes debido a las condiciones: x < am ó x > am que
contienen respectivamente por lo que en cada vuelta al paso 1, considera sólo la mitad
de los elementos de la lista L de partida.

En consecuencia, en el peor caso, se llega a un único elemento entonces el algoritmo

termina en el paso 1. El número de veces que se vuelve al paso 1 es, en el peor caso
sería igual al número de veces que puede dividirse por dos el número n. Si n es potencia
de dos, dicho número será log2 n.

Por lo tanto, la función tiempo del algoritmo en el peor caso verificará:

T(n) <= n/2 ; siendo n = log2 n
T(n) <= c.log 2 n

Por lo que, teniendo en cuenta el teorema: T(n) € O (log n)

11. Analizar el algoritmo Búsqueda binaria recursivo:

 //ENTRADA: La lista L={ai,a i+1,…,a j} de n números naturales ordenados de
menor a mayor y un elemento x
• PASO1: Si i = j comparar x con ai. Si x = ai la respuesta es “SI”. En caso
contrario, la respuesta es “NO”. FIN
• PASO2: Asignar m ← [ i + j/2] // Siendo [ i + j/2] el mayor entero menor que
i + j/2
• PASO3: Si x = am la respuesta es “SI”. FIN
• PASO4: Si x < am asignar j ← m – 1
• PASO5: Si x > am asignar i ← m + 1
• PASO6: Buscar (x, {ai,a i+1,…,a j})
//SALIDA: La respuesta obtenida al finalizar el algoritmo

Análisis del algoritmo:

Los pasoso 1-5 requieren un tiempo constante c. Por tanto, si n es potencia de 2, la
función tiempo se verificará:

T(n) <= T.(n/2) + c

T(1) <= c

En el paso 6 se aplica el algoritmo Buscar a una lista que tiene la mitad de los elementos
que la de la lista original.
En consecuencia, teniendo en cuenta el teorema siguiente:

Teorema del caso donde h(n) = c: Sean a, b, c, números naturales tales que a>=1 y b >1
y sea f: N → R una función tal que:

f(n) <= a.f(n/b) + c, para todo n=b k, k>0 y f(1)<=c

Entonces: T(n) <= T(n/2) + c

Y sea S el subconjunto de N: S = {bk / k>=0}

Entonces, se verifica que a = 1, entonces f € O(log n)

Por lo que, teniendo en cuenta el teorema: T(n) € O (log n)

REVISAR LA SIGUIENTE FUENTE RESPECTO A ANÁLISIS DE COMPLEJIDAD:

Revisar y practicar el capítulo 3. Análisis de complejidad. Libro: Especificación, derivación y

análisis de algoritmos. Autor: Narciso Martí Oliet / Clara María Segura Díaz / José Alberto
Verdejo López. Página 82 – 88. (Caso peor)
REVISAR EJERCICIOS DE RESOLUCIÒN DE RECURRENCIAS

Revisar el capítulo 4. Análisis de algoritmos. Libro: Fundamentos de Algoritmia. Autor: G.

Brassard & P. Bratley. Página 132 – 148.

REVISAR EL ARTÍCULO .PDF DE EJERCICIOS RESUELTOS PUBLICADO EN EL DRIVE.

REVISAR LOS TRABAJOS DE LABORATORIO REALIZADOS.

Algoritmo de Strassen, Algoritmo QuickSort, Algoritmo del árbol binario de búsqueda.