Estructuras de datos. Algoritmos de ordenamiento. – Algoritmos simples: inserción, selección e intercambio – Algoritmo de Shell – Algoritmos HeapSort MergeSort – Algoritmo QuickSort – Algoritmos de ordenamiento externo

1. 1
Estructuras de Datos y
Estructuras de Datos y
Algoritmos
Algoritmos
Algoritmos de ordenamiento
Algoritmos de ordenamiento
Contenido
Contenido
§
§ Algoritmos de ordenamiento
Algoritmos de ordenamiento
–
– Algoritmos simples: inserci
Algoritmos simples: inserció
ón, selecci
n, selecció
ón e
n e
intercambio
intercambio
–
– Algoritmo de
Algoritmo de Shell
Shell
–
– Algoritmos
Algoritmos HeapSort
HeapSort MergeSort
MergeSort
–
– Algoritmo
Algoritmo QuickSort
QuickSort
–
– Algoritmos de ordenamiento externo
Algoritmos de ordenamiento externo

2. 2
Contenido
Contenido
§
§ En este cap
En este capí
ítulo se discutir
tulo se discutirá
á el problema de
el problema de
ordenar un arreglo de elementos.
ordenar un arreglo de elementos.
§
§ La mayor
La mayorí
ía de los algoritmos asumen que los
a de los algoritmos asumen que los
datos pueden almacenarse en su totalidad en la
datos pueden almacenarse en su totalidad en la
memoria principal. Al final se discutir
memoria principal. Al final se discutirá
á
ordenamiento externo.
ordenamiento externo.
§
§ Para ordenamiento interno se ver
Para ordenamiento interno se verá
á que:
que:
–
– Existen varios algoritmos simples de
Existen varios algoritmos simples de O(N
O(N2
2
).
).
–
– Algunos algoritmos m
Algunos algoritmos má
ás complicados cuyo peor caso es
s complicados cuyo peor caso es
O(N
O(N2
2
) pueden alcanzar en promedio
) pueden alcanzar en promedio O(N
O(N log
log N).
N).
–
– Un algoritmo de ordenamiento de
Un algoritmo de ordenamiento de proposito
proposito general
general
requiere
requiere Ω
Ω(N
(N log
log N) comparaciones.
N) comparaciones.
Ordenamiento Interno
Ordenamiento Interno
Consid
Considé
érese un arreglo
rese un arreglo
num
numé
érico de 5 elementos A1,
rico de 5 elementos A1,
A2, A3, A4, A5. Escriba un
A2, A3, A4, A5. Escriba un
programa que ordene los valores
programa que ordene los valores
en el arreglo de menor a mayor.
en el arreglo de menor a mayor.

3. 3
Clasificaci
Clasificació
ón de algoritmos de
n de algoritmos de
ordenamiento interno
ordenamiento interno
§
§ Su soluci
Su solució
ón probablemente pertenece a uno
n probablemente pertenece a uno
de los siguientes tipos:
de los siguientes tipos:
–
– Un ordenamiento por inserci
Un ordenamiento por inserció
ón.
n.
–
– Un ordenamiento por intercambio.
Un ordenamiento por intercambio.
–
– Un ordenamiento por selecci
Un ordenamiento por selecció
ón.
n.
–
– Un ordenamiento por enumeraci
Un ordenamiento por enumeració
ón.
n.
–
– Un algoritmo especializado.
Un algoritmo especializado.
–
– Una actitud perezosa.
Una actitud perezosa.
–
– Una t
Una té
écnica novedosa s
cnica novedosa sú
úper eficiente.
per eficiente.
Ordenamiento por inserci
Ordenamiento por inserció
ón
n
96
96
95
95
95
95
95
95
95
95
95
95
95
95
95
95
1,7
1,7
95
95
94
94
81
81
35
35
19
19
12
12
11
11
Pase 7
Pase 7
4,6
4,6
96
96
94
94
81
81
35
35
19
19
12
12
11
11
Pase 6
Pase 6
3,5
3,5
19
19
96
96
94
94
81
81
35
35
12
12
11
11
Pase 5
Pase 5
3,4
3,4
19
19
35
35
96
96
94
94
81
81
12
12
11
11
Pase 4
Pase 4
0,3
0,3
19
19
35
35
12
12
96
96
94
94
81
81
11
11
Pase 3
Pase 3
2,2
2,2
19
19
35
35
12
12
96
96
94
94
81
81
11
11
Pase 2
Pase 2
0,1
0,1
19
19
35
35
12
12
96
96
11
11
94
94
81
81
Pase 1
Pase 1
Movimientos y
Movimientos y
comparaciones
comparaciones
19
19
35
35
12
12
96
96
11
11
94
94
81
81
Original
Original
13,28

4. 4
Ordenamiento por inserci
Ordenamiento por inserció
ón
n
§
§ Se realiza en
Se realiza en N
N-
-1 pases.
1 pases.
§
§ Para el pase
Para el pase p
p = 1 hasta
= 1 hasta N
N-
-1 se ordenan los
1 se ordenan los
elementos en las posiciones 0 hasta
elementos en las posiciones 0 hasta p
p.
.
§
§ Al inicio de cada pase, los elementos en las
Al inicio de cada pase, los elementos en las
posiciones 0 hasta
posiciones 0 hasta p
p -
-1 est
1 está
án ordenados.
n ordenados.
Esta condici
Esta condició
ón se llama invariante de lazo.
n se llama invariante de lazo.
§
§ El algoritmo es
El algoritmo es Θ
Θ(
(N
N2
2
).
).
Ordenamiento por inserci
Ordenamiento por inserció
ón
n
/**
* Simple insertion sort.
* @param a an array of Comparable items.
*/
public static void insertionSort( Comparable [ ] a )
{
int j;
for( int p = 1; p < a.length; p++ )
{
Comparable tmp = a[ p ];
for( j = p; j>0 && tmp.compareTo(a[j-1])<0; j--)
a[ j ] = a[ j - 1 ];
a[ j ] = tmp;
}
}

5. 5
Ordenamiento por intercambio
Ordenamiento por intercambio
0,2
0,2
96
96
95
95
94
94
81
81
35
35
19
19
12
12
11
11
Pase 6
Pase 6
96
96
96
96
96
96
96
96
96
96
96
96
95
95
0,1
0,1
95
95
94
94
81
81
35
35
19
19
12
12
11
11
Pase 7
Pase 7
0,3
0,3
95
95
94
94
81
81
35
35
19
19
12
12
11
11
Pase 5
Pase 5
1,4
1,4
95
95
94
94
81
81
35
35
19
19
12
12
11
11
Pase 4
Pase 4
3,5
3,5
95
95
94
94
81
81
19
19
35
35
12
12
11
11
Pase 3
Pase 3
4,6
4,6
95
95
94
94
19
19
35
35
12
12
81
81
11
11
Pase 2
Pase 2
5,7
5,7
95
95
19
19
35
35
12
12
94
94
11
11
81
81
Pase 1
Pase 1
Movimientos y
Movimientos y
comparaciones
comparaciones
19
19
35
35
12
12
96
96
11
11
94
94
81
81
Original
Original
13,28
Ordenamiento por intercambio
Ordenamiento por intercambio
§
§ Se efect
Se efectú
úan
an N
N-
-1 pases.
1 pases.
§
§ Al inicio del pase
Al inicio del pase p
p = 1..
= 1..N
N-
-1 los
1 los ú
últimos
ltimos p
p-
-1
1
elementos del arreglo est
elementos del arreglo está
án ordenados.
n ordenados.
§
§ Se comparan todos los pares de elementos
Se comparan todos los pares de elementos
adyacentes entre 0..
adyacentes entre 0..p
p y se intercambian si
y se intercambian si
est
está
án fuera de orden.
n fuera de orden.
§
§ El algoritmo es
El algoritmo es Θ
Θ(
(N
N2
2
).
).

6. 6
Ordenamiento por intercambio
Ordenamiento por intercambio
public void bubbleSort(Comparable [] a)
{
int out, in;
for(out=a.length-1; out>=1; out--)
for(in=0; in<out; in++)
if( a[in].compareTo(a[in+1]) > 0 ) // out of order?
{
Comparable tmp = a[in]; // swap them
a[in] = a[in+1];
a[in+1] = tmp;
}
} // end bubbleSort()
Ordenamiento por selecci
Ordenamiento por selecció
ón
n
1,2
1,2
95
95
96
96
94
94
81
81
35
35
19
19
12
12
11
11
Pase 6
Pase 6
96
96
95
95
95
95
95
95
95
95
95
95
95
95
1,1
1,1
95
95
94
94
81
81
35
35
19
19
12
12
11
11
Pase 7
Pase 7
1,3
1,3
94
94
96
96
81
81
35
35
19
19
12
12
11
11
Pase 5
Pase 5
1,4
1,4
81
81
96
96
94
94
35
35
19
19
12
12
11
11
Pase 4
Pase 4
1,5
1,5
81
81
35
35
94
94
96
96
19
19
12
12
11
11
Pase 3
Pase 3
1,6
1,6
19
19
35
35
94
94
96
96
81
81
12
12
11
11
Pase 2
Pase 2
1,7
1,7
19
19
35
35
12
12
96
96
81
81
94
94
11
11
Pase 1
Pase 1
Movimientos y
Movimientos y
comparaciones
comparaciones
19
19
35
35
12
12
96
96
11
11
94
94
81
81
Original
Original
7,28

7. 7
Ordenamiento por selecci
Ordenamiento por selecció
ón
n
§
§ Se efect
Se efectú
úan
an N
N-
-1 pases.
1 pases.
§
§ Al inicio del pase
Al inicio del pase p
p = 1..(
= 1..(N
N-
-1) los primeros
1) los primeros
p
p-
-1 elementos del arreglo est
1 elementos del arreglo está
án ordenados.
n ordenados.
§
§ En cada pase se determina el m
En cada pase se determina el mí
ínimo de los
nimo de los
elementos
elementos p
p..(
..(N
N-
-1) y se intercambia este
1) y se intercambia este
con el elemento
con el elemento p
p.
.
§
§ El algoritmo es
El algoritmo es Θ
Θ(
(N
N2
2
).
).
Ordenamiento por selecci
Ordenamiento por selecció
ón
n
public void selectionSort(Comparable [] a)
{
int out, in, min;
for(out=0; out<a.length-1; out++)
{
min = out;
for(in=out+1; in<a.length; in++) // Find min
if(a[in].compareTo(a[min]) > 0 )
min = in;
Comparable tmp = a[in]; // Swap
a[in] = a[out];
a[out] = tmp;
} // end for(outer)
} // end selectionSort()

8. 8
Ordenamiento por enumeraci
Ordenamiento por enumeració
ón
n
6
6
95
95
8,56
8,56
2
2
3
3
1
1
7
7
0
0
5
5
4
4
Posici
Posició
ón
n
Movimientos y
Movimientos y
comparaciones
comparaciones
19
19
35
35
12
12
96
96
11
11
94
94
81
81
Arreglo
Arreglo
Ordenamiento por enumeraci
Ordenamiento por enumeració
ón
n
§
§ Se compara cada elemento con todos los
Se compara cada elemento con todos los
dem
demá
ás y se determina cuantos son menores
s y se determina cuantos son menores
que el. Se guarda esta informaci
que el. Se guarda esta informació
ón en un
n en un
arreglo auxiliar.
arreglo auxiliar.
§
§ El arreglo auxiliar contiene las posiciones
El arreglo auxiliar contiene las posiciones
finales de los elementos ordenados
finales de los elementos ordenados
§
§ Este algoritmo es
Este algoritmo es Θ
Θ(
(N
N2
2
).
).

9. 9
Ordenamiento por enumeraci
Ordenamiento por enumeració
ón
n
public void enumSort(Comparable [] a)
{
int out, in;
// Determine positions
pos = new int [a.length];
for (out=0; out<a.length; out++)
{ pos[out]=0;
for(in=0; in<a.length; in++)
if (in !=out && a[in].compareTo(a[out])>0)
++pos[out];
}
Ordenamiento por enumeraci
Ordenamiento por enumeració
ón
n
// Order elements
for (out=0; out<a.length; out++)
while (pos[out] != out)
{
Comparable atmp=a[out];
int ptmp=pos[out];
a[out]=a[ptmp];
pos[out]=pos[ptmp];
a[ptmp]=atmp;
pos[ptmp]=ptmp;
}
} // end enumSort()

10. 10
Ordenamiento de
Ordenamiento de Shell
Shell
96
96
96
96
96
96
95
95
5,28
5,28
95
95
94
94
81
81
35
35
19
19
12
12
11
11
Ord
Ord-
-1
1
3,12
3,12
81
81
95
95
19
19
94
94
12
12
35
35
11
11
Ord
Ord-
-2
2
3,4
3,4
19
19
94
94
81
81
95
95
11
11
35
35
12
12
Ord
Ord-
-4
4
Movimientos y
Movimientos y
comparaciones
comparaciones
19
19
35
35
12
12
96
96
11
11
94
94
81
81
Original
Original
11,44
Ordenamiento de
Ordenamiento de Shell
Shell
§
§ Inventado por
Inventado por Donald
Donald Shell
Shell en 1959.
en 1959.
§
§ Divide el arreglo en
Divide el arreglo en sub
sub-
-arreglos cuyos elementos
arreglos cuyos elementos
est
está
án separados por una distancia
n separados por una distancia g
gi
i.
.
§
§ Ordena (por inserci
Ordena (por inserció
ón) todos los arreglos con
n) todos los arreglos con
separaci
separació
ón
n g
gi
i y luego repite el paso anterior
y luego repite el paso anterior
usando
usando g
gi
i+1
+1 <
< g
gi
i.
.
§
§ La secuencia de valores de
La secuencia de valores de g
g debe ser
debe ser
decreciente y terminar en uno.
decreciente y terminar en uno.
§
§ La selecci
La selecció
ón de la secuencia de valores de g tiene
n de la secuencia de valores de g tiene
un importante influencia sobre la eficiencia del
un importante influencia sobre la eficiencia del
algoritmo.
algoritmo.

11. 11
Ordenamiento de
Ordenamiento de Shell
Shell
/**
* Shellsort, using Shell's (poor) increments.
* @param a an array of Comparable items.
*/
public static void shellsort( Comparable [ ] a )
{
int j;
for( int gap = a.length / 2; gap > 0; gap /= 2 )
for( int i = gap; i < a.length; i++ )
{
Comparable tmp = a[ i ];
for( j = i; j >= gap &&
tmp.compareTo( a[j-gap] ) < 0; j -= gap )
a[ j ] = a[ j - gap ];
a[ j ] = tmp;
}
}
Ordenamiento de
Ordenamiento de Shell
Shell
§
§ La secuencia inicial de
La secuencia inicial de Shell
Shell (
(…
….,8,4,2,1) es
.,8,4,2,1) es
particularmente ineficiente.
particularmente ineficiente.
§
§ La mejor secuencia conocida (
La mejor secuencia conocida (…
….,109, 41, 19, 5,
.,109, 41, 19, 5,
1) tiene terminos de la forma 9(4
1) tiene terminos de la forma 9(4i
i-
-2
2i
i)+1
)+1 ó
ó 4
4i
i-
-3*2
3*2i
i+1
+1
§
§ En general las mejores secuencias son aquellas
En general las mejores secuencias son aquellas
cuyos componentes son primos relativos
cuyos componentes son primos relativos
§
§ En el peor caso el algoritmo es
En el peor caso el algoritmo es Θ
Θ(
(N
N2
2).
).
§
§ El caso promedio es dif
El caso promedio es difí
ícil de analizar se
cil de analizar se
conjetura que con la secuencia anterior el
conjetura que con la secuencia anterior el
algoritmo es
algoritmo es O(N
O(N7
7/6
/6).
).

12. 12
HeapSort
HeapSort
§
§ Este algoritmo es
Este algoritmo es O(N
O(N log
log N).
N).
§
§ Utiliza una estructura de datos conocida como
Utiliza una estructura de datos conocida como
heap
heap (mont
(montí
ículo) que es un
culo) que es un á
árbol binario con las
rbol binario con las
siguientes caracter
siguientes caracterí
ísticas:
sticas:
–
– Estructural: El
Estructural: El á
árbol est
rbol está
á lleno en todos los niveles
lleno en todos los niveles
excepto el
excepto el ú
último que se llena de Izquierda a derecha.
ltimo que se llena de Izquierda a derecha.
–
– De orden: el nodo padre es mayor que sus dos hijos.
De orden: el nodo padre es mayor que sus dos hijos.
§
§ Estas caracter
Estas caracterí
ísticas permiten que el
sticas permiten que el heap
heap se
se
almacene en un arreglo en la que:
almacene en un arreglo en la que:
–
– Los hijos del nodo i est
Los hijos del nodo i esté
én en las posiciones 2*i y 2*i+1.
n en las posiciones 2*i y 2*i+1.
–
– El nodo mayor est
El nodo mayor está
á en la ra
en la raí
íz del
z del á
árbol.
rbol.
Heap
Heap
97
53
26 41
59
58 31
9
9
8
8
7
7
6
6
5
5
4
4
3
3
2
2
1
1
0
0
31
31
58
58
41
41
26
26
59
59
53
53
97
97

13. 13
Heap
Heap luego de eliminar el m
luego de eliminar el má
áximo
ximo
59
53
26 41
58
31 97
9
9
8
8
7
7
6
6
5
5
4
4
3
3
2
2
1
1
0
0
97
97
31
31
41
41
26
26
58
58
53
53
59
59
HeapSort
HeapSort
public static void heapsort( Comparable [ ] a )
{
for( int i = a.length / 2; i >= 0; i-- ) // buildHeap
percDown( a, i, a.length );
for( int i = a.length - 1; i > 0; i-- )
{
swapReferences( a, 0, i ); // deleteMax
percDown( a, 0, i );
}
}
private static int leftChild( int i )
{
return 2 * i + 1;
}

14. 14
HeapSort
HeapSort
private static void percDown( Comparable [ ] a, int i, int n )
{
int child;
Comparable tmp;
for( tmp = a[ i ]; leftChild( i ) < n; i = child )
{
child = leftChild( i );
if(child!= n-1 && a[child].compareTo(a[child+1])<0)
child++;
if( tmp.compareTo( a[ child ] ) < 0 )
a[ i ] = a[ child ];
else
break;
}
a[ i ] = tmp;
}
MergeSort
MergeSort
§
§ Si se tienen dos arreglos A y B ordenados, se
Si se tienen dos arreglos A y B ordenados, se
puede obtener un arreglo que contenga todos los
puede obtener un arreglo que contenga todos los
elementos de A y B en orden en un tiempo lineal.
elementos de A y B en orden en un tiempo lineal.
§
§ Aplicando
Aplicando recursivamente
recursivamente este concepto a las dos
este concepto a las dos
mitades de un arreglo que se desea ordenar, se
mitades de un arreglo que se desea ordenar, se
obtiene un algoritmos
obtiene un algoritmos O(N
O(N logN
logN)
)
§
§ La desventaja de este algoritmo es que se
La desventaja de este algoritmo es que se
requiere un arreglo de trabajo adicional del mismo
requiere un arreglo de trabajo adicional del mismo
tama
tamañ
ño del que se desea ordenar
o del que se desea ordenar
§
§ Mergesort
Mergesort forma la base de los algoritmos de
forma la base de los algoritmos de
ordenamiento externo
ordenamiento externo

15. 15
MergeSort
MergeSort
26
26
24
24
13
13
1
1 38
38
27
27
15
15
2
2
1
1 2
2 13
13 26
26
15
15 24
24 27
27 38
38
MergeSort
MergeSort
public static void mergeSort( Comparable [ ] a )
{
Comparable [ ] tmpArray = new Comparable[ a.length ];
mergeSort( a, tmpArray, 0, a.length - 1 );
}
private static void mergeSort(Comparable [0] a,
Comparable [] tmpArray, int left, int right )
{
if( left < right )
{
int center = ( left + right ) / 2;
mergeSort( a, tmpArray, left, center );
mergeSort( a, tmpArray, center + 1, right );
merge( a, tmpArray, left, center + 1, right );
}
}

16. 16
MergeSort
MergeSort
private static void merge( Comparable [ ] a, Comparable [ ]
tmpArray, int leftPos, int rightPos, int rightEnd )
{
int leftEnd = rightPos - 1;
int tmpPos = leftPos;
int numElements = rightEnd - leftPos + 1;
// Main loop
while( leftPos <= leftEnd && rightPos <= rightEnd )
if( a[ leftPos ].compareTo( a[ rightPos ] ) <= 0 )
tmpArray[ tmpPos++ ] = a[ leftPos++ ];
else
tmpArray[ tmpPos++ ] = a[ rightPos++ ];
while( leftPos <= leftEnd ) // Copy rest of first half
tmpArray[ tmpPos++ ] = a[ leftPos++ ];
while( rightPos <= rightEnd ) // Copy rest of right half
tmpArray[ tmpPos++ ] = a[ rightPos++ ];
// Copy tmpArray back
for( int i = 0; i < numElements; i++, rightEnd-- )
a[ rightEnd ] = tmpArray[ rightEnd ];
}
QuickSort
QuickSort
§
§ Desarrollado por C. A. R.
Desarrollado por C. A. R. Hoare
Hoare en 1962.
en 1962.
§
§ Es el algoritmo m
Es el algoritmo má
ás r
s rá
ápido conocido
pido conocido
§
§ En promedio es
En promedio es O(N
O(N log
log N), pero el peor case es
N), pero el peor case es
O(N
O(N2
2). Es posible hacer que el peor caso sea
). Es posible hacer que el peor caso sea
exponencialmente improbable.
exponencialmente improbable.
§
§ Se basa en el concepto de partici
Se basa en el concepto de partició
ón. En una
n. En una
partici
partició
ón se escoge un pivote y se colocan los
n se escoge un pivote y se colocan los
elementos mayores que el pivote en la parte
elementos mayores que el pivote en la parte
superior del arreglo y los menores en la inferior.
superior del arreglo y los menores en la inferior.
§
§ Se aplica este concepto en forma recursiva para
Se aplica este concepto en forma recursiva para
obtener el algoritmo.
obtener el algoritmo.

17. 17
Partici
Partició
ón
n
1
8 4 9 0 3 5 2 7 6
Pivote: 6
2 8
9
5 6 9
int i = left, j = right - 1;
for( ; ; )
{
while( a[ ++i ].compareTo( pivot ) < 0 ) { }
while( a[ --j ].compareTo( pivot ) > 0 ) { }
if( i < j )
swapReferences( a, i, j );
else
break;
}
swapReferences( a, i, right - 1 ); // Restore pivot
QuickSort
QuickSort
§
§ Para que
Para que quicksort
quicksort sea eficiente es importante
sea eficiente es importante
escoger pivotes de modo que las particiones sean
escoger pivotes de modo que las particiones sean
aproximadamente del mismo tama
aproximadamente del mismo tamañ
ño.
o.
§
§ Escoger consistentemente el mayor (o menor)
Escoger consistentemente el mayor (o menor)
elemento como pivote resulta en el peor caso de
elemento como pivote resulta en el peor caso de
O(N
O(N2
2)
)
§
§ Un buen m
Un buen mé
étodo para escoger el pivote es tomar
todo para escoger el pivote es tomar
la mediana entre los elementos primero. central y
la mediana entre los elementos primero. central y
ú
último
ltimo
§
§ Otra forma de acelerar el proceso, es no usar
Otra forma de acelerar el proceso, es no usar
quicksort
quicksort para arreglos peque
para arreglos pequeñ
ños.
os.

18. 18
QuickSort
QuickSort
public static void quicksort( Comparable [ ] a ) {
quicksort( a, 0, a.length - 1 ); }
private static void quicksort(Comparable[]a,int left,int right){
if( left + CUTOFF <= right ){
Comparable pivot = median3( a, left, right );
int i = left, j = right - 1; // Begin partitioning
for( ; ; ) {
while( a[ ++i ].compareTo( pivot ) < 0 ) { }
while( a[ --j ].compareTo( pivot ) > 0 ) { }
if( i < j )
swapReferences( a, i, j );
else
break;}
swapReferences( a, i, right - 1 ); // Restore pivot
quicksort( a, left, i - 1 ); // Sort small elements
quicksort( a, i + 1, right ) // Sort large elements}
else // Do an insertion sort on the subarray
insertionSort( a, left, right );
}
QuickSort
QuickSort
private static final int CUTOFF = 3;
public static final void swapReferences(Object [] a, int index1,
int index2 ) {
Object tmp = a[ index1 ];
a[ index1 ] = a[ index2 ];
a[ index2 ] = tmp;
}
private static Comparable median3( Comparable [ ] a, int left,
int right ) {
int center = ( left + right ) / 2;
if( a[ center ].compareTo( a[ left ] ) < 0 )
swapReferences( a, left, center );
if( a[ right ].compareTo( a[ left ] ) < 0 )
swapReferences( a, left, right );
if( a[ right ].compareTo( a[ center ] ) < 0 )
swapReferences( a, center, right );
swapReferences( a, center, right - 1 ); // Place pivot
return a[ right - 1 ];
}

19. 19
QuickSort
QuickSort
private static void insertionSort( Comparable [ ] a, int left,
int right )
{
for( int p = left + 1; p <= right; p++ )
{
Comparable tmp = a[ p ];
int j;
for( j = p; j > left && tmp.compareTo( a[j-1] ) < 0; j-- )
a[ j ] = a[ j - 1 ];
a[ j ] = tmp;
}
}
Á
Árboles de decisi
rboles de decisió
ón
n
a<b<c
a<c<b
b<a<c
b<c<a
c<a<b
c<b<a
a<b<c
a<c<b
c<a<b
b<a<c
b<c<a
c<b<a
a<b<c
a<c<b
c<a<b
a<b<c a<c<b
b<a<c
b<c<a
c<b<a
b<c<a
b<a<c
b<a
a<b
c<a
a<c
c<b
b<c
b<c
c<b
c<a
a<c
Teorema: Cualquier algoritmo de ordenamiento que usa solamente comparaciones
entre elementos requiere Ω(N log N) comparaciones.
N = 3
3! = 6
Log2 6 = 2.585 = 3 0
1
2
3
d = 3
23 = 8 > 6

20. 20
Ordenamiento externo
Ordenamiento externo
§
§ Las operaciones de entrada y salida son
Las operaciones de entrada y salida son
cientos de miles de veces mas lentas que
cientos de miles de veces mas lentas que
las del CPU.
las del CPU.
§
§ Los algoritmos de esta secci
Los algoritmos de esta secció
ón asumen
n asumen
acceso secuencial a los archivos.
acceso secuencial a los archivos.
§
§ En vez de leer un registro a la vez, se leen
En vez de leer un registro a la vez, se leen
bloques que se ordenan en memoria antes
bloques que se ordenan en memoria antes
de escribirlos en el archivo de salida. Estos
de escribirlos en el archivo de salida. Estos
bloques se llaman corridas.
bloques se llaman corridas.
Un algoritmo simple
Un algoritmo simple
§
§ Este algoritmo usa
Este algoritmo usa mergesort
mergesort y cuatro archivos
y cuatro archivos
(cintas).
(cintas).
§
§ Se leen bloques de tama
Se leen bloques de tamañ
ño M de la cinta de
o M de la cinta de
entrada, se ordenan en memoria y se escriben
entrada, se ordenan en memoria y se escriben
alternadamente en dos cintas de salida.
alternadamente en dos cintas de salida.
§
§ Se leen dos corridas, una de cada cinta,
Se leen dos corridas, una de cada cinta,
obteni
obtenié
éndose corridas de longitud 2M, que se
ndose corridas de longitud 2M, que se
escriben alternadamente en las otras dos cintas.
escriben alternadamente en las otras dos cintas.
§
§ Se requieren
Se requieren 
log(N
log(N/
/M)
M)
 pases para ordenar los
pases para ordenar los
datos.
datos.

21. 21
Un algoritmo simple
Un algoritmo simple
75
75
58
58
41
41
96
96
35
35
12
12
T4
T4
15
15
99
99
28
28
17
17
94
94
81
81
11
11
T3
T3
T2
T2
T1
T1
T4
T4
T3
T3
T2
T2
T1
T1 15
15
75
75
41
41
58
58
28
28
99
99
17
17
35
35
12
12
96
96
11
11
94
94
81
81
Un algoritmo simple
Un algoritmo simple
99
99
15
15
T4
T4
96
96
94
94
81
81
75
75
58
58
41
41
35
35
28
28
17
17
12
12
11
11
T3
T3
T2
T2
T1
T1
T4
T4
T3
T3
T2
T2
T1
T1
99
99
75
75
58
58
41
41
28
28
17
17
15
15
96
96
94
94
81
81
35
35
12
12
11
11

22. 22
Mezcla m
Mezcla mú
últiple
ltiple
§
§ Se puede reducir el n
Se puede reducir el nú
úmero de pases del
mero de pases del
algoritmo anterior puede reducirse usando
algoritmo anterior puede reducirse usando
2k cintas.
2k cintas.
§
§ Se generan k corridas de tama
Se generan k corridas de tamañ
ño M.
o M.
§
§ En cada paso, excepto el primero se
En cada paso, excepto el primero se
mezclan corridas de k cintas
mezclan corridas de k cintas obteneindose
obteneindose
corridas de tama
corridas de tamañ
ño k*M.
o k*M.
§
§ Se requieren
Se requieren 
log
logk
k(N
(N/
/M)
M)
 pases para
pases para
ordenar los datos.
ordenar los datos.
Un algoritmo simple
Un algoritmo simple
T6
T6
T5
T5
T4
T4
T3
T3
T2
T2
T1
T1 15
15
75
75
41
41
58
58
28
28
99
99
17
17
35
35
12
12
96
96
11
11
94
94
81
81
99
99
28
28
17
17
T6
T6
15
15
96
96
35
35
12
12
T5
T5
T4
T4
T3
T3
T2
T2
T1
T1
75
75
58
58
41
41
94
94
81
81
11
11

23. 23
Un algoritmo simple
Un algoritmo simple
T6
T6
T5
T5
T4
T4
T3
T3
T2
T2
T1
T1
75
75
58
58
41
41
15
15
99
99
96
96
94
94
81
81
35
35
28
28
17
17
12
12
11
11
T6
T6
T5
T5
T4
T4
T3
T3
T2
T2
T1
T1
99
99
96
96
94
94
81
81
75
75
58
58
41
41
35
35
28
28
17
17
15
15
12
12
11
11
Mezcla polif
Mezcla polifá
ásica
sica
§
§ Consiste en efectuar una mezcla m
Consiste en efectuar una mezcla mú
últiple
ltiple
utilizando k+1 cintas.
utilizando k+1 cintas.
§
§ Para que el algoritmo sea eficiente, las
Para que el algoritmo sea eficiente, las
corridas se distribuyen inicialmente de
corridas se distribuyen inicialmente de
forma desigual en las k cintas de salida,
forma desigual en las k cintas de salida,
siguiendo los n
siguiendo los nú
úmeros de
meros de Fibonacci
Fibonacci de
de
orden k:
orden k: F
Fk
k
(n
(n)=
)=F
Fk
k
(n
(n-
-1)+
1)+F
Fk
k
(n
(n-
-2)
2)…
…F
Fk
k
(n
(n-
-k).
k).
§
§ Durante las operaciones de mezcla, al
Durante las operaciones de mezcla, al
terminarse las corridas en una de las cintas,
terminarse las corridas en una de las cintas,
esa se convierte en la nueva cinta de salida.
esa se convierte en la nueva cinta de salida.

24. 24
Mezcla con reemplazo
Mezcla con reemplazo
§
§ Se lee una corrida de M elementos y se coloca en
Se lee una corrida de M elementos y se coloca en
un mont
un montí
ículo (
culo (heap
heap).
).
§
§ Se ejecuta un
Se ejecuta un deleteMin
deleteMin,
, se env
se enví
ía a la salida y
a a la salida y
se lee un nuevo registro. Si este es mayor que el
se lee un nuevo registro. Si este es mayor que el
valor anterior se coloca en el
valor anterior se coloca en el heap
heap sino se coloca
sino se coloca
en el espacio vac
en el espacio vací
ío al final del mismo.
o al final del mismo.
§
§ Cuando se vac
Cuando se vací
ía el
a el heap
heap se da por terminada la
se da por terminada la
corrida y se crea un nuevo
corrida y se crea un nuevo heap
heap.
.
§
§ La ventaja de este algoritmo es que produce
La ventaja de este algoritmo es que produce
corridas m
corridas má
ás largas y por tanto menos pases.
s largas y por tanto menos pases.
Mezcla con reemplazo
Mezcla con reemplazo
15
15
15
15
Corrida 3
Corrida 3
Recrear
Recrear heap
heap
Fin de corrida
Fin de corrida
15
15
99
99
15
15
99
99
Fin de cinta
Fin de cinta
58
58
15
15
99
99
58
58
15
15
41
41
58
58
99
99
41
41
41
41
35
35
58
58
99
99
35
35
58
58
28
28
35
35
99
99
28
28
28
28
17
17
99
99
35
35
17
17
99
99
12
12
35
35
17
17
12
12
Corrida 2
Corrida 2
Recrear
Recrear heap
heap
Fin de corrida
Fin de corrida
12
12
35
35
17
17
17
17
96
96
12
12
35
35
96
96
35
35
94
94
12
12
96
96
94
94
12
12
81
81
96
96
94
94
81
81
96
96
11
11
81
81
94
94
11
11
Corrida 1
Corrida 1
Pr
Pró
óximo
ximo
Salida
Salida
Mont
Montí
ículo (
culo (heap
heap)
)

25. 25
Resumen
Resumen
41.282
41.282
47.065
47.065
104.68
104.68
71.164
71.164
NA
NA
1.000.000
1.000.000
3.5882
3.5882
4.2298
4.2298
8.8591
8.8591
5.7298
5.7298
NA
NA
100.000
100.000
0.31532
0.31532
0.36765
0.36765
0.71650
0.71650
0.42998
0.42998
58.864
58.864
10.000
10.000
0.02587
0.02587
0.03153
0.03153
0.05565
0.05565
0.02927
0.02927
0.59564
0.59564
1.000
1.000
0.00244
0.00244
0.00248
0.00248
0.00420
0.00420
0.00171
0.00171
0.00675
0.00675
100
100
0.00046
0.00046
0.00052
0.00052
0.00057
0.00057
0.00041
0.00041
0.00044
0.00044
10
10
Quicksort
Quicksort
Opt.
Opt.
Quicksort
Quicksort
O(N
O(N log
log N)
N)
Heapsort
Heapsort
O(N
O(N log
log N)
N)
Shellsort
Shellsort
O(N
O(N7
7/6
/6
)?
)?
Inseci
Inseció
ón
n
O(N
O(N2
2
)
)
N
N