Universidad Tecnológica Metropolitana

Facultad de Ingeniería

Departamento de Informática

TAT Nº3
Algoritmos de Ordenamiento (AO)

Integrantes : -Nicolás Arratia Vera

-Catherine González Lara
-Oscar León Trureo
-Cristóbal Pérez González
-Sebastián Menéndez Sáez

Profesor : Sr. Oscar Magna V.

Asignatura : Computación Paralela

Grupo : N° 2

Fecha : 28 de Noviembre del 2013

Tabla de Contenidos
1. Introducción ................................................................................................................................ 4
2. Desarrollo .................................................................................................................................... 5
2.1. Descripción de los AO y su complejidad algorítmica teórica .............................................. 5
2.1.1. BubbleSort ................................................................................................................... 5
2.1.2. InsertionSort................................................................................................................ 6
2.1.3. SelectionSort ............................................................................................................... 6
2.1.4. QuickSort ..................................................................................................................... 6
2.1.5. ShellSort ...................................................................................................................... 7
2.1.6. HeapSort...................................................................................................................... 8
2.1.7. MergeSort ................................................................................................................... 8
2.2. Análisis operacional de los AO de forma secuencial (N vs T(N)) ......................................... 8
2.2.1. BubbleSort ................................................................................................................... 8
2.2.2. InsertionSort................................................................................................................ 9
2.2.3. SelectionSort ............................................................................................................... 9
2.2.4. QuickSort ................................................................................................................... 10
2.2.5. ShellSort .................................................................................................................... 11
2.2.6. HeapSort.................................................................................................................... 11
2.2.7. MergeSort ................................................................................................................. 12
2.3. Análisis operacional de los AO de forma paralela (Nº de Procesos/Nodos vs T(N)) ......... 13
2.3.1. BubbleSort ................................................................................................................. 13
2.3.2. InsertionSort.............................................................................................................. 13
2.3.3. SelectionSort ............................................................................................................. 14
2.3.4. QuickSort ................................................................................................................... 15
2.3.5. ShellSort .................................................................................................................... 15
2.3.6. HeapSort.................................................................................................................... 16
2.3.7. MergeSort ................................................................................................................. 17
2.4. Análisis grafico de los AO (secuencial y paralelo) (N vs T(N)) ........................................... 17
2.4.1. BubbleSort ................................................................................................................. 17
2.4.2. InsertionSort.............................................................................................................. 19
2.4.3. SelectionSort ............................................................................................................. 20
2.4.4. QuickSort ................................................................................................................... 22

2
 2.4.5. ShellSort .................................................................................................................... 23
2.4.6. HeapSort.................................................................................................................... 25
2.4.7. MergeSort ................................................................................................................. 26
2.5. Análisis teórico que permita concluir el por qué es conveniente paralelizar AO ............. 27
2.6. Análisis de Métricas de Desempeño (Speedup, Eficiencia y Coste) .................................. 28
2.6.1. BubbleSort ................................................................................................................. 28
2.6.2. InsertionSort.............................................................................................................. 29
2.6.3. SelectionSort ............................................................................................................. 31
2.6.4. QuickSort ................................................................................................................... 32
2.6.5. ShellSort .................................................................................................................... 33
2.6.6. HeapSort.................................................................................................................... 34
2.6.7. MergeSort ................................................................................................................. 36
2.7. Desarrollo de un análisis teórico y operacional global y concluya al respecto ................. 37
3. Bibliografía ................................................................................................................................ 39
4. Anexo......................................................................................................................................... 40
4.1. Métricas de rendimiento................................................................................................... 40

3
 1. Introducción

En la computación y las matemáticas los algoritmos de ordenamiento (los cuales ahora

llamaremos AO) son los que sitúan elementos de una lista o vector dado, a una secuencia
u ordenamiento (por lo general por peso, o numeración), esto quiere decir que los
resultados de salidas deben ser un reordenamiento de los datos de entrada, y que estos
satisfagan la relación de orden entregada. Como se conoce, las relaciones de orden más
comunes son por orden numérico, de peso o de abecedario. Los distintos tipos de
algoritmos de ordenamientos, al final nos entregan los mismos resultados, pero sin
embargo existen algoritmos más eficientes y de menor costo que otros.

En cuanto al presente informe, se centrara principalmente en el análisis de los métodos

más populares de ordenamiento, analizando la cantidad de comparaciones que realiza
cada uno, la complejidad teórica de cada uno de estos, el tiempo que demoran obtener la
respuesta los distintos algoritmos implementados, tanto a nivel secuencial como paralelo,
con la intención fundamental de compararlos y observar si existen mejoras en el
funcionamiento, además el por qué ocurren estas mejoras en los tiempos de respuesta.

Cabe destacar que en cuanto a la implementación de los distintos algoritmos se utilizara

el lenguaje C y C++, además de la utilización de MPI para la paralelización de los distintos
AO.

El desarrollo de la problemática expuesta tiene como objetivo conocer más a fondo los
distintos métodos de ordenamiento existente, desde el más simple al más complejo,
además de la utilización de todos los tópicos analizados en la clase del ramo
Computación Paralela, con la intención de realizar una comparación en el funcionamiento
de los AO con respecto de su Speedup, Eficiencia y Coste.

4
 2. Desarrollo
2.1. Descripción de los AO y su complejidad algorítmica
teórica

2.1.1. BubbleSort

La Ordenación de burbuja (BubbleSort) corresponde es un sencillo AO que funciona

revisando cada elemento de la lista que va a ser ordenada con el siguiente,
intercambiándolos de posición si están en el orden equivocado. Es necesario revisar
varias veces toda la lista hasta que no se necesiten más intercambios, lo cual significa
que la lista está ordenada. Este algoritmo también es conocido como el método del
intercambio directo, dado que solo usa comparaciones para operar elementos.

Este algoritmo consiste en realizar un ordenamiento o reordenamiento de una lista A

de N valores a comparar, términos numerados del 0 al N-1. Este algoritmo para su
funcionamiento consta de dos bucles anidados, uno con el índice I, que da un tamaño
menor al recorrido de la burbuja en sentido inverso de 2 a N, y un segundo bucle con el
índice J, con un recorrido desde 0 hasta N-I, para cada iteración del primer bucle, que
indica el lugar de la burbuja.

La burbuja son dos términos de la lista seguidos (J y J+1) que se comparan, si el

primero es menor que el segundo sus valores se intercambian. Esta comparación se
repite en el centro de los dos bucles, dando lugar a la postre a una lista ordenada, puede
verse que el número de repeticiones solo depende de la cantidad de valores (N), y no del
orden de los términos, por ejemplo, si pasamos al algoritmo una lista ya ordenada, este
realizara todas las comparaciones exactamente igual que para una lista no ordenada, esta
es una característica de este algoritmo.

Por otra parte en cuanto a la complejidad del algoritmo podemos decir que a pesar de que
este es uno de los algoritmos más sencillos de implementar, su orden O (n2) lo hace muy
ineficiente para ser usado en listas compuestas por un gran número de elementos.

5
 2.1.2. InsertionSort

El ordenamiento por inserción (insertion sort) es una manera muy natural y fácil de
ordenamiento, y puede usarse en tareas cotidianas como ordenar un mazo de cartas
numeradas en forma arbitraria.
En cuanto al funcionamiento, inicialmente se tiene un solo elemento, que obviamente es
un conjunto ordenado, después, cuando hay k elementos ordenados de menor a mayor,
se toma el elemento k+1 y se compara con todos los elementos ya ordenados,
deteniéndose cuando se encuentra un elemento menor (todos los elementos mayores han
sido desplazados una posición a la derecha) o cuando ya no se encuentran elementos
(todos los elementos fueron desplazados y este es el más pequeño). En este punto
se inserta el elemento k+1 debiendo desplazarse los demás elementos.

Por otra parte, en cuanto a la complejidad del algoritmo, corresponde a una complejidad
cuadrática O (n²), para ordenar una lista de N elementos.

2.1.3. SelectionSort

Este algoritmo mejora ligeramente el algoritmo de la burbuja, en cuanto a su

funcionamiento este primero que todo busca el mínimo elemento de la lista a ordenar para
luego intercambiarlo con el primero, luego de esto nuevamente se busca el mínimo
elemento pero ahora del resto de la lista para intercambiarlo con el segundo elemento de
la lista, así sucesivamente.

En cuanto a la complejidad del algoritmo es de O (n2) operaciones para ordenar una lista
de N elementos.

2.1.4. QuickSort

El método de ordenamiento QuickSort es actualmente el más eficiente y veloz de los

métodos de ordenación interna. Es también conocido con el nombre del método rápido y
de ordenamiento por partición. Este método es una mejora sustancial del método de
intercambio directo y recibe el nombre de QuickSort por la velocidad con que ordena los
elementos del arreglo.

6
En cuanto al funcionamiento consiste en el siguiente:

Primero se toma un elemento X de una posición cualquiera del arreglo, luego se trata de
ubicar a X en la posición correcta del arreglo, de tal forma que todos los elementos que se
encuentran a su izquierda sean menores o iguales a X y todos los elementos que se
encuentren a su derecha sean mayores o iguales a X. Por ultimo se repiten los pasos
descritos anteriormente, pero ahora para los sub-conjuntos de datos que se encuentran a
la izquierda y a la derecha de la posición correcta de X en el arreglo, siempre y cuando
estos sub-conjuntos contengan más de un elemento. Una vez terminado este proceso
todos los elementos estarán ordenados.

Por otra parte en cuanto a la complejidad este algoritmo en el caso promedio,

corresponde al orden de O(n·log n).

2.1.5. ShellSort

El ordenamiento Shell (ShellSort en inglés) es un AO. Su implementación original,

requiere O (n2) comparaciones e intercambios en el peor caso. Aunque es fácil desarrollar
un sentido intuitivo de cómo funciona este algoritmo, es muy difícil analizar su tiempo de
ejecución.

El ShellSort es una generalización del ordenamiento por inserción, teniendo en cuenta

dos observaciones:

 El ordenamiento por inserción es eficiente si la entrada está "casi ordenada".

 El ordenamiento por inserción es ineficiente, en general, porque mueve los valores
sólo una posición cada vez.

El algoritmo Shell sort mejora el ordenamiento por inserción comparando elementos

separados por un espacio de varias posiciones. Esto permite que un elemento haga
"pasos más grandes" hacia su posición esperada. Los pasos múltiples sobre los datos se
hacen con tamaños de espacio cada vez más pequeños. El último paso del Shell sort es
un simple ordenamiento por inserción, pero para entonces, ya está garantizado que los
datos del vector están casi ordenados.

7
 2.1.6. HeapSort

El ordenamiento por montículos (HeapSort en inglés) es un AO no recursivo, no estable,

con complejidad computacional O (n log n).

Este algoritmo consiste en almacenar todos los elementos del vector a ordenar en un
montículo (Heap), y luego extraer el nodo que queda como nodo raíz del montículo (cima)
en sucesivas iteraciones obteniendo el conjunto ordenado.

El algoritmo, en su implementación habitual, tiene dos fases. Primero una fase de

construcción de un montículo a partir del conjunto de elementos de entrada, y después,
una fase de extracción sucesiva de la cima del montículo.

2.1.7. MergeSort

El algoritmo de ordenamiento por mezcla (MergeSort en inglés) es un AO externo estable

basado en la técnica divide y vencerás. Es de complejidad O(n log n).

Conceptualmente, el ordenamiento por mezcla funciona de la siguiente manera:

1. Si la longitud de la lista es 0 ó 1, entonces ya está ordenada. En otro caso:

2. Dividir la lista desordenada en dos sub-listas de aproximadamente la mitad del
tamaño.
3. Ordenar cada sub-lista recursivamente aplicando el ordenamiento por mezcla.
4. Mezclar las dos sub-listas en una sola lista ordenada.

2.2. Análisis operacional de los AO de forma secuencial (N vs

T(N))
2.2.1. BubbleSort

N Ts (segundos)
100000 20,164
200000 80,684
300000 181,516
400000 327,480

8
 500000 504,784
600000 720,640
700000 982,72
800000 1301,192
900000 1651,660
1000000 1988,372

Figura 1 - Tiempos Secuenciales BubbleSort

Según los datos obtenidos en el desarrollo del algoritmo BubbleSort, se puede observar la
característica fundamental de este, ya que si bien es el algoritmo más fácil de
implementar, es a su vez el algoritmo más costoso, ya que aunque el arreglo estuviera
completamente ordenado tendría el mismo costo que si no lo estuviera, por esta razón es
que el algoritmo muestra los valores más altos de todos (ej. N=1000000 con un tiempo de
1988,372 segundos).

2.2.2. InsertionSort

N Ts (segundos)
100000 13,04
200000 52,15
300000 117,41
400000 208,78
500000 326,08
600000 469,16
700000 638,91
800000 834,28
900000 1056,20
1000000 1304,17

Figura 2 - Tiempos Secuenciales InsertionSort

Si bien este algoritmo entrega valores más positivos que el BubbleSort; no se encuentra
tan alejado este, por la simple razón que InsertionSort también hace un análisis y
comparación completa del arreglo a ordenar, por esta razón ambos algoritmo poseen la
misma complejidad de O (n2).

2.2.3. SelectionSort

9
 N Ts (segundos)
100000 10.91
200000 43.61
300000 99.4
400000 179.49
500000 282.89
600000 408.5
700000 540.21
800000 730.97
900000 926.18
1000000 1113.39
Figura 3 - Tiempos Secuenciales SelectionSort

Este algoritmo junto con el BubbleSort son los algoritmos más costosos en el
ordenamiento de datos, lo cual se ve claramente en los valores obtenidos en la Figura
3.Por otro lado el SelectionSort presenta una pequeña mejora frente al BubbleSort por la
simple razón que en este se realizan menos procesos de intercambio de posiciones de los
datos, pero si se analiza el vector de manera completa.

2.2.4. QuickSort

N Ts (segundos)
100000 7,21
200000 27,45
300000 49,93
400000 78,61
500000 108,56
600000 145,28
700000 388,32
800000 446,45
900000 496,57
1000000 618,855

Figura 4 - Tiempos Secuenciales QuickSort

Si bien QuickSort no es el mejor algoritmo de ordenamiento, mejora notablemente los

tiempos de los algoritmos anteriormente mencionados, pues bien, como trabaja dividiendo
el largo del vector (divide y vencerás), trabaja con vectores cada vez más pequeños y no
de forma entera, es por esto que el algoritmo mejora los tiempos. Lo costoso es que al

10
dividir el vector se trabaja tan solo con una parte de éste y la otra, queda en resumidas
palabras en “stanby”, mientras se trabaja con la parte mencionada.

2.2.5. ShellSort

N Ts (segundos)
100000 4,68
200000 18,74
300000 42,11
400000 74,92
500000 117,32
600000 168,69
700000 230,19
800000 300,74
900000 384,35
1000000 471,91

Figura 5 - Tiempos Secuenciales ShellSort

El comportamiento que demuestra ShellSort en la Fig. 5 es mucho mejor que BubbleSort,

InsertionSort y SelectionSort. Esto lo podemos apreciar al comparar su tiempo con N =
1.000.000 datos, el cual da que ShellSort es 4 veces más rápido que BubbleSort, 2.76
veces más rápido que InsertionSort y 2.35 veces más rápido que SelectionSort.

Por otro lado, esta que ShellSort no puede competir con QuickSort, HeapSort y
MergeSort, esto ocurre netamente porque estos algoritmos mencionados anteriormente
tienen tiempos muy por debajo de ShellSort, solo para mencionar MergeSort con N=
1.000.000 tiene un tiempo de 0.99 seg, lo cual sería cerca del 476 veces más rápido que
ShellSort.

2.2.6. HeapSort

N Ts (segundos)
100000 0.2
200000 0.3
300000 0.5
400000 0.6
500000 0.7
600000 0.9
700000 1.1
800000 1.2

11
 900000 1.3
1000000 1.6

Figura 6 - Tiempos Secuenciales HeapSort

Como se aprecia en la Fig. 6, HeapSort nos muestra valores extraordinarios respectos al

conjunto de algoritmos de ordenamientos más lentos (BubbleSort, InsertionSort,
SelectionSort). Estos tiempos los puede alcanzar, ya que tiene una Complejidad O(n log
n), lo cual es bastante buena en comparación a O(n^2) que posee el conjunto de
algoritmos mencionados anteriormente.

2.2.7. MergeSort

N Ts (segundos)
100000 0,098
200000 0,21
300000 0,301
400000 0,39
500000 0,502
600000 0,62
700000 0,699
800000 0,798
900000 0,9
1000000 0,99

Figura 7 - Tiempos Secuenciales MergeSort

MergeSort se ha caracterizado en ser uno de los mejores algoritmos de ordenamiento

(QuickSort es el otro).Si vemos la Fig. 7, los tiempos que entrega este
son demasiado bajos en comparación con la gran mayoría de los demás algoritmos.
Solo para mencionar lo bueno que es este algoritmo, se comparará con el peor de todos:
BubbleSort, el cual en N= 1 millón tiene 1988,372 seg y MergeSort en este ambiente de
un N = 1 millón posee un tiempo de 0.798 seg, lo que equivale a unas 2490 veces más
rápido que BubbleSort. ¿Impresionante no?

12
 2.3. Análisis operacional de los AO de forma paralela (Nº de
Procesos/Nodos vs T(N))

2.3.1. BubbleSort

N Tp (p = 4) Tp (p = 8) Tp (p = 12)
100000 1,946 1,68 1,527
200000 4,585 2,355 1,945
300000 8,889 3,815 2,804
400000 15,22 5,112 3,197
500000 23,248 7,894 4,092
600000 32,649 11,251 5,074
700000 44,402 13,126 6,917
800000 56,817 16,765 8,36
900000 71,695 21,167 10,374
1000000 87,349 23,261 14,227

Figura 8 - Tiempos Paralelos BubbleSort

Si bien este algoritmo en paralelo sigue arrojando los valores más altos en comparación a
los demás algoritmos implementados en paralelo, podemos establecer que se redujeron
los tiempos considerablemente, además que mientras más recursos o máquinas se
utilizaron más redujeron estos tiempos, todo lo anterior lo podemos ver reflejado en el
análisis de 1000000 de datos, que en secuencial demoraba 1988,372 segundos y ahora
en paralelo usando 12 hilos (3 máquinas) demoró solo 14,227 reduciendo
considerablemente.

2.3.2. InsertionSort

N Tp (p = 4) Tp (p = 8) Tp (p = 12)
100000 0,86 0,25 0,15
200000 3,33 0,91 0,46
300000 7,54 1,97 0,99
400000 13,41 3,45 1,65
500000 20,77 5,35 2,51
600000 29,95 7,66 3,62
700000 40,79 10,38 4,8
800000 53,43 13,49 6,25
900000 67,54 17,68 7,86

13
 1000000 83,49 21,04 9,67

Figura 9 - Tiempos Paralelos InsertionSort

En cuanto a la implementación de este algoritmo en paralelo, por una parte podemos

establecer que es de los que más se demora junto con el BubbleSort y el SelectionSort
por la naturaleza de estos, pero también podemos decir que en un ambiente paralelo se
reduce considerablemente el tiempo de respuesta, sobre todo al aumentar la cantidad de
máquina trabajando, esto se puede reflejar al comparar los valores obtenidos en el
1000000 de datos, donde en secuencial demoró 1304.17 seg, en paralelo con 4 hilos(1
maquina) 83.49, en paralelo con 8 hilos(2 máquina) 21.04 y en por último en donde se
observan las mayores mejoras en paralelo con 12 hilos (3 máquinas) tan solo demoró
9.67 seg.

2.3.3. SelectionSort

N Tp (p = 4) Tp (p = 8) Tp (p = 12)
100000 0.71 0.24 0.14
200000 2.77 0.77 0.41
300000 6.2 1.71 0.83
400000 11.05 2.96 1.39
500000 17.16 4.42 2.22
600000 24.83 6.35 2.98
700000 33.71 8.65 4.19
800000 43.9 11.98 5.31
900000 56.47 14.81 6.53
1000000 69.38 17.61 8.12

Figura 10 - Tiempos Paralelos SelectionSort

Si bien este algoritmo posee la misma naturaleza o complejidad que el BubbleSort

siempre presenta una mejora en el rendimiento, lo que también se puede ver reflejado en
el ambiente paralelo en donde se mejoran los tiempos de respuestas, tiempos que
también están asociados con las máquinas que trabajan, ya que a mayor cantidad de
máquina trabajando en paralelo (en este caso 3 máquinas) mayores son los tiempos de
respuesta.

14
 2.3.4. QuickSort

N Tp (p = 4) Tp (p = 8) Tp (p = 12)
100000 0,33 0,21 0,14
200000 2,94 0,74 0,39
300000 6,52 1,73 0,83
400000 11,7 3,03 1,47
500000 18,29 4,72 2,24
600000 24,21 6,77 3,17
700000 9,17 4,25
800000 12,01 5,57
900000 13,92 6,97
1000000 17,96 8,6

Figura 11 - Tiempos Paralelos QuickSort

Como se aprecia en la figura 11, QuickSort mejora notablemente respecto a sus

antecesores (BubbleSort, InsertionSort y SelectionSort) y en comparación al secuencial
en su forma nativa. Es de suma importancia hacer saber que el algoritmo con más de
700.000 datos causaba un error gravísimo, en donde tras diversas búsquedas se llegó a
la conclusión que se debió al exceso de memoria ocupada y la no liberación de esta, se
trató de distintas formas el solucionar esta problemática, pero al buscar datos del
QuickSort con un mayor número de datos, este causa en la mayoría de sus casos, el
colapso anteriormente mencionado.

En lo demás, al paralelizar el algoritmo, mejora cada vez más con los hilos usados y estos
responden de la manera esperada bajando cada vez más los tiempos, en comparación a
los algoritmos anteriormente señalados.

2.3.5. ShellSort

N Tp (p = 4) Tp (p = 8) Tp (p = 12)
100000 0,29 0,08 0,03
200000 1,16 0,3 0,12
300000 2,62 0,64 0,29
400000 4,7 1,16 0,52
500000 7,28 1,81 0,8

15
 600000 10,45 2,62 1,14
700000 14,21 3,58 1,58
800000 18,61 4,62 2,06
900000 23,54 5,88 2,6
1000000 29,26 7,25 3,19

Figura 12 - Tiempos Paralelos ShellSort

La situación en paralelo mejora bastante los tiempos de ShellSort. .Si miramos los datos,
vemos que las mejoras van creciendo en función de la cantidad de Hilos que se usan.
De manera análoga a los tiempos secuenciales , las cantidad de veces que es rápido
ShellSort a los que se comparó en el apartado Secuencial , sigue manteniéndose , salvo
con los algoritmos QuickSort, HeapSort y MergeSort que lo dejan abajo en relación al
tiempo que se demora en ejecutar con cualquier N a analizar.

2.3.6. HeapSort

N Tp (p = 4) Tp (p = 8) Tp (p = 12)
100000 0.001 0.04 0.05
200000 0.02 0.08 0.1
300000 0.03 0.12 0.14
400000 0.02 0.15 0.18
500000 0.03 0.2 0.23
600000 0.06 0.23 0.28
700000 0.05 0.27 0.32
800000 0.06 0.31 0.37
900000 0.06 0.34 0.42
1000000 0.06 0.38 0.47

Figura 13 - Tiempos Paralelos HeapSort

Por el lado de los tiempos paralelos, se puede apreciar de la Figura 13, que los
tiempos con p =4 son bastante mejores que los de p=8 y=12.Esto sucede porque aquí
interviene un tiempo de comunicación el cual degrada un poco el algoritmo HeapSort
dando valores un poco más altos, pero siguen siendo buenos si los comparamos con el
conjunto de algoritmos más lentos mencionados en el apartado Secuencial de HeapSort.

16
 2.3.7. MergeSort

N Tp (p = 4) Tp (p = 8) Tp (p = 12)
100000 0,001 0,04 0,05
200000 0,01 0,06 0,099
300000 0,02 0,1 0,13
400000 0,03 0,15 0,158
500000 0,02 0,17 0,23
600000 0,05 0,21 0,25
700000 0,05 0,24 0,32
800000 0,03 0,29 0,37
900000 0,05 0,35 0,4
1000000 0,05 0,379 0,478

Figura 14 - Tiempos Paralelos MergeSort

En el ambiente paralelo le pasa lo mismo que HeapSort incrementándose los tiempos por
culpa de la comunicación que hay en el paso de los mensajes. Aunque estos tiempos
hayan empeorado (el que empeore depende de la situación en la cual se toma mucha
importancia o no a este tipo de tiempo, por ejemplo Ordenar Información de los bancos
mundiales), se sigue manteniendo un buen rendimiento con más procesadores. Como
dato que se presenta en la Figura 14 se ve que, para este tipo de muestras el tiempo no
sobrepaso los 0,5 seg, esto lo hace ser uno de los mejores algoritmos a nivel secuencial y
paralelo junto a QuickSort.

2.4. Análisis grafico de los AO (secuencial y paralelo) (N vs

T(N))
2.4.1. BubbleSort

17
 N v/s Tiempo de
Ejecución

Tiempo de ejecución(en segundos)

2500
2000
1500
1000
500
0

Figura 15 Grafica Secuencial BubbleSort.

N v/s Tiempo de Ejecución

100
Tiempo de ejecución(segundos)

90
80
70
60
50
40
30
20
10
0

4 Procesadores
(seg) N
8 Procesadores
(seg)
12 Procesadores
(seg)

Figura 16 Grafica Paralelo BubbleSort.

Desde el punto de vista gráfico, el comportamiento de la curva secuencial tiene un

parentesco a nivel de curva con la que se muestra en el grafico paralelo (p=4).También

18
resaltar que BubbleSort es el que mostro peor desempeño respecto a los demás, lo cual
se ve reflejado en el gráfico. A nivel de complejidad, esta se mantuvo usando p=4,
llegando solamente a bajar los tiempos. Por el contrario, usando p=8 y p=12, el algoritmo
además de bajar los tiempos considerablemente se llega a observar que la complejidad
tiende a bajar hasta comportarse de forma similar o muy parecida a una de complejidad
O(n).

2.4.2. InsertionSort

N v/s Tiempo de
Ejecución
Tiempo de ejecución(en segundos)

1500

1000

500

Figura 17 Grafica Secuencial InsertionSort

19
 N v/s Tiempo de
90
Ejecución
80

Tiempo de ejecución(segundos)
70
60
50
40
30
20
10
0

4 Procesadores N
(seg)
8 Procesadores
(seg)
12 Procesadores
(seg)

Figura 18 Grafica Paralelo InsertionSort

Al interpretar ambos gráficos, se ve que a nivel secuencial y nivel paralelo (p=4) ha y

mejoras si los comparamos con el BubbleSort. También mencionar que esté llega más
rápido de complejidad O (n2 ) a O(n) que BubbleSort en todo el transcurso del gráfico.

2.4.3. SelectionSort

20
 N v/s Tiempo de

Tiempo de ejecución(en segundos)

Ejecución
1200
1000
800
600
400
200
0

Figura 19 Grafica Secuencial SelectionSort

N v/s Tiempo de Ejecución

80
Tiempo de ejecución(segundos)

70
60
50
40
30
20
10
0

4 Procesadores (seg)
N
8 Procesadores (seg)
12 Procesadores (seg)

Figura 20 Grafica Paralelo SelectionSort

21
El comportamiento de SelectionSort a nivel gráfico, se comporta parecido a los analizados
anteriormente (BubbleSort y InsertionSort), solo que estos tiempos son mejores y la
complejidad algorítmica demora menos en llegar a O(N) que ambos.

2.4.4. QuickSort

N v/s Tiempo de
Ejecución
700
Tiempo de ejecución(en segundos)

600
500
400
300
200
100
0

Figura 21 Grafica Secuencial QuickSort

22
 N v/s Tiempo de Ejecución
30

Tiempo de ejecución(segundos)
25
20
15
10
5
0

4 Procesadores (seg)
N
8 Procesadores (seg)

12 Procesadores (seg)

Figura 22 Grafica Paralela SelectionSort

Al analizar los gráficos es de suma importancia hacer notar que el algoritmo no

funcionaba en forma paralela para un p=4 con más de 700.000 datos, pudiendo sacar una
pequeña conclusión de que el grafico se comporta de forma sinusoidal quedándose
estancado a un número mayor de datos. Además, QuickSort con un número alto de p se
comporta de forma log-lineal O(n log n).

2.4.5. ShellSort

23
 N V/S Tiempo
500

Tiempo de ejecución (en segundos)

450
400
350
300
250
200
150
100
50
0

Figura 23 Grafica Secuencial ShellSort

N v/s Tiempo de Ejecucion

35
Tiempo de ejecución(segundos)

30
25
20
15
10
5
0

4 Procesadores (seg) N

8 Procesadores (seg)

12 Procesadores (seg)

Figura 24 Grafica Paralela ShellSort

Como se ha hablado en los algoritmos anteriormente, ShellSort también muestra

tendencia a curvas parecidas. También se tiene que mediante p > 4 se comporta casi

24
lineal, pero mejora notablemente en comparación de los tiempos de los anteriores
algoritmos.

2.4.6. HeapSort

Figura 25 Grafica Secuencial HeapSort

Figura 26 Grafica Paralela HeapSort

25
En esta graficas vemos un cambio notable en comparación a los otros algoritmos, sus
complejidades ya no están parecidas al O(n^2), sino más bien a una recta la cual sube al
trabajar con un mayor número de procesadores (pero muy poco en comparación de los
tiempos). En este caso, se ve reflejado la demora por el tiempo de comunicación que
existe en la red en donde se trabajó. El tiempo de comunicación para 8 procesadores es
de 0.78 ms y para el procesamiento con 12, el tiempo de comunicación de los 3 equipos
es de 1.56ms, lo cual debe ser descontado de cada valor entregado y esto bajaría
notablemente los tiempos, pero los gráficos se comportarían de forma similar a lo
expuesto.

2.4.7. MergeSort

N v/s Tiempo de Ejecución

1,2
Tiempo de ejecución(en segundos)

1
0,8
0,6
0,4
0,2
0

Figura 27 Grafica Secuencial MergeSort

26
 N v/s Tiempo de Ejecución
0,6

Tiempo de ejecución(segundos)
0,5

0,4

0,3

0,2

0,1

4 Procesadores (seg) N
8 Procesadores (seg)
12 Procesadores (seg)

Figura 28 Grafica Paralelo MergeSort

El comportamiento demostrado en los gráficos de MergeSort se vislumbra como este es el

mejor de todos los demás algoritmos. Su grafica secuencial se muestra como una recta, la
cual posee tiempos muy por debajo de los normales (para N = 1.000.000 tiene un T = 0.99
seg).a nivel paralelo, le ocurre algo parecido como a HeapSort, esto netamente debido a
los tiempos de comunicación en la transferencia de los datos al nodo maestro. Lo más
increíble es ver las diferencias sustanciales en los diferentes casos con p, ya que teniendo
p=4, se obtiene el máximo de curva llegando a tiempos bajo 0,1 seg.

2.5. Análisis teórico que permita concluir el por qué es

conveniente paralelizar AO

La conveniencia de paralelizar algoritmos de ordenamientos va a depender si la solución

secuencial responde peor que la solución paralela a plantear. Para poder ver esto,
podemos ver el nivel de detalle a través de la granularidad y divisar cual es el que nos
conviene. Los tipos de granularidad son fina y gruesa. Para hacernos un alcance de lo
que es granularidad, consiste en la cantidad de cómputo con relación a la comunicación.

27
En granularidad fina, las tareas individuales son relativamente pequeñas en término de
tiempo de ejecución. La comunicación entre los procesadores es frecuente. En cambio en
granularidad gruesa la comunicación entre los procesadores es poco frecuente y se
realiza después de largos periodos de ejecución.

De lo anterior, decimos que es conveniente paralelizar algoritmos de ordenamiento

cuando tenemos cantidad de datos gigantescos ya que funcionan mejor y se les pude
sacar el provecho a los recursos que se dispondrán para implementar tal solución
paralela. Puede usarse una Granularidad fina, si y solo si, se tiene una buena red para
que los tiempos de comunicación no se anexen al tiempo de procesamiento de la tarea
que se realiza (momo en el caso que se nos dio en HeapSort) o puede usarse
Granularidad Gruesa, si y solo si, se maneja con computadores capaces de procesar
inmensos volúmenes de datos.

Por el contrario no sería conveniente paralelizar cuando la cantidad de datos es ínfima o

el tiempo secuencial de tal algoritmo es menor que el del paralelo.

2.6. Análisis de Métricas de Desempeño (Speedup, Eficiencia

y Coste)

2.6.1. BubbleSort

N Sp (p = 4) Sp (p = 8) Sp (p = 12)
100000 10,36176773 12,00238095 13,20497708
200000 17,59738277 34,26072187 41,48277635
300000 20,42029475 47,57955439 64,73466476
400000 21,51642576 64,06103286 102,4335314
500000 21,71300757 63,94527489 123,3587488
600000 22,07234525 64,05119545 142,026015
700000 22,13233638 74,86820052 142,0731531
800000 22,90145555 77,61359976 155,6449761
900000 23,03731083 78,02995228 159,2114903

28
 1000000 22,76353479 85,48093375 139,7604555

Figura 29 Speedup BubbleSort

Eficiencia

N Ep (p = 4) Ep (p = 8) Ep (p = 12)
100000 2,590441932 1,500297619 1,650622135
200000 4,399345692 4,282590234 5,185347044
300000 5,105073687 5,947444299 8,091833096
400000 5,379106439 8,007629108 12,80419143
500000 5,428251893 7,993159362 15,4198436
600000 5,518086312 8,006399431 17,75325187
700000 5,533084095 9,358525065 17,75914414
800000 5,725363888 9,70169997 19,45562201
900000 5,759327708 9,753744036 19,90143628
1000000 5,690883696 10,68511672 17,47005693

Figura 30 Eficiencia BubbleSort

Coste

N Cp (p = 4) Cp (p = 8) Cp (p = 12)
100000 7,784 13,44 18,324
200000 18,34 18,84 23,34
300000 35,556 30,52 33,648
400000 60,88 40,896 38,364
500000 92,992 63,152 49,104
600000 130,596 90,008 60,888
700000 177,608 105,008 83,004
800000 227,268 134,12 100,32
900000 286,78 169,336 124,488
1000000 349,396 186,088 170,724
Figura 31 Coste BubbleSort

2.6.2. InsertionSort

Speedup

N Sp (p = 4) Sp (p = 8) Sp (p = 12)
100000 15,1627907 52,16 86,93333333
200000 15,66066066 57,30769231 113,3695652

29
300000 15,57161804 59,59898477 118,5959596
400000 15,56897837 60,51594203 126,5333333
500000 15,69956668 60,94953271 129,9123506
600000 15,66477462 61,24804178 129,6022099
700000 15,66339789 61,55202312 133,10625
800000 15,61444881 61,84432913 133,4848
900000 15,63814036 59,739819 134,3765903
1000000 15,62067313 61,98526616 134,8676319

Figura 32 Speedup InsertionSort

Eficiencia

N Ep (p = 4) Ep (p = 8) Ep (p = 12)
100000 3,790697674 6,52 7,244444444
200000 3,915165165 7,163461538 9,447463768
300000 3,892904509 7,449873096 9,882996633
400000 3,892244594 7,564492754 10,54444444
500000 3,924891671 7,618691589 10,82602922
600000 3,916193656 7,656005222 10,80018416
700000 3,915849473 7,69400289 11,0921875
800000 3,903612203 7,730541142 11,12373333
900000 3,90953509 7,467477376 11,19804919
1000000 3,905168284 7,74815827 11,23896932

Figura 33 Eficiencia InsertionSort

Coste

N Cp (p = 4) Cp (p = 8) Cp (p = 12)
100000 3,44 2 1,8
200000 13,32 7,28 5,52
300000 30,16 15,76 11,88
400000 53,64 27,6 19,8
500000 83,08 42,8 30,12
600000 119,8 61,28 43,44
700000 163,16 83,04 57,6
800000 213,72 107,92 75
900000 270,16 141,44 94,32
1000000 333,96 168,32 116,04

Figura 34 Coste InsertionSort

30
2.6.3. SelectionSort

Speedup

N Sp (p = 4) Sp (p = 8) Sp (p = 12)
100000 15.36619718 45.45833333 77.92857143
200000 15.74368231 56.63636364 106.3658537
300000 16.03225806 58.12865497 119.7590361
400000 16.24343891 60.63851351 129.1294964
500000 16.48543124 64.00226244 127.4279279
600000 16.45187273 64.33070866 137.0805369
700000 16.02521507 62.45202312 128.928401
800000 16.65079727 61.01585977 137.6591337
900000 16.40127501 62.53747468 141.8346095
1000000 16.04770827 63.22487223 137.1169951

Figura 35 Speedup SelectionSort

Eficiencia

N Ep (p = 4) Ep (p = 8) Ep (p = 12)
100000 3.841549296 11.36458333 19.48214286
200000 3.935920578 14.15909091 26.59146341
300000 4.008064516 14.53216374 29.93975904
400000 4.060859729 15.15962838 32.2823741
500000 4.121357809 16.00056561 31.85698198
600000 4.112968184 16.08267717 34.27013423
700000 4.006303767 15.61300578 32.23210024
800000 4.162699317 15.25396494 34.41478343
900000 4.100318753 15.63436867 35.45865237
1000000 4.011927068 15.80621806 34.27924877

Figura 36 Eficiencia SelectionSort

Coste

N Cp (p = 4) Cp (p = 8) Cp (p = 12)
100000 2.84 1.92 1.68
200000 11.08 6.16 4.92
300000 24.8 13.68 9.96
400000 44.2 23.68 16.68
500000 68.64 35.36 26.64

31
 600000 99.32 50.8 35.76
700000 134.84 69.2 50.28
800000 175.6 95.84 63.72
900000 225.88 118.48 78.36
1000000 277.52 140.88 97.44

Figura 37 Coste SelectionSort

2.6.4. QuickSort

Speedup

N Sp (p = 4) Sp (p = 8) Sp (p = 12)
100000 21,84848485 34,33333333 51,5
200000 9,336734694 37,09459459 70,38461538
300000 7,65797546 28,86127168 60,15662651
400000 6,718803419 25,94389439 53,47619048
500000 5,935483871 23 48,46428571
600000 6,000826105 21,45937962 45,829653
700000 42,34678299 91,36941176
800000 37,17318901 80,15260323
900000 35,67313218 71,24390244
1000000 34,45740535 71,95988372

Figura 38 Speedup QuickSort

Eficiencia

N Ep (p = 4) Ep (p = 8) Ep (p = 12)
100000 5,462121212 8,583333333 12,875
200000 2,334183673 9,273648649 17,59615385
300000 1,914493865 7,215317919 15,03915663
400000 1,679700855 6,485973597 13,36904762
500000 1,483870968 5,75 12,11607143
600000 1,500206526 5,364844904 11,45741325
700000 10,58669575 22,84235294
800000 9,293297252 20,03815081
900000 8,918283046 17,81097561
1000000 8,614351336 17,98997093

32
 Figura 39 Eficiencia QuickSort

Coste

N Cp (p = 4) Cp (p = 8) Cp (p = 12)
100000 1,32 1,68 1,68
200000 11,76 5,92 4,68
300000 26,08 13,84 9,96
400000 46,8 24,24 17,64
500000 73,16 37,76 26,88
600000 96,84 54,16 38,04
700000 73,36 51
800000 96,08 66,84
900000 111,36 83,64
1000000 143,68 103,2

Figura 40 Coste QuickSort

2.6.5. ShellSort

Speedup

N Sp (p = 4) Sp (p = 8) Sp (p = 12)
100000 16,13793103 58,5 156
200000 16,15517241 62,46666667 156,1666667
300000 16,07251908 65,796875 145,2068966
400000 15,94042553 64,5862069 144,0769231
500000 16,11538462 64,81767956 146,65
600000 16,14258373 64,38549618 147,9736842
700000 16,19915552 64,29888268 145,6898734
800000 16,16012896 65,0952381 145,9902913
900000 16,32752761 65,36564626 147,8269231
1000000 16,12816131 65,09103448 147,9341693

Figura 41 Speedup ShellSort

33
 Eficiencia

N Ep (p = 4) Ep (p = 8) Ep (p = 12)
100000 4,034482759 14,625 39
200000 4,038793103 15,61666667 39,04166667
300000 4,018129771 16,44921875 36,30172414
400000 3,985106383 16,14655172 36,01923077
500000 4,028846154 16,20441989 36,6625
600000 4,035645933 16,09637405 36,99342105
700000 4,049788881 16,07472067 36,42246835
800000 4,040032241 16,27380952 36,49757282
900000 4,081881903 16,34141156 36,95673077
1000000 4,032040328 16,27275862 36,98354232

Figura 42 Eficiencia ShellSort

Coste

N Cp (p = 4) Cp (p = 8) Cp (p = 12)
100000 1,16 0,64 0,36
200000 4,64 2,4 1,44
300000 10,48 5,12 3,48
400000 18,8 9,28 6,24
500000 29,12 14,48 9,6
600000 41,8 20,96 13,68
700000 56,84 28,64 18,96
800000 74,44 36,96 24,72
900000 94,16 47,04 31,2
1000000 117,04 58 38,28

Figura 43 Coste ShellSort

2.6.6. HeapSort

Speedup

N Sp (p = 4) Sp (p = 8) Sp (p = 12)
100000 200 5 4
200000 15 3.75 3
300000 16.66666667 4.166666667 3.571428571
400000 30 4 3.333333333

34
500000 23.33333333 3.5 3.043478261
600000 15 3.913043478 3.214285714
700000 22 4.074074074 3.4375
800000 20 3.870967742 3.243243243
900000 21.66666667 3.823529412 3.095238095
1000000 26.66666667 4.210526316 3.404255319

Figura 44 Speedup HeapSort

Eficiencia

N Ep (p = 4) Ep (p = 8) Ep (p = 12)
100000 50 0.625 0.333333333
200000 3.75 0.46875 0.25
300000 4.166666667 0.520833333 0.297619048
400000 7.5 0.5 0.277777778
500000 5.833333333 0.4375 0.253623188
600000 3.75 0.489130435 0.267857143
700000 5.5 0.509259259 0.286458333
800000 5 0.483870968 0.27027027
900000 5.416666667 0.477941176 0.257936508
1000000 6.666666667 0.526315789 0.283687943

Figura 45 Eficiencia HeapSort

Coste

N Cp (p = 4) Cp (p = 8) Cp (p = 12)
100000 0.004 0.32 0.6
200000 0.08 0.64 1.2
300000 0.12 0.96 1.68
400000 0.08 1.2 2.16
500000 0.12 1.6 2.76
600000 0.24 1.84 3.36
700000 0.2 2.16 3.84
800000 0.24 2.48 4.44
900000 0.24 2.72 5.04
1000000 0.24 3.04 5.64

Figura 46 Coste HeapSort

35
2.6.7. MergeSort

Speedup

N Sp (p = 4) Sp (p = 8) Sp (p = 12)
100000 98 2,45 1,96
200000 21 3,5 2,121212121
300000 15,05 3,01 2,315384615
400000 13 2,6 2,46835443
500000 25,1 2,952941176 2,182608696
600000 12,4 2,952380952 2,48
700000 13,98 2,9125 2,184375
800000 26,6 2,751724138 2,156756757
900000 18 2,571428571 2,25
1000000 19,8 2,612137203 2,071129707

Figura 47 Speedup MergeSort

Eficiencia

N Ep (p = 4) Ep (p = 8) Ep (p = 12)
100000 24,5 0,30625 0,163333333
200000 5,25 0,4375 0,176767677
300000 3,7625 0,37625 0,192948718
400000 3,25 0,325 0,205696203
500000 6,275 0,369117647 0,181884058
600000 3,1 0,369047619 0,206666667
700000 3,495 0,3640625 0,18203125
800000 6,65 0,343965517 0,17972973
900000 4,5 0,321428571 0,1875
1000000 4,95 0,32651715 0,172594142

Figura 48 Eficiencia MergeSort

Coste

N Cp (p = 4) Cp (p = 8) Cp (p = 12)
100000 0,004 0,32 0,6
200000 0,04 0,48 1,188

36
 300000 0,08 0,8 1,56
400000 0,12 1,2 1,896
500000 0,08 1,36 2,76
600000 0,2 1,68 3
700000 0,2 1,92 3,84
800000 0,12 2,32 4,44
900000 0,2 2,8 4,8
1000000 0,2 3,032 5,736

Figura 49 Costo MergeSort

2.7. Desarrollo de un análisis teórico y operacional global y

concluya al respecto

Luego de realizado el presente trabajo, se encontraron un conjunto de conclusiones las

cuales son las siguientes:

 El paralelizar algoritmos de ordenamientos es recomendable cuando se dispone

de cantidad elevadas de datos a ordenar, ya que al analizar las gráficas descritas
se da cuenta de que la baja de los tiempo es notoria a partir del uso de p>4 pero
nos atrevimos a decir que el tiempo bajara al trabajar en paralelo con dos pc y
usando p>8 procesadores.

 Encontramos que en casi todos los casos, los algoritmos paralelos se comportan
mejores que los secuenciales, salvo excepciones en MergeSort y HeapSort que el
tiempo de comunicación, de latencia en este caso, fue mayor a lo esperado y se
vio reflejado en la gráfica respectiva de estos algoritmos.

 La importancia de los tiempos secuenciales entra en juego siempre y cuando se

tomen cantidades de datos muy ínfimas, ya que no será necesario intervenir con
mayor capacidad de cómputo, lo cual generaría mayor tiempo (aquí entra en juego
la comunicación entre los equipos).

37
 Desde el punto de vista de las métricas de desempeño computacional, se ven
reflejados sustancialmente mejoras a nivel de que los algoritmos paralelos logran
más de 2 veces poder cumplir la tarea de los algoritmos secuenciales, salvo la
excepción MergeSort y HeapSort que a nivel de métricas también demuestran un
aumento de los tiempos(Conexión de red paupérrima).

38
3. Bibliografía

 Informática UV- Rendimiento de los sistemas paralelos

(http://informatica.uv.es/iiguia/AAC/AA/apuntes/aic_rendimiento.pdf)
 Conclase – algoritmos de ordenamiento
(http://c.conclase.net/orden/)
 Interactive and cooperative Technologies Lab
(http://ict.udlap.mx/people/ingrid/Clases/IS211/Ordenar.html).

39
 4. Anexo

4.1. Métricas de rendimiento

Tiempo secuencial

Es el tiempo de un algoritmo que funciona en tiempo discretizado, es decir, paso a paso,

definiendo así una secuencia de estados "computacionales" por cada entrada válida
(la entrada son los datos que se le suministran al algoritmo antes de comenzar).

Tiempo paralelo

Es el tiempo que demora en funcionar el algoritmo en p procesadores (p>1).

Speedup

El Speedup es una medida de que tan rápido es un algoritmo paralelo comparado con un
algoritmo secuencial, es decir, representa el incremento de velocidad de un algoritmo
paralelo. Se utiliza para comparar cual es el porcentaje de mejora de tiempo al paralelizar
un algoritmo con respecto a su tiempo secuencial.

Eficiencia

La eficiencia de un algoritmo paralelo se define como el cociente entre el Speed up y el

número p de procesadores. Esto nos da una idea de la porción de tiempo que los
procesadores se dedican a trabajo útil, también entendido como rendimiento. La
eficiencia ideal es 1, y los valores varían entre 0 y 1.

Coste

El coste de un algoritmo se defino en términos de trabajo. Se llama también

producto procesador-tiempo. Su fórmula matemática es la siguiente:

40