UNIVERSIDAD NACIONAL DE SAN

AGUSTÍN

EDA

Algoritmos de Ordenamiento

Integrantes:
Algoritmos de Ordenamiento

Índice
1. Introducción 3

2. Algoritmos de Ordenamiento 3
2.1. Bubble-Sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.1.1. C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.1.2. Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.1.3. Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.1.4. Comparación de los gráficas en los tres lenguajes . . . . . . . 5
2.2. Insertion-Sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2.1. C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.2.2. Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.2.3. Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2.4. Comparación de los gráficas en los tres lenguajes . . . . . . . 7
2.3. Selection-Sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.3.1. C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.3.2. Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.3.3. Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.3.4. Comparación de los gráficas en los tres lenguajes . . . . . . . 10
2.4. Merge-Sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.4.1. C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.4.2. Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.4.3. Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.4.4. Comparación de los gráficas en los tres lenguajes . . . . . . . 15
2.5. Quick-Sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.5.1. C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.5.2. Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.5.3. Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.5.4. Comparación de los gráficas en los tres lenguajes . . . . . . . 19
2.6. Heap-Sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.6.1. C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.6.2. Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.6.3. Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.6.4. Comparación de los gráficas en los tres lenguajes . . . . . . . 24
2.7. Counting-Sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.7.1. C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.7.2. Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.7.3. Comparación de los gráficas en los tres lenguajes . . . . . . . 26
2.8. Algoritmos de Ordenamiento en Java . . . . . . . . . . . . . . . . . . 26

1
Algoritmos de Ordenamiento

2.9. Algoritmos de Ordenamiento en C++ y PYthon . . . . . . . . . . . . 28

2
 Algoritmos de Ordenamiento

1. Introducción
En el siguiente trabajo para el curso de EDA analizaremos los algoritmos de or-
denamiento (buble, heap, insertion , merge , quick , selection y counting) con sus
respectivas gráficas cantidad de elemento - tiempo. Cada algoritmo sera analizado
en los lenguajes c++ , java y python.

2. Algoritmos de Ordenamiento
2.1. Bubble-Sort
Este algoritmo de clasificación es el mas simple de todos que funciona intercambiando
cada elemento adyacente si este es menor o mayor dependiendo de si esta en orden
as endente o des endente.
El tiempo de ejecución es de lo mas malos ya que tiene que recorrer cada elemento
incluso si el array esta ordenado , su tiempo de ejecución es O(n2 ). Se puede optimizar
deteniendo el algoritmo si el bucle interno no causó ningún intercambio.

2.1.1. C++

Listing 1: C++ Bubble-Sort

1 v o i d b u b b l e S o r t ( v e c t o r <i n t > &a r r , i n t n )
2 {
3 int i , j ;
4 f o r ( i = 0 ; i < n−1; i ++)
5 f o r ( j = 0 ; j < n−i −1; j ++)
6 i f ( a r r [ j ] > a r r [ j +1])
7 swap(& a r r [ j ] , &a r r [ j + 1 ] ) ;
8 }

Resivimos un vector en cual tenemos nuestra lista de elementos desordenados toma-

dos del txt, compramos cada elemento con los dos for para luego hacer el intercambio
si el elemento es menor que el que le sigue.

2.1.2. Python

Listing 2: Python Bubble-Sort

3
 Algoritmos de Ordenamiento

1 def bubbleSort ( arr ) :

2 n = len ( arr )
3 f o r i i n range ( n ) :
4 f o r j i n range ( 0 , n−i −1):
5 i f a r r [ j ] > a r r [ j +1] :
6 a r r [ j ] , a r r [ j +1] = a r r [ j +1] , a r r [ j ]

2.1.3. Java

Listing 3: Java Bubble-Sort

1 void bubbleSort ( I n t eg e r arr [ ] )
2 {
3 int n = arr . length ;
4 f o r ( i n t i = 0 ; i < n−1; i ++)
5 f o r ( i n t j = 0 ; j < n−i −1; j ++)
6 i f ( a r r [ j ] > a r r [ j +1])
7 {
8 i n t temp = a r r [ j ] ;
9 arr [ j ] = arr [ j +1];
10 a r r [ j +1] = temp ;
11 }
12 }

4
Algoritmos de Ordenamiento

2.1.4. Comparación de los gráficas en los tres lenguajes

Figura 1: Java-Python-C++

Conclusión
Como podemos observar en la Figura 1 Para esta situación el programa desa-
rrollado en c++ es el mas rápido seguido después de de java y por ultimo
siendo el mas lento como se esperaba python.
Al realizar las pruebas al momento de generar las coordenadas N vs T Python
tardo mucho en ejecutar este algoritmo como podemos ver en los códigos mos-
trados anteriormente el algoritmo no varia realizan doce dos bucles for para
posteriormente hacer los respectivos intercambios si esta lo amerita.

2.2. Insertion-Sort
La manera de ordenar los datos de este algoritmo se asemeja al ordenamiento de un
mazo de cartas requiere O(n2 ) operaciones para ordenar una lista de n elementos.

5
 Algoritmos de Ordenamiento

2.2.1. C++

Listing 4: C++ Insertion-Sort

1 v o i d i n s e r t i o n S o r t ( v e c t o r <i n t > &a r r , i n t n )
2 {
3 i n t i , key , j ;
4 f o r ( i = 1 ; i < n ; i ++)
5 {
6 key = a r r [ i ] ;
7 j = i − 1;
8 w h i l e ( j >= 0 && a r r [ j ] > key )
9 {
10 arr [ j + 1] = arr [ j ] ;
11 j = j − 1;
12 }
13 a r r [ j + 1 ] = key ;
14 }
15 }
16 }

2.2.2. Python

Listing 5: Python Insertion-Sort

1 def insertionSort ( arr ) :
2 f o r i i n range ( 1 , l e n ( a r r ) ) :
3 key = a r r [ i ]
4 j = i −1
5 w h i l e j >= 0 and key < a r r [ j ] :
6 arr [ j + 1] = arr [ j ]
7 j −= 1
8 a r r [ j + 1 ] = key

6
 Algoritmos de Ordenamiento

2.2.3. Java

Listing 6: Java Insertion-Sort

1 void I n s e r t i o n S o r t ( I n te g e r arr [ ] )
2 {
3 int n = arr . length ;
4 f o r ( i n t i =1; i <n ; ++i )
5 {
6 i n t key = a r r [ i ] ;
7 i n t j = i −1;
8 w h i l e ( j >=0 && a r r [ j ] > key )
9 {
10 a r r [ j +1] = a r r [ j ] ;
11 j = j −1;
12 }
13 a r r [ j +1] = key ;
14 }
15 }

2.2.4. Comparación de los gráficas en los tres lenguajes

Figura 2: Java-Python-C++

7
 Algoritmos de Ordenamiento

Conclusión
Este algoritmo en los tres lenguajes recibe un Array el cual procederemos a
recorrerlo, El resultado de la comparación de los algoritmo en los tres lenguajes
diferentes varia a diferencia del algoritmos anterior python sigue siendo el mas
lento pero la diferencia entre el algoritmo ejecutado en java como el de c++
es mı́nima.

2.3. Selection-Sort
Este algoritmo de ordenamiento clasifica el Array recibido encontrando repentina-
mente el elemento mı́nimo de la parte no ordenada y colocarla al principio.
El algoritmo mantiene dos sub-Array en un matriz determinada.El Sub-Array que
ya esta ordenada y la otra que contiene a los no ordenados.
En cada iteración del orden de selección, el elemento mı́nimo(Considerando el orden
ascendente) del subconjunto sin clasificar se selecciona y se mueve al subconjunto
ordenado.

2.3.1. C++

Listing 7: C++ Selection-Sort

1 v o i d swap ( i n t ∗ a , i n t ∗ b )
2 {
3 i n t t = ∗a ;
4 ∗a = ∗b ;
5 ∗b = t ;
6 }
7 v o i d s e l e c t i o n S o r t ( v e c t o r <i n t > &a r r , i n t n )
8 {
9 i n t i , j , min idx ;
10 f o r ( i = 0 ; i < n−1; i ++)
11 {
12 min idx = i ;
13 f o r ( j = i +1; j < n ; j ++)
14 i f ( a r r [ j ] < a r r [ min idx ] )
15 min idx = j ;
16 swap(& a r r [ min idx ] , &a r r [ i ] ) ;
17 }

8
 Algoritmos de Ordenamiento

18 }

2.3.2. Python

Listing 8: Python Selection-Sort

1
2 d e f s e l e c t i o n (A) :
3 f o r i i n range ( l e n (A ) ) :
4 min idx = i
5 f o r j i n range ( i +1, l e n (A ) ) :
6 i f A[ min idx ] > A[ j ] :
7 min idx = j
8 A[ i ] , A[ min idx ] = A[ min idx ] , A[ i ]

2.3.3. Java

Listing 9: Java Selection-Sort

1 void S e l e c t i o n S o r t ( In t eg e r arr [ ] )
2 {
3 int n = arr . length ;
4
5 f o r ( i n t i = 0 ; i < n−1; i ++)
6 {
7 i n t min idx = i ;
8 f o r ( i n t j = i +1; j < n ; j ++)
9 i f ( a r r [ j ] < a r r [ min idx ] )
10 min idx = j ;
11
12 i n t temp = a r r [ min idx ] ;
13 a r r [ min idx ] = a r r [ i ] ;
14 a r r [ i ] = temp ;
15 }
16 }

9
Algoritmos de Ordenamiento

2.3.4. Comparación de los gráficas en los tres lenguajes

Figura 3: Java-Python-C++

Conclusión
Este algoritmo también es también uno de los mas lentos al tener dos For
anidados también cuenta con un tiempo de ejecución O(n2 ).
En este ejemplo podemos observar que python sigue siendo el mas lento pero
acortando la distocia tan amplia que los anteriores en el caso de java y c++ en
este algoritmo java es el mas rápido al procesar los datos. En el algoritmo de
c++ hacemos uso de una función swap el cual nos ayudare a intercambiar los
datos a diferencia de python y java que no necesitan de esta función externa.

10
 Algoritmos de Ordenamiento

2.4. Merge-Sort
Uno de los algoritmos mas eficientes, este algoritmo es uno de los que utiliza el dicho
divide y conquistaras.Este algoritmo divide la lista de entrada en dos mitades, es de
forma recursiva .Este algoritmo hace uso de una función Merge()la cual nos ayudara
a unir dos mitades para el ordenamiento.

2.4.1. C++

Listing 10: C++ Merge-Sort

1 v o i d merge ( v e c t o r <i n t > &a r r , i n t l , i n t m, i n t r )
2 {
3 int i , j , k ;
4 i n t n1 = m − l + 1 ;
5 i n t n2 = r − m;
6 i n t L [ n1 ] , R[ n2 ] ;
7 f o r ( i = 0 ; i < n1 ; i ++)
8 L[ i ] = arr [ l + i ] ;
9 f o r ( j = 0 ; j < n2 ; j ++)
10 R[ j ] = a r r [m + 1+ j ] ;
11 i = 0;
12 j = 0;
13 k = l;
14 w h i l e ( i < n1 && j < n2 )
15 {
16 i f (L [ i ] <= R[ j ] )
17 {
18 arr [ k ] = L[ i ] ;
19 i ++;
20 }
21 else
22 {
23 a r r [ k ] = R[ j ] ;
24 j ++;
25 }
26 k++;
27 }
28 w h i l e ( i < n1 )
29 {
30 arr [ k ] = L[ i ] ;

11
 Algoritmos de Ordenamiento

31 i ++;
32 k++;
33 }
34 w h i l e ( j < n2 )
35 {
36 a r r [ k ] = R[ j ] ;
37 j ++;
38 k++;
39 }
40 }
41
42 v o i d mergeSort ( v e c t o r <i n t > &a r r , i n t l , i n t r )
43 {
44 if (l < r)
45 {
46 i n t m = l +(r−l ) / 2 ;
47 mergeSort ( a r r , l , m) ;
48 mergeSort ( a r r , m+1, r ) ;
49
50 merge ( a r r , l , m, r ) ;
51 }
52 }

2.4.2. Python

Listing 11: Python Merge-Sort

1 d e f mergeSort ( a r r ) :
2 i f l e n ( a r r ) >1:
3 mid = l e n ( a r r )//2
4 L = a r r [ : mid ]
5 R = a r r [ mid : ]
6 mergeSort (L)
7 mergeSort (R)
8 i = j = k = 0
9 w h i l e i < l e n (L) and j < l e n (R ) :
10 i f L [ i ] < R[ j ] :
11 arr [ k ] = L[ i ]
12 i+=1

12
 Algoritmos de Ordenamiento

13 else :
14 a r r [ k ] = R[ j ]
15 j+=1
16 k+=1
17 w h i l e i < l e n (L ) :
18 arr [ k ] = L[ i ]
19 i+=1
20 k+=1
21
22 w h i l e j < l e n (R ) :
23 a r r [ k ] = R[ j ]
24 j+=1
25 k+=1

2.4.3. Java

Listing 12: Java Merge-Sort

1 v o i d merge ( I n t e g e r a r r [ ] , i n t l , i n t m, i n t r )
2 {
3 i n t n1 = m − l + 1 ;
4 i n t n2 = r − m;
5 i n t L [ ] = new i n t [ n1 ] ;
6 i n t R [ ] = new i n t [ n2 ] ;
7 f o r ( i n t i =0; i <n1 ; ++i )
8 L[ i ] = arr [ l + i ] ;
9 f o r ( i n t j =0; j <n2 ; ++j )
10 R[ j ] = a r r [m + 1+ j ] ;
11 int i = 0 , j = 0;
12 int k = l ;
13 w h i l e ( i < n1 && j < n2 )
14 {
15 i f (L [ i ] <= R[ j ] )
16 {
17 arr [ k ] = L[ i ] ;
18 i ++;
19 }
20 else
21 {

13
 Algoritmos de Ordenamiento

22 a r r [ k ] = R[ j ] ;
23 j ++;
24 }
25 k++;
26 }
27 while ( i < n1 )
28 {
29 arr [ k ] = L[ i ] ;
30 i ++;
31 k++;
32 }
33 while ( j < n2 )
34 {
35 arr [ k ] = R[ j ] ;
36 j ++;
37 k++;
38 }
39 }
40 void Merge sort ( I nt e ge r arr [ ] , i n t l , i n t r )
41 {
42 if (l < r)
43 {
44 i n t m = ( l+r ) / 2 ;
45 M e r g e s o r t ( a r r , l , m) ;
46 M e r g e s o r t ( a r r , m+1, r ) ;
47 merge ( a r r , l , m, r ) ;
48 }
49 }

14
Algoritmos de Ordenamiento

2.4.4. Comparación de los gráficas en los tres lenguajes

Figura 4: Java-Python-C++

Conclusión
Merge Sort es uno de los algoritmos mas rápidos ya que siempre divide el
array en dos mitades y toma un tiempo lineal para fusionarlas.La complejidad
de tiempo del Merge sort es Θ(nLogn) en su mejor y peor caso. En nuestra
comparación podemos observar los tiempos disminuyeron considerablemente
a diferencia de las anteriores gráficas pero sigue manteniendo el mismo com-
portamiento siendo python el mas lento de los tres.

15
 Algoritmos de Ordenamiento

2.5. Quick-Sort
Al igual que Merge Sort , QuickSort es un algoritmo Divide y Conquistaras. Elige
un elemento como pivote y divide la matriz dada alrededor del pivote seleccionado.
Hay muchas versiones diferentes de QuickSort que seleccionan pivote de diferentes
maneras.
Eija siempre el primer elemento como pivote.
Elija siempre el último elemento como pivote (implementado a continuación)/
Elija un elemento aleatorio como pivote.
Elija la mediana como pivote.
El proceso clave en quickSort es la partición (). El objetivo de las particiones es,
dada un Array y un elemento x de la matriz como pivote, colocar x en su posición
correcta en un Array ordenada y colocar todos los elementos más pequeños (más
pequeños que x) antes de x, y poner todos los elementos mayores (más grandes que
x) después X. Todo esto debe hacerse en tiempo lineal.

2.5.1. C++

Listing 13: C++ Quick-Sort

1 i n t p a r t i t i o n ( v e c t o r <i n t > &a r r , i n t low , i n t hi gh )
2 {
3 i n t p i v o t = a r r [ high ] ;
4 i n t i = ( low − 1 ) ;
5
6 f o r ( i n t j = low ; j <= high − 1 ; j ++)
7 {
8 i f ( arr [ j ] < pivot )
9 {
10 i ++;
11 swap(& a r r [ i ] , &a r r [ j ] ) ;
12 }
13 }
14 swap(& a r r [ i + 1 ] , &a r r [ high ] ) ;
15 return ( i + 1);
16 }
17
18 v o i d q u i c k S o r t ( v e c t o r <i n t > &a r r , i n t low , i n t hi gh )

16
 Algoritmos de Ordenamiento

19 {
20 i f ( low < high )
21 {
22 i n t p i = p a r t i t i o n ( a r r , low , high ) ;
23 q u i c k S o r t ( a r r , low , p i − 1 ) ;
24 q u i c k S o r t ( a r r , p i + 1 , high ) ;
25 }
26 }

2.5.2. Python

Listing 14: Python Quick-Sort

1 d e f p a r t i t i o n ( a r r , low , high ) :
2 i = ( low−1 )
3 p i v o t = a r r [ hig h ]
4 f o r j i n range ( low , high ) :
5
6 i f arr [ j ] < pivot :
7 i = i +1
8 arr [ i ] , arr [ j ] = arr [ j ] , arr [ i ]
9
10 a r r [ i +1] , a r r [ high ] = a r r [ high ] , a r r [ i +1]
11 r e t u r n ( i +1 )
12
13 d e f q u i c k S o r t ( a r r , low , high ) :
14 i f low < high :
15
16 p i = p a r t i t i o n ( a r r , low , high )
17
18 q u i c k S o r t ( a r r , low , pi −1)
19 q u i c k S o r t ( a r r , p i +1, high )

17
 Algoritmos de Ordenamiento

2.5.3. Java

Listing 15: Java Quick-Sort

1 i n t p a r t i c i o n ( I n t e g e r a r r [ ] , i n t low , i n t high )
2 {
3 i n t p i v o t = a r r [ high ] ;
4 i n t i = ( low −1);
5 f o r ( i n t j=low ; j <high ; j ++)
6 {
7 i f ( arr [ j ] < pivot )
8 {
9 i ++;
10 i n t temp = a r r [ i ] ;
11 arr [ i ] = arr [ j ] ;
12 a r r [ j ] = temp ;
13 }
14 }
15 i n t temp = a r r [ i + 1 ] ;
16 a r r [ i +1] = a r r [ high ] ;
17 a r r [ high ] = temp ;
18
19 r e t u r n i +1;
20 }
21 v o i d Q u i c k S o r t ( I n t e g e r a r r [ ] , i n t low , i n t high )
22 {
23 i f ( low < high )
24 {
25
26 i n t p i = p a r t i c i o n ( a r r , low , high ) ;
27 Q u i c k S o r t ( a r r , low , pi −1);
28 Q u i c k S o r t ( a r r , p i +1, hi gh ) ;
29 }
30 }

18
Algoritmos de Ordenamiento

2.5.4. Comparación de los gráficas en los tres lenguajes

Figura 5: Java-Python-C++

19
Algoritmos de Ordenamiento

Conclusión
Aligual que el MergeSort es un algortimo de ordenamiento muy rapido. Su
tiempo de ejecuacion se puede expresar de la siguiente manera.

T (n) = T (k) + T (nk − 1) + Θ(n)

Los primeros dos términos son para las llamadas recursivas el Θ(n) es por el
proceso de partición , k es el numero de elementos que son mas pequeños que
el pivote.
El tiempo que tarde el QuickSort en ordenar un Array dependerá de ella y el
tipo de partición.

Peor Caso : El peor de los casos ocurre cuando el proceso de partición

siempre elige el elemento más grande o más pequeño como pivote. Si
consideramos la estrategia de partición anterior donde el último elemento
siempre se elige como pivote, el peor de los casos ocurrirı́a cuando la
matriz ya esté ordenada en orden creciente o decreciente.
El mejor caso ocurre cuando el proceso de partición siempre elige el
elemento medio como pivote. Lo siguiente es recurrencia para el mejor
caso.

2.6. Heap-Sort
La ordenación de este algoritmo es una técnica de clasificación basada en la com-
paración . Es similar al orden de selección donde primero encontramos el elemento
máximo y colocamos el elemento máximo al final. Repetimos el mismo proceso para
el elemento restante.
Un Heap es un árbol binario completo donde los elementos se almacenan en un or-
den especial, de modo que el valor en un nodo principal es mayor (o menor) que los
valores en sus dos nodos secundarios. El primero se llama Heap máximo y el segundo
se llama Heap mı́nimo.
Cree un montón máximo a partir de los datos de entrada.
En este punto, el elemento más grande se almacena en la raı́z del montón.
Reemplácelo con el último elemento del montón seguido de reducir el tamaño
del montón en 1. Finalmente, heapifique la raı́z del árbol.
Repita los pasos anteriores mientras el tamaño del montón es mayor que 1.

20
 Algoritmos de Ordenamiento

2.6.1. C++

Listing 16: C++ Heap-Sort

1 v o i d h e a p i f y ( v e c t o r <i n t >&a r r , i n t n , i n t i )
2 {
3 int largest = i ;
4 i n t l = 2∗ i + 1 ;
5 i n t r = 2∗ i + 2 ;
6 i f ( l < n && a r r [ l ] > a r r [ l a r g e s t ] )
7 largest = l ;
8
9 i f ( r < n && a r r [ r ] > a r r [ l a r g e s t ] )
10 largest = r ;
11
12
13 i f ( l a r g e s t != i )
14 {
15 swap ( a r r [ i ] , a r r [ l a r g e s t ] ) ;
16
17
18 heapify ( arr , n , l a r g e s t ) ;
19 }
20 }
21
22 v o i d heapSort ( v e c t o r <i n t >&a r r , i n t n )
23 {
24
25 f o r ( i n t i = n / 2 − 1 ; i >= 0 ; i −−)
26 heapify ( arr , n , i ) ;
27
28
29 f o r ( i n t i=n−1; i >=0; i −−)
30 {
31 swap ( a r r [ 0 ] , a r r [ i ] ) ;
32 heapify ( arr , i , 0 ) ;
33 }
34 }

21
 Algoritmos de Ordenamiento

2.6.2. Python

Listing 17: Python Heap-Sort

1 def heapify ( arr , n , i ) :
2 largest = i
3 l = 2 ∗ i + 1
4 r = 2 ∗ i + 2
5 i f l < n and a r r [ i ] < a r r [ l ] :
6 largest = l
7 i f r < n and a r r [ l a r g e s t ] < a r r [ r ] :
8 largest = r
9
10 i f l a r g e s t != i :
11 arr [ i ] , arr [ largest ] = arr [ largest ] , arr [ i ]
12 heapify ( arr , n , l a r g e s t )
13
14 d e f heapSort ( a r r ) :
15 n = len ( arr )
16 f o r i i n range ( n , −1, −1):
17 heapify ( arr , n , i )
18 f o r i i n range ( n−1, 0 , −1):
19 arr [ i ] , arr [ 0 ] = arr [ 0 ] , arr [ i ]
20 heapify ( arr , i , 0)

2.6.3. Java

Listing 18: Java Heap-Sort

1 p u b l i c v o i d Heapsort ( I n t e g e r a r r [ ] )
2 {
3 int n = arr . length ;
4
5
6 f o r ( i n t i = n / 2 − 1 ; i >= 0 ; i −−)
7 heapify ( arr , n , i ) ;
8 f o r ( i n t i=n−1; i >=0; i −−)
9 {
10 i n t temp = a r r [ 0 ] ;

22
 Algoritmos de Ordenamiento

11 arr [ 0 ] = arr [ i ] ;
12 a r r [ i ] = temp ;
13 heapify ( arr , i , 0 ) ;
14 }
15 }
16
17 void heapify ( I n t eg e r arr [ ] , i n t n , i n t i )
18 {
19 int largest = i ;
20 i n t l = 2∗ i + 1 ;
21 i n t r = 2∗ i + 2 ;
22 i f ( l < n && a r r [ l ] > a r r [ l a r g e s t ] )
23 largest = l ;
24 i f ( r < n && a r r [ r ] > a r r [ l a r g e s t ] )
25 largest = r ;
26 i f ( l a r g e s t != i )
27 {
28 i n t swap = a r r [ i ] ;
29 arr [ i ] = arr [ largest ] ;
30 a r r [ l a r g e s t ] = swap ;
31 heapify ( arr , n , l a r g e s t ) ;
32 }
33 }

23
Algoritmos de Ordenamiento

2.6.4. Comparación de los gráficas en los tres lenguajes

Figura 6: Java-Python-C++

Conclusión
Este algoritmo utilizo un heap mı́nimo para ordenarlo de manera asendente. La
función heapify tiene un tiempo de O(Logn) La complejidad de tiempo de del
Heap es de O(n). Teniendo una complejidad de timpo genereal de O(nLogn).
Como podemos observar en la grafica, el algoritmo en python sigue siendo el
mas lento sin embargo en esta ocacion el algoritmo en java fue mucho mejor
que el su par en C++.

2.7. Counting-Sort
La ordenación de conteo es una técnica de clasificación basada en claves entre un
rango especı́fico. Funciona contando el número de objetos que tienen valores clave
distintos (tipo de hash). Luego haciendo algo de aritmética para calcular la posición
de cada objeto en la secuencia de salida.

24
 Algoritmos de Ordenamiento

2.7.1. C++

Listing 19: C++ Heap-Sort

1 v o i d CountingSort ( v e c t o r <i n t > &a r r , i n t s z )
2 {
3 int i , j , k ;
4 i n t idx = 0;
5 i n t min , max ;
6
7 min = max = a r r [ 0 ] ;
8 f o r ( i = 1 ; i < s z ; i ++) {
9 min = ( a r r [ i ] < min ) ? a r r [ i ] : min ;
10 max = ( a r r [ i ] > max) ? a r r [ i ] : max ;
11 }
12 k = max − min + 1 ;
13 i n t ∗B = new i n t [ k ] ;
14 f o r ( i = 0 ; i < k ; i ++) B [ i ] = 0 ;
15
16 f o r ( i = 0 ; i < s z ; i ++) B [ a r r [ i ] − min]++;
17 f o r ( i = min ; i <= max ; i ++)
18 f o r ( j = 0 ; j < B [ i − min ] ; j ++) a r r [ i d x++] = i ;
19 d e l e t e [ ] B;
20 }

2.7.2. Python

Listing 20: Python Heap-Sort

1 def countSort ( arr ) :
2 output = [ 0 f o r i i n range ( 2 5 6 ) ]
3 count = [ 0 f o r i i n range ( 2 5 6 ) ]
4 ans = [ ”” f o r in arr ]
5 for i in arr :
6 count [ ord ( i ) ] += 1
7
8 f o r i i n range ( 2 5 6 ) :
9 count [ i ] += count [ i −1]
10

25
 Algoritmos de Ordenamiento

11 f o r i i n range ( l e n ( a r r ) ) :
12 output [ count [ ord ( a r r [ i ] ) ] − 1 ] = a r r [ i ]
13 count [ ord ( a r r [ i ] ) ] −= 1
14
15 f o r i i n range ( l e n ( a r r ) ) :
16 ans [ i ] = output [ i ]
17 r e t u r n ans

2.7.3. Comparación de los gráficas en los tres lenguajes

Figura 7: Java-Python-C++

2.8. Algoritmos de Ordenamiento en Java

En este punto compararemos los algoritmos de ordenamiento en un solo lenguaje
(Java).

26
Algoritmos de Ordenamiento

Figura 8: Java

27
Algoritmos de Ordenamiento

Figura 9: Java

Conclusión
Como se puede observar en esta gráfica comparativa, no podemos conocer a
ciencia cierta quien fue el ganador, dado que hay 4 algoritmos que se solapan
entre si debido a la escala de la gráfica, y corresponden al quickSort, mer-
geSort, heapSort y countingSort, pero con total seguridad tenemos un claro
perdedor, el cual fue el algoritmo burbuja con una complejidad algoritmica de
O(n2 ), seguido del insertionSort y el selectionSort, los cuales tienen igual una
complejidad de O(n2 ) pero sus implementaciones son un poco más eficientes
dado que se hacen menos comparaciones, pero no dejan de ser algoritmos poco
competentes. los algoritmos veloces, que son el quickSort, mergeSort, heapSort
y countingSort, de los cuales casi ninguno supero 1 segundo ordenando 20,000
datos

2.9. Algoritmos de Ordenamiento en C++ y PYthon

En este punto compararemos los algoritmos de ordenamiento en un solo lenguaje
(C++).

28
Algoritmos de Ordenamiento

Figura 10: C++

29
Algoritmos de Ordenamiento

Figura 11: C++

30
Algoritmos de Ordenamiento

Figura 12: C++

31
Algoritmos de Ordenamiento

Figura 13: C++

32
Algoritmos de Ordenamiento

Conclusión Generales
Para esta comparación se usaron 60,000 datos aleatorios para tener un mejor
resultado.
Como podemos observar en esta gráfica vemos que los algoritmos quickSort,
mergeSort, heapSort y countingSort son los mas la figura 11 nos muestra co-
mo es que solapan entre si pero teniendo como ganador en la mayor parte del
tramo al countig Sort con una complejidad de O(n + k), siendo n la canti-
dad de datos a ordenar y k el tamaño del vector auxiliar(máximo - mı́nimo
).Este algoritmo de conteo no es del todo bueno ya que que tiene una gran
limitación la cual es que solo funciona con números enteros ya que depende
de un vector auxiliar donde a amacena la cuenta de cada valor.Por otro lado
incluso cuando queremos ordenar solo números enteros si la diferencia entre el
máximo y el mı́nimo de los datos a ordenar es muy grande, el vector auxiliar
requerido implica un consumo excesivo de memoria, lo cual implica que sea
menos eficiente , pero como hemos probado, bajo condiciones especı́ficas, el
algoritmo de conteo es una de las mejores técnicas para ordenar datos.
El QuickSort seria el segundo algoritmo mas rápido , algoritmo con una com-
plejidad de O(n log n), siendo uno de los más usados con el cual puedes ordenar
también números reales; pero que igual que el algoritmo de conteo tiene sus
falencias, dado que es un algoritmo probabilı́stico y hay casos extremos en los
cuales la complejidad se puede elevar a O(n2 ), dependiendo de la distribución
de los datos y una mala elección de pivote. El peor algoritmo sigue siendo la
Burbuja tanto en c++ como en Python.

33