12 Ordenamientos Presentacion

Algoritmos basados en comparaciones Algoritmos por distribución Bibliografía
Ordenamientos
Verónica E. Arriola-Rios
Estructuras de Datos
22 de mayo de 2017
Verónica E. Arriola-Rios Ordenamientos

Temas
1 Algoritmos basados en comparaciones

Bubble Sort
Selection Sort
Insertion Sort
Divide y vencerás
Quick Sort
Merge Sort
Heap Sort
2 Algoritmos por distribución
Ordenamiento en cubetas
Radix Sort
Ordenamiento de Shell
3 Bibliografía

Temas

Bubble Sort
Selection Sort
Insertion Sort
Divide y vencerás
Quick Sort
Merge Sort
Heap Sort
Radix Sort
3 Bibliografía

El ordenamiento burbuja
Par por par, se verifica que los datos estén en el orden
correcto.
En cada iteración se garantiza que el elemento más a la
derecha se encuentra en la posición correcta.
Tiene complejidad O(n2 )
9 8 7 6 5 4 3 2 1 10
8 7 6 5 4 3 2 1 9 10
7 6 5 4 3 2 1 8 9 10
6 5 4 3 2 1 7 8 9 10
5 4 3 2 1 6 7 8 9 10
4 3 2 1 5 6 7 8 9 10
3 2 1 4 5 6 7 8 9 10
2 1 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10

1 public static <C extends Comparable <? super C > >

2 void bubleSort ( C [] a ) {
3 boolean swapped = false ;
4 for ( int i = 0; i < a . length - 1; i ++) {
5 swapped = false ;
6 for ( int j = 1; j < a . length - i ; j ++) {
7 if ( a [j -1]. compareTo ( a [ j ]) > 0) {
8 swap (a , j -1 , j );
9 swapped = true ;
10 }
11 }
12 if (! swapped ) return ;
13 }
14 }

Temas

Bubble Sort
Selection Sort
Insertion Sort
Divide y vencerás
Quick Sort
Merge Sort
Heap Sort
Radix Sort
3 Bibliografía

Selecciona y acomoda
Busca el elemento más pequeño en el subarreglo restante y lo

coloca en su posición.
http://cheetahonfire.blogspot.mx/2009/05/selection-sort-vs-insertion-sort.html

1 public static void selectionSort ( Comparable [] a ){

2 int primero , temp ;
3 for ( int i = 0; i < a . length - 1; i ++) {
4 primero = i ; // primer elemento en el arreglo
5 for ( int j = i + 1; j < a . length ; j ++){
6 // elemento m á s peque ñ o entre 1 e i .
7 if ( a [ j ]. compareTo ( a [ primero ]) < 0) primero = j ;
8 }
9 swap (a , primero , i );
10 }
11 }

Temas

Bubble Sort
Selection Sort
Insertion Sort
Divide y vencerás
Quick Sort
Merge Sort
Heap Sort
Radix Sort
3 Bibliografía

Acomoda en su lugar
Inserta cada número en su posición correcta.
http://cheetahonfire.blogspot.mx/2009/05/selection-sort-vs-insertion-sort.html

Temas

Bubble Sort
Selection Sort
Insertion Sort
Divide y vencerás
Quick Sort
Merge Sort
Heap Sort
Radix Sort
3 Bibliografía

Alrededor del pivote
Se elige algún número como pivote.

Los menores que el pivote se acomodan a su izquierda,
los mayores a su derecha.
Después de cada iteración el pivote queda en su lugar.
Repertir con cada segmento del arreglo hasta que tenga un
sólo elemento.
Complejidad en promedio:
En promedio se realizan log(n) pasos recursivos.
Cada elemento del arreglo es revisado durante el paso recursivo
en alguna de las subdivisiones.
La complejidad total es O(n log n)

Ejemplo
Pivote = 6 2 3 4 5 1 6 8 9 10 7
Pivote = 4 2 3 1 4 5 6 8 9 10 7
Pivote = 3 2 1 3 4 5 6 8 9 10 7
Pivote = 2 1 2 3 4 5 6 8 9 10 7
Pivote = 9 1 2 3 4 5 6 8 7 9 10
Pivote = 8 1 2 3 4 5 6 7 8 9 10
1 public static void quickSort ( Comparable [] a ) {

2 quickSort (a , 0 , a . length - 1);
3 }

1 private static void quickSort ( Comparable [] a ,

2 int left , int right ){
3 int pivotIndex = ( right + left )/2;
4 Comparable pivot = a [ pivotIndex ];
5 swap (a , pivotIndex , right ); // Pivote al final
6 int i = left ;
7 int j = right ;
8 while ( i < j ) {
9 while (i <= right && a [ i ]. compareTo ( pivot ) < 0) i ++;
10 while (j >= left && a [ j ]. compareTo ( pivot ) >= 0) j - -;
11 if ( i < j ) swap (a , i , j );
12 }
13 swap (a , right , i );
14
15 // Llamada recursiva
16 if ( i - left >= 2) quickSort (a , left , i - 1);
17 if ( right - i >= 2) quickSort (a , i + 1 , right );
18 }

Divide, ordena y mezcla
Parte el arreglo en mitades recursivamente hasta que sólo

haya un elemento.
Mezcla las mismas mitades, pero insertando los elementos en
orden.

Ejemplo
9 10|8|7 6|5 4|3|2 1

8 9 10|7 6|5 4|3|2 1
8 9 10|6 7|5 4|3|2 1
6 7 8 9 10|5 4|3|2 1
6 7 8 9 10|4 5|3|2 1
6 7 8 9 10|3 4 5|2 1
6 7 8 9 10|3 4 5|1 2
6 7 8 9 10|1 2 3 4 5
1 2 3 4 5 6 7 8 9 10

1 public static void mergeSort ( Comparable [] a ) {

2 msortDivide (a ,0 , a . length -1);
3 }
1 private static void msortDivide ( Comparable [] a ,

2 int left , int right ) {
3 if ( left < right ) {
4 int middle = ( left + right ) / 2;
5 msortDivide (a , left , middle );
6 msortDivide (a , middle + 1 , right );
7 merge (a , left , middle , right );
8 }
9 }

1 // middle : í ndice derecho subarreglo 1

2 private static void merge ( Comparable [] a ,
3 int left , int middle , int right ) {
4 int di = left ;
5 int dd = middle + 1;
6 int i = 0;
7 Comparable [] temp = new Comparable [ right - left +1];
8 while ( di <= middle && dd <= right ) {
9 if ( a [ di ]. compareTo ( a [ dd ]) < 0)
10 temp [ i ++] = a [ di ++];
11 else
12 temp [ i ++] = a [ dd ++];
13 }
14 while ( di <= middle ) temp [ i ++] = a [ di ++];
15 while ( dd <= right ) temp [ i ++] = a [ dd ++];
16 for ( int j = left , jj = 0; j <= right ; j ++ , jj ++)
17 a [ j ] = temp [ jj ];
18 }

Temas

Bubble Sort
Selection Sort
Insertion Sort
Divide y vencerás
Quick Sort
Merge Sort
Heap Sort
Radix Sort
3 Bibliografía

Árboles n-arios en arreglos
Dado que el número de hijos en un árbol n-ario es fijo:

El número total de nodos m en un árbol n-ario con altura l es:
m =1 + n + n2 + n3 + ... + nl (1)
nl
−1
= (2)
n−1
1 2 4 8
50 25 75 10 39 ∅ 100 1 ∅ 29 42 ∅ ∅ ∅ 120
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14

Es posible determinar la posición del i-ésimo descendiente,

dada la posición de su padre.
hijoj (i) = ni + (j + 1) (3)
donde i es la posición del nodo; j, el índice de su hijo,

contando desde cero de izquierda a derecha y n, el grado del
árbol.
Y la posición del padre dada la posición del hijo:
i−1
padre(i) = b c (4)
n

Árbol binario en arreglo
50
25 75
10 39 100
1 29 42 120
50 25 75 10 39 ∅ 100 1 ∅ 29 42 ∅ ∅ ∅ 120
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
hijoIzquierdo(i) → 2i + 1 padre(i) → b(i − 1)/2c

hijoDerecho(i) → 2(i + 1)

Montículo máximo
Los datos en los hijos de un nodo son menores que el dato en
su padre.
200
39 120
25 10 75 100
1 19 9
200 39 120 25 10 75 100 1 19 9 ∅ ∅ ∅ ∅ ∅
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
hijoIzquierdo(i) → 2i + 1 padre(i) → b(i − 1)/2c

hijoDerecho(i) → 2(i + 1)
Inserta
Se inserta siempre en el siguiente nodo vacío.

El dato se intercambia con su padre hasta que su padre no sea
más chico que él o llegue a la raíz.
200
39 120
25 10 75 100
1 19 9 61

Inserta
200
39 120
25 61 75 100
1 19 9 10

Inserta
200
61 120
25 39 75 100
1 19 9 10

Maxmonticuliza (Heapify )
Si los dos subárboles de un nodo son montículos máximos,

pero el dato en el nodo es menor que alguno de sus hijos:
Intercambiar al dato del nodo con el mayor de sus hijos.
Repetir recursivamente hasta que el dato intercambiado sea
mayor que sus dos hijos.
12
39 120
25 10 100 75
1 19 9

120
39 100
25 10 12 75
1 19 9

Construye montículo máximo
Es posible ordenar los elementos de un árbol casi completo

para que formen un montículo máximo si se repite la
operación maxMonticuliza de abajo hacia arriba sobre la
mitad de los nodos.
Su complejidad es O(n).
120
39 100
25 10 12 75
1 19 9

Remueve
Intercambiar al nodo que se quiere remover con el último

nodo (última hoja).
Quitar la hoja.
Aplicar maxMonticuliza desde la hoja que subió de posición.
120
9 120
25 10 100 75
X
1 19 39

Heap Sort
Se construye un montículo máximo. O(n)

Para cada dato, desde el último hacia uno antes de la raíz:
O(n)
“Remover la raíz” (valor más grande).
Dejar al nodo “removido” pero marcar que el heap termina un
nodo antes (este nodo ha quedado en su lugar). O(log n)
Su complejidad es O(n) + O(n log n) = O(n log n)

Temas

Bubble Sort
Selection Sort
Insertion Sort
Divide y vencerás
Quick Sort
Merge Sort
Heap Sort
Radix Sort
3 Bibliografía

Temas

Bubble Sort
Selection Sort
Insertion Sort
Divide y vencerás
Quick Sort
Merge Sort
Heap Sort
Radix Sort
3 Bibliografía

Ordenamiento en cubetas / por conteo
Bruno Preiss lo llama Ordenamiento en cubetas [1] , mientras

que Cormen lo presenta como Ordenamiento por conteo [2]
Sirve para ordenar secuencias con n elementos en [0, k], con
k << n.
Se utilizan tres arreglos.
1 El arreglo a ordenar A, con longitud n.
2 Un arreglo auxiliar C, con longitud K, que cuenta cuántas
veces aparece cada elemento.
3 El arreglo con el resultado B.
[1]
Bucket Sort
[2]
Counting Sort
Algoritmo 1 Ordenamiento en cubetas

1: n ← longitud(A)
2: B ← Zeros(n)
3: C ← Zeros(k + 1)
4: for j ∈ [0, n) do
5: C[A[j]]+ = 1 . Conteo elementos por valor
6: for i ∈ [1, k] do
7: C[i]+ = C[i − 1] . Posiciones finales para cada valor
8: for j ∈ (n, 0] cada −1 do
9: B[C[A[j]] − 1] ← A[j] . Acomoda
10: C[A[j]]− = 1 . Calcula posición siguiente
return B

Ejemplo
k=3
A→ 3 1 1 0 2 3 2 1 0 2
0 1 2 3 4 5 6 7 8 9
2 5 8 10
C→ 2 3 3 2
0 1 2 3
2 5 8 10
B→ 0 0 1 1 1 2 2 2 3 3
0 1 2 3 4 5 6 7 8 9

Temas

Bubble Sort
Selection Sort
Insertion Sort
Divide y vencerás
Quick Sort
Merge Sort
Heap Sort
Radix Sort
3 Bibliografía

Radix Sort
Para i ∈ [1, d] (del dígito de menor a mayor precedencia):

ordena A según el iésimo − dı́gito, utilizando un
ordenamiento estable.
En un ordenamiento estable los elementos con el mismo valor
conservan su orden original, con respecto a los otros
elementos semejantes. Ejemplos son:
Por inserción.
En cubetas (como se implementó anteriormente).
Su complejidad es Θ(d(n + k)), con:
d el número de dígitos en los números
n el total de números
k el número de dígitos diferentes posibles en la base utilizada

Ejemplo
d =3
n =7
k = 10
329 720 720 329

457 355 329 355
657 436 436 436
839 → 457 → 839 → 457
436 657 355 657
720 329 457 720
355 839 657 839

Temas

Bubble Sort
Selection Sort
Insertion Sort
Divide y vencerás
Quick Sort
Merge Sort
Heap Sort
Radix Sort
3 Bibliografía

Está basado en el ordenamiento por inserción.

Se ordenan sucesivamente subsecuencias de elementos
equidistantes.
La distacia entre los elementos se reduce para cada iteración,
hasta llegar a separación 1.

Ejemplo
0 5 10 15
13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10
salto = 5
13 14 94 33 82 10 14 73 25 23
inserción
25 59 94 65 23 13 27 94 33 39
→
45 27 73 25 39 25 59 94 65 82
10 45
salto = 3
salto = 1

Criterios para elegir los saltos
2 , 4 , ..., 1, produce complejidad O(n )

n n 2
Shell
3
Hibbard 2k − 1, produce complejidad O(n 2 )
Sedgewick Se eligen números alternando entre las series
definidas por las funciones:
f(i) = 9(4i ) − 9(2i ) + 1 (5)

i+2 i+2
g(i) = (2 ) ∗ (2 − 3) + 1 (6)
f(0) = 1 g(0) = 5
f(1) = 19 g(1) = 41
f(2) = 109 g(2) = 209
f(5) = 505 g(3) = 929
produce complejidad O(n log2 (n))

Temas

Bubble Sort
Selection Sort
Insertion Sort
Divide y vencerás
Quick Sort
Merge Sort
Heap Sort
Radix Sort
3 Bibliografía

Bibliografía
Bruno R. Preiss, Data Structures and Algorithms with

Object-Oriented design patterns in java, John Wiley & Sons,
2000.
Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest,
Clifford Stein. Introduction to Algorithms, Second Edition,
McGrawHill, 2004.
Ordenamiento Shell
https://es.wikipedia.org/wiki/Ordenamiento_Shell

12 Ordenamientos Presentacion

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

12 Ordenamientos Presentacion

Cargado por

Copyright:

Formatos disponibles

Algoritmos basados en comparaciones Algoritmos por distribución Bibliografía

Verónica E. Arriola-Rios Ordenamientos

1 Algoritmos basados en comparaciones

Verónica E. Arriola-Rios Ordenamientos

1 Algoritmos basados en comparaciones

Verónica E. Arriola-Rios Ordenamientos

Verónica E. Arriola-Rios Ordenamientos

1 public static <C extends Comparable <? super C > >

Verónica E. Arriola-Rios Ordenamientos

1 Algoritmos basados en comparaciones

Verónica E. Arriola-Rios Ordenamientos

Busca el elemento más pequeño en el subarreglo restante y lo

Verónica E. Arriola-Rios Ordenamientos

1 public static void selectionSort ( Comparable [] a ){

Verónica E. Arriola-Rios Ordenamientos

1 Algoritmos basados en comparaciones

Verónica E. Arriola-Rios Ordenamientos

Inserta cada número en su posición correcta.

Verónica E. Arriola-Rios Ordenamientos

1 Algoritmos basados en comparaciones

Verónica E. Arriola-Rios Ordenamientos

Alrededor del pivote

Se elige algún número como pivote.

Verónica E. Arriola-Rios Ordenamientos

1 public static void quickSort ( Comparable [] a ) {

Verónica E. Arriola-Rios Ordenamientos

1 private static void quickSort ( Comparable [] a ,

Verónica E. Arriola-Rios Ordenamientos

Divide, ordena y mezcla

Parte el arreglo en mitades recursivamente hasta que sólo

Verónica E. Arriola-Rios Ordenamientos

9 10|8|7 6|5 4|3|2 1

Verónica E. Arriola-Rios Ordenamientos

1 public static void mergeSort ( Comparable [] a ) {

1 private static void msortDivide ( Comparable [] a ,

Verónica E. Arriola-Rios Ordenamientos

1 // middle : í ndice derecho subarreglo 1

Verónica E. Arriola-Rios Ordenamientos

1 Algoritmos basados en comparaciones

Verónica E. Arriola-Rios Ordenamientos

Árboles n-arios en arreglos

Dado que el número de hijos en un árbol n-ario es fijo:

Verónica E. Arriola-Rios Ordenamientos

Es posible determinar la posición del i-ésimo descendiente,

hijoj (i) = ni + (j + 1) (3)

donde i es la posición del nodo; j, el índice de su hijo,

Verónica E. Arriola-Rios Ordenamientos

Árbol binario en arreglo

hijoIzquierdo(i) → 2i + 1 padre(i) → b(i − 1)/2c

Verónica E. Arriola-Rios Ordenamientos

hijoIzquierdo(i) → 2i + 1 padre(i) → b(i − 1)/2c

Se inserta siempre en el siguiente nodo vacío.

Verónica E. Arriola-Rios Ordenamientos

Verónica E. Arriola-Rios Ordenamientos

Verónica E. Arriola-Rios Ordenamientos

Si los dos subárboles de un nodo son montículos máximos,

Verónica E. Arriola-Rios Ordenamientos

Verónica E. Arriola-Rios Ordenamientos

Construye montículo máximo

Es posible ordenar los elementos de un árbol casi completo

Verónica E. Arriola-Rios Ordenamientos

Intercambiar al nodo que se quiere remover con el último

Verónica E. Arriola-Rios Ordenamientos