Beruflich Dokumente
Kultur Dokumente
Mtodos de Ordenamiento
Arturo Daz Prez
Sorting-1
Tipos de Ordenamiento
F Ordenamiento interno.
Se lleva a cabo completamente en memoria principal. Todos los
objetos que se ordenan caben en la memoria principal de la
computadora
F Ordenamiento externo.
No cabe toda la informacin en memoria principal y es necesario
ocupar memoria secundaria. El ordenamiento ocurre
transfiriendo bloques de informacin a memoria principal en
donde se ordena el bloque y este es regresado, ya ordenado, a
memoria secundaria
Sorting-2
Formulacin
Registros:
Llaves:
Obtener la secuencia
tal que,
Sorting-3
Criterios de Eficiencia
F Criterios de eficiencia
El nmero de pasos
El nmero de comparaciones entre llaves para ordenar n
registros.
/De utilidad cuando la comparacin entre llaves es costosa
El nmero de movimientos de registros que se requieren para
ordenar n registros.
/De utilidad cuando el movimiento de registros es costoso
Sorting-4
Sorting-5
Mtodo de Burbujeo
25
12
19
25
12
19
25
12 19
25
12
19
25
12 19
25
12 19
12
25 19
19 25
Sorting-6
Mtodo de Burbujeo
void Burbujeo( int A[], int n)
{
int i,j;
for( i=0; i < n-1; i++ )
for( j=n-1; j > i; j--)
if( A[j] < A[j-1] )
Intercambia( &A[j], &A[j-1] );
}
n 1
n 1
i =1
i =1
Comparaciones:
c = (n i ) = i =
Movimientos:
M min = 0
n 1
n 1
i =1
i =1
n(n 1) n 2 n
=
2
2 2
M max = ( n i ) = i =
n(n 1) n 2 n
=
2
2 2
Sorting-7
Mtodo de Seleccin
25
12
19
12
19
25
12
19
25
19
12
25
12
25
19
25
12
19
12
25
19
19
25
Sorting-8
Mtodo de Seleccin
void Seleccin( int A[], int n )
{
int
i, j, imin;
for( i=0; i < n-1; i++ ) {
imin = i;
for( j = i+1; j > n; j++ )
if( A[j] < A[imin] )
imin = j;
intercambia( &A[i], &A[imin] );
}
}
n1
n1
i=1
i =1
C = n i = i =
Comparaciones:
Movimientos:
n(n 1) n2 n
=
2
2 2
M = n 1
Sorting-9
Mtodo de Insercin
25
12
19
25
12
12
25
19
12
19
25
12
19
25
12
19
25
12
19
25
12
19
25
Sorting-10
Mtodo de Insercin
void Insercin( int A[], int n )
{
int i,j;
for( i=1; i < n; i++ ) {
j:= i;
while( j > 0 && A[j] < A[j-1] ) {
Intercambia( &A[j], &A[j-1] );
j-}
}
}
Comparaciones:
Cmin = n 1
n 1
n 1
i =1
i =1
Cmax = ( n i ) = i =
n( n 1) n 2 n
=
2
2 2
M min = 0
Movimientos:
n 1
M max = i =
i =1
n ( n 1) n 2 n
=
2
2 2
Sorting-11
QuickSort
F Dado un arreglo desordenado de n elementos
1 2 3
n-1 n
j-1
1 2
< v
Anlisis y Diseo de Algoritmos
j
v
>v
Sorting-12
QuickSort
1 2
j-1
1 2
j
v
< v
>v
void quicksort( int A[], int i, int j )
{
if( desde A[i] hasta A[j] existen al
menos dos llaves distintas ) {
Seleccionar un pivote, v
Permutar A[i], ...,A[j], tal que,
para algn k entre i+1 y j,
A[i], ..., A[k-1] < v y
A[k], . . . , A[j] v
quicksort( A, i, k-1 );
quicksort( A, k, j );
}
}
Sorting-13
QuickSort: Pivote
i
Sorting-14
QuickSort: Particionamiento
j
i
<v
A[p] <v,
A[p] v,
i p <l
r <p j
>v
El tiempo de ejecucin de
particin es O(j-i+1)
Sorting-15
QuickSort: Particionamiento
Sorting-16
QuickSort: Ejemplo
Pivote 25
25
Pivote 6
Pivote 3 3
12
12
12
25
Pivote 12
12
Pivote 9
9
Sorting-17
Sorting-18
rn
rn-1
r1
r2
El tiempo tomado por quicksort para este caso es la suma sobre todos los
elementos del nmero de veces que el elemento forma parte de un subarreglo
en el cual se hace un llamado a quicksort.
Sorting-19
r1
2r
i=2
i=2
n + n i + 2 = n + i
= n+
n(n + 1)
1
2
n 2 3n
+ 1
2
2
Sorting-20
10
Sorting-21
Sorting-22
11
T ( n ) c2 n +
i =1
2i
[T (i ) + T (n i )]
n(n 1)
Sorting-23
n 1
n 1
1 n1
i =1
i =1
i =1
i =1
f (i ) = f ( n i ) f (i ) = 2 f (i ) + f ( n i )
F Aplicndolo a la recurrencia con T(n), se tiene
n 1
T ( n ) c2 n +
i =1
T ( n)
2i
[T (i ) + T (n i )]
n(n 1)
f(i)
1 n 1 2i
2( n i )
[T (i) + T (n i)] +
[T (n i) + T (i)] + c2 n
n( n 1)
2 i =1 n( n 1)
1 n 1 i
ni
1 n 1
(T (i) + T (n i)) + c2 n ,
n 1 i =1
por lo tanto
Sorting-24
12
1 n 1
(T (i) + T (n i)) + c2 n
n 1 i =1
F Por lo tanto,
T ( n)
2 n 1
T (i) + c2 n
n 1 i =1
Sorting-25
2 n 1
T (i) + c2 n
n 1 i =1
Sorting-26
13
2 n 1
T (i) + c2 n
n 1 i =1
2 n 1
ci log i + c2n
n 1 i =1
n 1
2c 2
T ( n)
i log i + i log i + c2 n
n 1 i =1
i = n2 +1
n 1
2c 2
i (log n 1) + i log n + c2 n
n 1 i =1
n
i = 2 +1
2c n n
nn 3 n
+ 1 log n + 1 + n 1 log n + c2 n
n 1 4 2
42 4 2
Sorting-27
2c n n
nn 3 n
+ 1 log n + 1 + n 1 log n + c2 n
n 1 4 2
42 4 2
T ( n)
n 2 n
2c n 2 n
log n + + c2 n
n 1 2 2
8 4
2c n(n 1)
n 2 + 2n
log n
+ c2 n
n 1 2
8
cn log n
cn
cn
+ c2 n
4 2( n 1)
Sorting-28
14
HeapSort
F Estructura de datos abstracta
AGREGA, BORRAMIN, VACIA e INICIA
(1)
(2)
(3)
(4)
(5)
(6)
(7)
INICIA( S);
for( cada elemento, x, a ordenar )
AGREGA( x, S );
while( !VACIA(S) ) {
y = BORRA_MIN(S);
printf(" ... ", y );
}
10
11
12
9
4
9
9
8
Sorting-30
15
HeapSort, cont.
9 5 4 9 1 3 6 3 7 9 2 8
1
10
11
12
9
4
9
7
F Nota:
Si n es el nmero de elementos del arreglo, n/2 son nodos
interiores del rbol binario.
HeapSort: Descenso.
F Supongamos que los elementos
A[i], . . . ,A[j]
Sorting-32
16
HeapSort: Descenso.
void desciende( int A, int i, int j )
{
int r;
r = i;
while( r <= j/2) {
if( 2*r+1 > j ) { /* r tiene slo un hijo */
if( comp( A[r], A[2*r]) > 0 )
intercambia ( &A[r], &A[2*r] );
r = j;
} else { /* r tiene dos hijos */
if( comp( A[r], A[2*r] ) > 0 &&
comp( A[2*r], A[2*r+1] ) <= 0 ) {
intercambia( &A[r], &A[2*r] );
r = 2*r;
} else if( comp( A[r], A[2*r+1] ) > 0 &&
comp( A[2*r+1], A[2*r] ) <= 0 ) {
intercambia( &A[r], &A[2*r+1] );
r = 2*r+1;
} else
/* no se viola la propiedad de los rboles
parcialmente ordenados */
r = j;
}
}
Sorting-33
HeapSort, cont.
A[1]
A[n-k] A[n-k+1]
A[n]
arreglo en orden no
creciente
rbol parcialmente
ordenado
Sorting-34
17
Ordenamiento Lineal
F Supongamos que las llaves son enteros en el rango de 1 a n, y
que no existen llaves iguales.
Si A y B son arreglos de tipo adecuado y los n elementos que van a ser
ordenados estn inicialmente en A, se pueden colocar en el arreglo B en
el orden de sus llaves mediante
for( i = 1; i <= n; i++ )
B[ A[i].llave ] = A[i];
Sorting-35
Ordenamiento Lineal
F Se puede usar otra forma para ordenar el arreglo A con llaves
1, ..., n usando el mismo arreglo en tiempo O(n).
Se visitan A[1], . . . , A[n] en ese orden.
/Si el registro A[i] tiene una llave j i, se intercambia con A[j].
/Si despus del intercambio, el elemento que est ahora en A[i]
tiene llave k i, se intercambia A[i] con A[k], y se sigue as hasta
que en A[i] quede el registro con llave i.
for( i=1; i <= n; i++ )
while( A[i].llave != i )
intercambia(&A[i], &A[ A[i].llave] );
Cada intercambio coloca algn registro en su lugar y una vez ah nunca
se mueva ms.
Anlisis y Diseo de Algoritmos
Sorting-36
18
Ordenamiento Lineal
Si se permiten llaves duplicadas, entonces, para cada valor llave, k,
debe existir una lista, L[k], de todos los elementos con la llave k.
1
2
rp
rq
Sorting-37
Ordenamiento Lineal
#define
typedef
MAX_LLAVE
. . . LISTA
. . .
*/
Si INICIA, INSERTA y
CONCATENA toman un tiempo O(1)
y MAX_LLAVE < n, entonces, la
funcin anterior toma un tiempo O(n).
Sorting-38
19
BinSort: Inserta
Operacin de Insercin
inicio
fin
Sorting-39
BinSort: Concatena
Operacin de Concatenacin
Sorting-40
20
BinSort
F Observaciones:
Suponga que se desea ordenar una lista de valores enteros en el
rango 0 a n2-1. Se utilizan n cubetas, una para cada uno de los
enteros 0,1, . . . ,n-1
Dos fases:
/Se coloca el entero i al final de la cubeta i mod n
/Se seleccionan los valores en el orden en que estn
almacenados en las cubetas desde la 0 hasta la n-1. El entero i
se coloca al final de la cubeta i/n
Sorting-41
BinSort: Ejemplo
F Ejemplo
0, 1, 81, 64, 4, 25, 36, 16, 9, 49
Primera Fase
Cubeta
0
1
2
3
4
5
6
7
8
9
Segunda Fase
Contenido
0
1,81
64,4
25
36,16
9,49
Cubeta
0
1
2
3
4
5
6
7
8
9
Contenido
0,1,4,9
16
25
36
49
64
81
Sorting-42
21
BinSort
F Observaciones:
Si los nmeros i, j estn en el rango 0 a n2-1 se puede pensar que
ellos se pueden expresar en base n como nmeros de dos dgitos,
esto es,
/i = an + b y j = cn + d, donde a, b, c, y d estn dentro del
rango 0,n-1
/Si i < j, entonces, a c
3 Si a < c, i aparece en una cubeta menor a la de j en la segunda
pasada, as que i preceder a j en el ordenamiento final.
3 Si a = c, entonces, b <d.
En la primera pasada i debe preceder a j, i en b y j en d.
En la segunda pasada i y j son colocados en la misma
cubeta, i antes que j
Sorting-43
RadixSort
F Suponga que se desea ordenar una lista de elementos cuyos
valores llave consisten de k componentes, f1, f2, . . . , fk, cuyos
tipos son t1, t2, ..., tk.
F Orden lexicogrfico
(a1, a2, ..., ak) es menor que (b1, b2, ..., bk), si sucede solo una de las
condiciones siguientes:
a1 < b1
a1 = b1 y a2 < b2
...
a1 = b1, a2 = b2, ..., ak-1 = bk-1 y ak < bk
/As, para algn j entre 0 y k-1, a1 = b1, ..., aj = bj y aj+1 < bj+1.
Sorting-44
22
RadixSort
F La idea clave detrs del mtodo es ordenar todos los elementos
de acuerdo al campo fk (el dgito menos significativo ) y luego
concatenar las cubetas.
Despus aplicar el mtodo para fk-1 y as hasta f1.
Sorting-45
RadixSort
void RadixSort()
/* Ordena la lista A de n elementos con llaves que
consisten de los campos f1, f2, ..., fk de tipos
t1, t2, . . . , tk, respectivamente. Utiliza arreglos
Bi, 1 i k, para las cubetas de los valores en el
campo fi */
{
(1) for( i = k; k >= 1; k-- ) {
(2)
for( cada valor v del tipo ti )
(3)
INICIA( Bi[v] );
(4)
(5)
(6)
(7)
}
}
Sorting-46
23
RadixSort
void RadixSort()
{
(1) for( i = k; i >= 1; i-- ) {
for( cada valor v del tipo ti )
(2)
(3)
INICIA( Bi[v] );
for( cada elemento r en la lista A )
Colocar r al final de la cubeta Bi[v], donde v
es el valor para el campo fi de la llave de r.
for( cada valor v del tipo ti, de menor a mayor)
Concatenar Bi[v] al final de A.
(4)
(5)
(6)
(7)
}
}
O( s
+ n)
i =1
Anlisis y Diseo de Algoritmos
i =1
i =1
O( kn + si ) O( n + si )
Sorting-47
Arboles de Decisin
F Un rbol de decisin para un mtodo de ordenamiento
es un rbol binario en el cual sus nodos representan el
estado del mtodo despus de hacer algn nmero de
comparaciones.
F El estado de un programa de ordenamiento es
esencialmente el conocimiento acerca de los
ordenamientos iniciales que se han obtenido por el
programa hasta ese momento.
Sorting-48
24
Arboles de Decisin
bca, cba
bac
cba
acb, cab
abc
10
cab
11
acb
Sorting-49
Arboles de Decisin
Fsi se ordena una lista de elementos de tamao n, a1, a2, ..., an existen
n(n-1) (n-2) (2) (1) posibles ordenamientos correctos.
n! =
FLa longitud del camino ms largo de la raz a una hoja es una cota inferior
en el nmero de pasos ejecutados por el algoritmo en el peor caso.
FYa que un rbol binario con k hojas debe tener un camino de longitud al
menos log k, entonces, un algoritmo de ordenamiento que utiliza slo
comparaciones para ordenar una lista de n elementos debe tomar en el peor
n
caso un tiempo ( log n! ).
n n
n n 2
n!= n ( n 1) ... (2) (1) ... =
2 2
2 2
n/2 veces
n
n n
n
log( n!) log = log n
2
2 2
2
Anlisis y Diseo de Algoritmos
Sorting-50
25
Arboles de Decisin
FEl ordenamiento por comparaciones requiere un tiempo ( n logn ) en el
peor caso
FEjercicio: Uno puede preguntarse si existe un algoritmo de ordenamiento
que utilice nicamente comparaciones y que toma un tiempo ( n logn ) en
el peor caso, pero en el caso promedio toma un tiempo O(n) o algo menor a
O(n log n).
FExiste tal algoritmo?
Sorting-51
26