You are on page 1of 15

CENTRO UNIVERSITARIO DE CIENCIAS EXACTAS E INGENIERIAS

Actividad 6
Algoritmos de ordenamiento.
Benuto Castaeda Marcos Giovanni
10/23/2014

Introduccin.
El presente trabajo se trata de un reporte de tiempos de ordenamiento, en el cual se experimentar con diferentes
cantidades de datos y diferentes mtodos de ordenacin, al final estos datos se promediarn y se graficarn para
ser comparados contra los resultados tericos de complejidad algortmica ya proporcionados. Se utilizar el
lenguaje de programacin en C++ para la creacin de arreglos con nmeros al azar y para la implementacin de
los mtodos de Insercin, Mezcla, Burbuja y Quicksort, as como para la generacin de los datos requeridos para
la actividad, que sern mostrados en tablas para su mejor organizacin. Los cdigos utilizados pueden ser
encontrados en la direccin proporcionada al final de este documento.

Contenido.

Para cada uno de los 4 algoritmos de ordenamiento implementados en la actividad 5 (Quicksort, Mezcla,
Brubuja, Insercin), realice experimentos en donde se ordenen de manera ascendente 100 arreglos de
nmeros generados al azar con N=10, 25, 50, 100, 500, 1000, 5000, 10,000 (8000 experimentos en total
para cada algoritmo).
Para cada experimento calcule el tiempo (en segundos) que le tom a la computadora para realizar el
ordenamiento.
Para cada algoritmo y para cada valor de N, calcule el tiempo promedio (en segundos) que le tom a la
computadora para realizar el ordenamiento.
Construya una tabla que muestre el tiempo promedio para cada algoritmo y para cada N
Dibuje una grfica en donde se muestre el comportamiento de los 4 algoritmos para los diferentes valores
de N
Compare los resultados de la tabla y la grfica, con los resultados tericos de complejidad.

Mtodo Insercin.

Definicin.
El ordenamiento por insercin es una manera muy natural de ordenar para un ser humano, y puede usarse
fcilmente para ordenar un mazo de cartas numeradas en forma arbitraria. Requiere O(n) operaciones
para ordenar una lista de n elementos.
Inicialmente se tiene un solo elemento, que obviamente es un conjunto ordenado. Despus
(cuando hay k elementos ordenados de menor a mayor) se toma el elemento k+1 (siguiente elemento) y se
compara con todos los elementos ya ordenados, detenindose cuando se encuentra un elemento menor
(todos los elementos mayores han sido desplazados una posicin a la derecha) o cuando ya no se
encuentran elementos (todos los elementos fueron desplazados y este es el ms pequeo). En este punto
se inserta el elemento k+1 debiendo desplazarse los dems elementos.

Algoritmo.
1. for(i=1; i<TAM; i++)
2.
temp = lista[i];
3.
j = i - 1;
4.
while( (lista[j] > temp) && (j >= 0) )
5.
lista[j+1] = lista[j];
6.
j--;
7.
lista[j+1] = temp;

Donde lista es un arreglo a ordenar, TAM es el tamao de la lista (utilizado como una constante
entera), i y j son contadores, y temp es una variable que guarda elementos de la lista de manera
temporal.

Implementacin (Lista de tamao N).


Para obtener la siguiente tabla, as como las tablas siguientes para cada mtodo, se ha implementado el
mtodo insercin dentro de C++, y se ha medido el tiempo de ejecucin de cada ordenamiento con nuevas
listas ordenadas al azar. Cada resultado fue insertado en un documento con la extensin .csv (comma
separated values) y se ha traspasado a una tabla en Excel, donde se ha calculado el promedio de 100
valores por cada valor de N.

#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

N=10

N=25
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

N=50
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

0
0
0
0
0
0
0
0
0
0
0
0
0
0
0.001
0
0
0
0
0
0
0

N=100
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0.001
0
0
0
0

N=500
0.001
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

N=1000
0.002
0.002
0.002
0
0
0
0
0
0.01
0
0
0.01
0
0
0.01
0
0
0.01
0
0.01
0
0

N=5000
0.066
0.06
0.06
0.07
0.05
0.05
0.06
0.05
0.06
0.06
0.076
0.112
0.071
0.06
0.07
0.06
0.07
0.06
0.06
0.06
0.06
0.07

N=10000
0.374
0.386
0.266
0.26
0.25
0.25
0.25
0.26
0.25
0.26
0.26
0.25
0.27
0.25
0.24
0.26
0.23
0.24
0.26
0.25
0.26
0.26

23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

0
0
0
0
0
0
0
0
0
0
0
0
0.012
0.001
0.001
0.001
0.001
0.001
0.001
0
0.001
0.001
0
0
0
0
0
0.01
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

0.01
0
0
0.01
0
0
0.01
0
0
0.01
0
0
0
0
0.01
0
0.01
0
0
0.01
0
0
0.01
0
0
0
0
0.01
0
0
0.01
0
0
0
0
0
0.01
0
0
0.01
0
0.01
0
0
0.01
0
0
0.01
0
0.01
0
0
0.01
0
0
0.01
0
0
0.01
0.003
0.002
0.003

0.05
0.07
0.06
0.08
0.066
0.054
0.06
0.06
0.06
0.06
0.06
0.05
0.06
0.07
0.05
0.06
0.05
0.06
0.06
0.06
0.064
0.057
0.07
0.06
0.06
0.06
0.061
0.06
0.052
0.067
0.054
0.06
0.07
0.05
0.064
0.057
0.06
0.06
0.05
0.06
0.06
0.06
0.06
0.07
0.05
0.05
0.06
0.06
0.06
0.05
0.07
0.062
0.07
0.05
0.06
0.06
0.06
0.06
0.05
0.07
0.06
0.06

0.26
0.25
0.27
0.27
0.25
0.25
0.25
0.26
0.25
0.26
0.25
0.26
0.271
0.249
0.24
0.25
0.25
0.24
0.272
0.23
0.26
0.272
0.262
0.25
0.262
0.26
0.25
0.26
0.26
0.25
0.26
0.24
0.26
0.26
0.262
0.269
0.26
0.25
0.26
0.25
0.25
0.26
0.25
0.25
0.25
0.25
0.26
0.24
0.25
0.26
0.27
0.25
0.264
0.24
0.25
0.24
0.25
0.27
0.25
0.26
0.24
0.23

85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
Prom

0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0.00001

0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0.00001

0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0.00031

0.003
0.002
0.002
0
0
0
0.01
0
0
0.01
0
0
0.01
0
0
0
0.00291

0.05
0.06
0.06
0.06
0.06
0.05
0.06
0.06
0.05
0.05
0.05
0.06
0.06
0.07
0.06
0.05
0.06033

0.25
0.26
0.26
0.26
0.26
0.26
0.25
0.25
0.26
0.27
0.25
0.294
0.288
0.28
0.27
0.292
0.25863

Observaciones.
No hay resultados notables en las primeras pruebas, puesto que el tiempo de ordenamiento es
mnimo, pero conforme N aumenta de valor, el algoritmo tarda ms tiempo en ejecutarse y el tiempo
de ejecucin vara con mayor frecuencia.

Mtodo Burbuja.

Definicin.
El mtodo de ordenacin funciona revisando cada elemento de la lista que va a ser ordenada con el
siguiente, intercambindolos de posicin si estn en el orden equivocado. Es necesario revisar varias
veces toda la lista hasta que no se necesiten ms intercambios, lo cual significa que la lista est ordenada.
Este algoritmo obtiene su nombre de la forma con la que suben por la lista los elementos durante los
intercambios, como si fueran pequeas "burbujas". Tambin es conocido como el mtodo del intercambio
directo. Dado que solo usa comparaciones para operar elementos, se lo considera un algoritmo de
comparacin, siendo el ms sencillo de implementar.
Este algoritmo es esencialmente un algoritmo de fuerza bruta lgica y su complejidad temporal
en el peor caso es de O(n2).

Algoritmo.
1. for(i=1; i<TAM; i++)
2.
for(j=0 ; j<TAM - 1; j++)
3.
if(lista[j] > lista[j+1])
4.
temp = lista[j];
5.
lista[j] = lista[j+1];
6.
lista[j+1] = temp;

Donde lista es un arreglo a ordenar, TAM es el tamao de la lista (utilizado como una constante
entera), i y j son contadores, y temp es una variable que guarda elementos de la lista de manera
temporal.

Implementacin (Lista de tamao N).

#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

N=10

N=25
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

N=50
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

N=100
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0.01
0
0
0
0
0
0
0
0
0
0.001
0
0
0
0
0
0
0
0.001
0
0
0
0
0
0
0
0

N=500
0.003
0.002
0.002
0.003
0.003
0.004
0.003
0.005
0.002
0.003
0.004
0.003
0.003
0.003
0.003
0.002
0.002
0.002
0.004
0.002
0.003
0.003
0.003
0.002
0.003
0.003
0.003
0.003
0.002
0.003
0.002
0.003
0.003
0.003
0.003
0.003
0.002
0.006
0.003
0.002
0.003
0.003
0.003
0.003
0.003
0.002
0.003
0.003
0.003
0.003
0.003
0.003
0.003
0.003
0.003
0.003
0.002

N=1000
0.01
0.01
0.01
0.01
0.01
0.01
0.01
0.01
0.01
0.01
0.02
0.01
0.01
0.01
0.01
0.01
0.01
0.01
0.02
0.01
0.01
0.01
0.02
0.013
0.014
0.012
0.024
0.024
0.013
0.014
0.012
0.01
0.006
0.01
0.01
0.01
0.01
0.01
0.01
0.01
0.01
0.01
0.01
0.01
0.02
0.01
0.02
0.01
0.01
0.01
0.02
0.01
0.01
0.01
0.01
0.01
0.01

N=5000
0.28
0.3
0.27
0.375
0.306
0.29
0.28
0.29
0.28
0.29
0.29
0.28
0.28
0.27
0.28
0.29
0.28
0.28
0.27
0.26
0.282
0.28
0.28
0.28
0.28
0.29
0.27
0.27
0.28
0.29
0.29
0.28
0.26
0.27
0.27
0.27
0.27
0.27
0.28
0.328
0.276
0.29
0.27
0.28
0.27
0.27
0.28
0.28
0.27
0.27
0.29
0.28
0.27
0.272
0.28
0.28
0.28

N=10000
1.266
1.13
1.16
1.17
1.16
1.15
1.15
1.142
1.13
1.154
1.15
1.15
1.15
1.16
1.15
1.14
1.16
1.15
1.18
1.14
1.14
1.15
1.19
1.14
1.18
1.15
1.16
1.16
1.217
1.183
1.14
1.224
1.17
1.162
1.17
1.14
1.14
1.16
1.14
1.15
1.12
1.14
1.132
1.17
1.162
1.142
1.14
1.15
1.162
1.142
1.17
1.152
1.15
1.182
1.184
1.142
1.16

58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
Prom

0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0.001
0
0
0
0
0
0
0.00001

0
0
0
0
0
0
0
0
0
0
0
0
0
0.01
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0.001
0
0
0
0
0.001
0
0
0
0
0
0
0
0
0.00024

0.003
0.003
0.003
0.004
0.003
0.003
0.003
0.003
0.005
0.003
0.003
0.002
0.003
0.004
0.002
0.003
0.002
0.003
0.003
0.004
0.003
0.003
0.002
0.003
0.004
0.003
0.003
0.003
0.002
0.003
0.003
0.003
0.003
0.002
0.002
0.004
0.003
0.002
0.003
0.003
0.002
0.003
0.003
0.00292

0.01
0.01
0.01
0.02
0.01
0.01
0.01
0.02
0.01
0.01
0.01
0.01
0.01
0.02
0.01
0.01
0.02
0.01
0.01
0.01
0.01
0.01
0.01
0.01
0.01
0.01
0.01
0.01
0.01
0.02
0.01
0.01
0.01
0.01
0.01
0.01
0.02
0.01
0.01
0.01
0.01
0.01
0.01
0.01162

0.29
0.29
0.27
0.29
0.28
0.28
0.29
0.28
0.27
0.28
0.28
0.28
0.27
0.28
0.28
0.28
0.27
0.28
0.29
0.28
0.28
0.27
0.27
0.29
0.28
0.28
0.28
0.28
0.29
0.29
0.27
0.28
0.27
0.29
0.292
0.28
0.29
0.282
0.28
0.29
0.27
0.29
0.29
0.28133

1.14
1.172
1.14
1.162
1.142
1.172
1.14
1.16
1.2
1.19
1.192
1.234
1.18
1.305
1.228
1.549
1.923
1.421
1.497
1.587
1.453
1.666
1.341
1.831
1.356
1.403
1.71
1.453
1.468
1.47
1.573
1.361
1.305
1.4
1.347
1.298
1.487
1.386
1.746
1.739
1.523
1.552
1.356
1.25966

Observaciones.
Debido a su algoritmo, este mtodo tarda un poco ms que el de insercin. Pues aun cuando los datos
se encuentren ordenados, el mtodo burbuja recorre los dos ciclos for hasta terminar.

Mtodo Mezcla.

Definicin.
El algoritmo de ordenamiento por mezcla (merge sort en ingls) es un algoritmo de ordenamiento
externo estable basado en la tcnica divide y vencers. Es de complejidad O(n log n).
Conceptualmente, el ordenamiento por mezcla funciona de la siguiente manera:
1.
2.
3.
4.

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


Dividir la lista desordenada en dos sublistas de aproximadamente la mitad del tamao.
Ordenar cada sublista recursivamente aplicando el ordenamiento por mezcla.
Mezclar las dos sublistas en una sola lista ordenada.

El ordenamiento por mezcla incorpora dos ideas principales para mejorar su tiempo de ejecucin:
1.
2.

Una lista pequea necesitar menos pasos para ordenarse que una lista grande.
Se necesitan menos pasos para construir una lista ordenada a partir de dos listas tambin
ordenadas, que a partir de dos listas desordenadas. Por ejemplo, slo ser necesario
entrelazar cada lista una vez que estn ordenadas.

Algoritmo.
El algoritmo de ordenamiento por mezcla (Mergesort) se divide en dos procesos, primero se divide
en partes iguales la lista:
1. public static void mergesort(int[ ] matrix, int init, int n)
2.
int n1;
3.
int n2;
4.
if (n > 1)
5.
n1 = n / 2;
6.
n2 = n - n1;
7.
mergesort(matrix, init, n1);
8.
mergesort(matrix, init + n1, n2);
9.
merge (matrix, init, n1, n2);

Y el algoritmo que nos permite mezclar los elementos segn corresponda:


1. private static void merge(int[ ] matrix, int init, int n1, int n2)
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.

int[ ] buffer = new int[n1+n2];


int temp = 0;
int temp1 = 0;
int temp2 = 0;
int i;
while ((temp1 < n1) && (temp2 < n2))
if (matrix[init + temp1] < matrix[init + n1 + temp2])
buffer[temp++] = matrix[init + (temp1++)];
else
buffer[temp++] = matrix[init + n1 + (temp2++)];
while (temp1 < n1)
buffer[temp++] = matrix[init + (temp1++)];
while (temp2 < n2)
buffer[temp++] = matrix[init + n1 + (temp2++)];
for (i = 0; i < n1+n2; i++)
matrix[init + i] = buffer[i];

Implementacin.

#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

N=10

N=25
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

0
0
0.001
0
0
0
0
0
0
0
0.001
0
0
0
0
0
0
0.001
0
0
0
0
0
0
0
0
0
0
0.01
0
0
0
0
0
0
0.01
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

N=50
0.001
0
0
0
0
0
0.003
0
0.001
0
0
0
0
0
0
0
0
0.001
0
0
0
0
0
0.001
0
0
0.001
0.001
0
0
0
0
0
0
0.001
0.001
0
0
0.001
0
0
0
0
0
0
0
0
0
0
0
0.001
0
0
0.001
0
0
0

N=100
0
0
0
0
0
0.001
0.001
0
0
0.001
0
0
0
0
0.001
0
0.001
0
0
0.001
0
0
0
0
0.004
0
0
0
0
0
0
0
0
0
0.002
0
0.001
0.001
0
0.001
0.001
0
0
0.001
0
0
0.001
0
0.001
0
0.001
0
0
0.001
0.001
0
0.001

N=500
0.001
0.001
0.001
0.002
0.001
0.001
0.001
0.001
0.001
0.001
0.002
0.001
0.001
0
0
0
0
0
0
0
0
0.01
0
0
0
0.01
0
0.01
0
0
0
0
0
0
0
0
0
0.01
0
0
0
0.01
0
0
0.01
0
0
0.01
0
0
0
0.01
0
0
0.01
0
0

N=1000
0.003
0.003
0.003
0.003
0.002
0.003
0.002
0.001
0
0
0
0.01
0.01
0
0
0.01
0
0.01
0
0
0.01
0
0.01
0
0.01
0
0.01
0
0.01
0
0
0
0
0
0.01
0
0.01
0
0
0
0
0
0
0
0
0
0.01
0
0.01
0
0.01
0
0
0
0.01
0
0.01

N=5000
0.01
0.01
0.02
0.02
0.01
0.02
0.01
0.01
0.01
0.01
0.02
0.01
0.02
0.01
0.02
0.01
0.02
0.01
0.02
0.01
0.02
0.01
0.02
0.01
0.02
0.01
0.02
0.02
0.01
0.02
0.01
0.01
0.02
0.01
0.02
0.01
0.02
0.01
0.01
0.01
0.01
0.01
0.088
0.015
0.018
0.017
0.017
0.018
0.015
0.017
0.015
0.018
0.013
0.012
0.01
0.01
0.01

N=10000
0.042
0.022
0.03
0.03
0.03
0.03
0.03
0.03
0.03
0.032
0.02
0.03
0.02
0.02
0.02
0.02
0.02
0.035
0.031
0.037
0.04
0.043
0.029
0.085
0.031
0.03
0.03
0.03
0.03
0.03
0.03
0.03
0.02
0.02
0.02
0.03
0.03
0.03
0.03
0.03
0.03
0.02
0.02
0.02
0.02
0.03
0.03
0.03
0.03
0.02
0.03
0.03
0.03
0.03
0.03
0.03
0.03

58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
Prom

0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0.01
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0.00033

0
0
0
0
0
0
0
0.002
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0.001
0
0
0.001
0
0
0
0
0
0
0.00018

0
0
0
0
0
0
0
0
0
0.01
0
0
0
0
0
0.01
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0.00043

0
0.01
0
0
0
0
0.01
0
0
0
0.01
0
0
0.01
0
0
0
0
0
0
0
0
0
0
0
0
0
0.01
0
0
0.01
0
0
0
0.01
0
0
0
0
0
0
0
0
0.00175

0
0
0
0
0.01
0
0.01
0
0.01
0
0
0
0
0.01
0
0
0
0
0.01
0
0
0
0.01
0
0
0
0
0
0
0.01
0
0.01
0
0
0
0
0.01
0
0
0
0
0
0
0.0027

0.01
0.01
0.02
0.01
0.02
0.02
0.01
0.02
0.01
0.02
0.01
0.02
0.02
0.02
0.017
0.013
0.01
0.01
0.01
0.02
0.02
0.02
0.01
0.01
0.01
0.01
0.01
0.01
0.01
0.01
0.01
0.01
0.021
0.009
0.02
0.01
0.01
0.02
0.01
0.01
0.01
0.021
0.009
0.01473

0.02
0.03
0.02
0.02
0.03
0.03
0.03
0.03
0.03
0.03
0.02
0.02
0.02
0.02
0.02
0.03
0.03
0.03
0.03
0.03
0.03
0.03
0.03
0.02
0.02
0.03
0.02
0.02
0.02
0.02
0.03
0.03
0.03
0.02
0.02
0.02
0.03
0.02
0.02
0.03
0.03
0.02
0.02
0.02747

Observaciones.
Al principio, con pocos datos, los resultados tienen altibajos y el algoritmo no parece llevar la ventaja
contra los mtodos Burbuja o Insercin. Sin embargo, al trabajar con una mayor cantidad de enteros
se puede afirmar que la diferencia entre ste y los mtodos anteriores es grande, al menos 10 veces
menor, puesto que este algoritmo divide el arreglo tantas veces como sea necesario para hacer menos
repetitivas las comparaciones.

Mtodo Quicksort.

Definicin.
El ordenamiento rpido (quicksort en ingls) es un algoritmo creado por el cientfico britnico en
computacin C. A. R. Hoare basado en la tcnica de divide y vencers, que permite, en promedio,
ordenar n elementos en un tiempo proporcional a n log n.
El algoritmo trabaja de la siguiente forma:

Elegir un elemento de la lista de elementos a ordenar, al que llamaremos pivote.


Resituar los dems elementos de la lista a cada lado del pivote, de manera que a un lado
queden todos los menores que l, y al otro los mayores. Los elementos iguales al pivote
pueden ser colocados tanto a su derecha como a su izquierda, dependiendo de la
implementacin deseada. En este momento, el pivote ocupa exactamente el lugar que le
corresponder en la lista ordenada.
La lista queda separada en dos sublistas, una formada por los elementos a la izquierda del
pivote, y otra por los elementos a su derecha.
Repetir este proceso de forma recursiva para cada sublista mientras stas contengan ms de
un elemento. Una vez terminado este proceso todos los elementos estarn ordenados.

Algoritmo.
void OrdRap (int list[], int lim_inf, int lim_sup)
//
1.
2.
3.
4.

Inicializacin de variables
elem_div = lista[sup];
i = inf - 1;
j = sup;
cont = 1;

// Verificamos que no se crucen los lmites


5. if (inf >= sup)
6.
retornar;
// Clasificamos la sublista
7. while (cont)
8.
while (lista[++i] < elem_div);
9.
while (lista[--j] > elem_div);
10.
if (i < j)
11.
temp = lista[i];
12.
lista[i] = lista[j];
13.
lista[j] = temp;
14.
else
15.
cont = 0;
// Copiamos el elemento de divisin
// en su posicin final
16. temp = lista[i];
17. lista[i] = lista[sup];
18. lista[sup] = temp;
// Aplicamos el procedimiento
// recursivamente a cada sublista
19. OrdRap (lista, inf, i - 1);
20. OrdRap (lista, i + 1, sup);

Implementacin.
#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

N=10

N=25
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

N=50
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

N=100
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0.001
0
0
0
0
0
0
0
0
0

N=500
0
0
0
0
0
0
0
0
0
0
0
0
0
0.001
0
0
0
0.001
0
0
0
0
0
0
0
0
0
0
0
0.001
0
0
0
0.001
0
0
0
0
0
0
0
0
0
0.001
0
0.002
0
0
0
0
0
0
0
0
0
0
0
0
0.001

N=1000
0
0
0
0
0.001
0
0
0
0
0
0.001
0
0
0
0.001
0
0
0.001
0
0.001
0
0
0.001
0.001
0
0
0
0
0
0.001
0
0.001
0
0
0
0
0
0.001
0
0.001
0
0
0
0
0
0
0
0
0
0.001
0.001
0
0.001
0
0
0
0.001
0
0

N=5000
0.001
0.001
0.002
0.001
0.001
0.001
0.002
0.001
0.002
0.001
0.002
0.001
0.002
0.002
0.002
0.001
0.001
0.001
0.002
0.001
0.001
0.001
0.002
0.002
0.002
0.001
0.002
0.002
0.002
0.001
0.001
0.002
0.001
0.001
0.001
0.001
0.001
0.001
0.001
0.003
0.002
0.001
0.002
0.001
0.002
0.001
0.001
0.001
0.001
0.002
0.002
0.001
0.002
0.001
0.002
0.002
0.001
0.002
0.001

N=10000
0.003
0.003
0.003
0.003
0.003
0.004
0.003
0.003
0.002
0.003
0.004
0.003
0.003
0.003
0.002
0.003
0.004
0.003
0.003
0.003
0.003
0.003
0.003
0.002
0.004
0.002
0.002
0.002
0.002
0.002
0.002
0.003
0.003
0.002
0.003
0.003
0.003
0.004
0.002
0.002
0.003
0.003
0.003
0.003
0.003
0.003
0.003
0.003
0.004
0.003
0.002
0.003
0.003
0.003
0.003
0.003
0.003
0.003
0.004

60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
Prom

0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0.001
0
0.00002

0
0
0
0
0
0
0
0.001
0
0
0.001
0
0
0.001
0
0
0
0
0
0
0.001
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0.00012

0
0.001
0.001
0
0.001
0.001
0
0
0
0
0.001
0
0
0
0
0
0.001
0.001
0
0.001
0
0
0
0
0.001
0
0
0
0
0.001
0
0.001
0
0
0
0
0
0
0
0
0
0.00026

0.002
0.002
0.002
0.002
0.002
0.002
0.001
0.001
0.001
0.004
0.001
0.002
0.001
0.001
0.001
0.001
0.001
0.001
0.001
0.002
0.002
0.001
0.055
0.005
0.001
0.001
0.002
0.002
0.002
0.004
0.002
0.001
0.001
0.001
0.001
0.001
0.001
0.001
0.001
0.002
0.001
0.00204

0.002
0.003
0.003
0.003
0.003
0.003
0.002
0.002
0.002
0.002
0.002
0.003
0.003
0.003
0.004
0.002
0.003
0.002
0.004
0.003
0.002
0.004
0.003
0.003
0.002
0.003
0.002
0.003
0.003
0.013
0.007
0.003
0.002
0.002
0.003
0.003
0.003
0.003
0.003
0.003
0.004
0.00299

Observaciones.
El mtodo Quicksort es el ms rpido al ejecutarse, pero a su vez consume ms recursos por la forma
en que utiliza la recursividad, podemos notar que la diferencia entre los primeros resultados y los
ltimos no es mucha, por lo que no es conveniente utilizar este algoritmo cuando se manejan muy
pocos datos.

Anlisis de complejidad.
A continuacin de muestra una grfica con los resultados de cada algoritmo en criterio del promedio de sus
valores de N, despus se muestra una grfica con los valores tericos de los ordenamientos: O(n2) para Burbuja e
Insercion y n log(n) para Quicksort y Mezcla.
1.4

1.2

0.8

Quicksort
Burbuja
Insercin

0.6

Mezcla

0.4

0.2

0
N=10

N=25

N=50

N=100

N=500 N=1000 N=5000 N=10000

Se pueden apreciar las similitudes entre los mtodos recursivos y los no recursivos. Adems de la eficiencia
de cada mtodo, siendo Quicksort el ms veloz, y Burbuja el ms lento de ellos.
El valor promedio mximo en el tiempo para los 10,000 valores supera por poco al segundo. No obstante,
cuando se trata de inmensas bases de datos, conviene alternar los mtodos dependiendo del nmero de valores que
se requiere ordenar, utilizando mtodos no recursivos cuando se trate de valores fciles de procesar, y mtodos
recursivos al momento de trabajar cantidades ms grandes de datos.
La siguiente grfica muestra los valores de O(n2) y n log (n), donde podemos observar su comportamiento y
compararlo con el de la grfica anterior, donde observamos que tambin: son similares.
100

n^2
n*log(n)

80

60

40

20

-20
0

6
n

10

Conclusin.
Hay que saber determinar los mtodos de ordenacin convenientes para cada criterio y cantidad de datos.
Esto es sumamente importante cuando se trata de manejar grandes cantidades de datos. En ese ltimo caso, lo ms
conveniente es utilizar ordenamientos del tipo n log n, y en el caso contrario, cuando los elementos son pocos, lo
mejor es utilizar ordenaciones del tipo n2.

Datos de la prctica.
Las caractersticas de la computadora donde fueron implementados estos algoritmos son:

Procesador:
RAM:
Sistema:
Disco Duro:

AMD E2-1800 APU con Radeon HD Graphics 1.70 GHz.


4.00 Gb (3.60 utilizable).
Sistema operativo de 64 bits.
450 Gb.

Estos programas fueron utilizados para la realizacin de tablas y grficas.

Tablas y grficas: Microsoft Excel


ltima grfica: wxMaxima.
Se recurri a los siguientes sitios para la definicin de los algoritmos y su algoritmo.

Definiciones y algoritmos: http://c.conclase.net


Definiciones:
http://es.wikipedia.org
Implementacin Quicksort: ronnyml.wordpress.com/2009/07/19/quicksort-en-c
Para implementar el cdigo se utiliz:

CodeBlocks 13.12
Los archivos de cdigo pueden ser encontrados en:

https://github.com/gioku14/Reporte-de-M-todos-de-Ordenamiento-C-