Tema 3 - Algoritmos de Ordenación

ALGORITMICA
PARTE II: Algoritmos existentes
Eugenio Fco. Sánchez Úbeda

Cristina Puente Águeda
Universidad Pontificia Comillas
Algoritmos de ordenación
-1
Ordenación
• Operación básica, se utiliza en casi todos los programas

complejos
• Existen muchos algoritmos
ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

2
Algoritmos de ordenación
• Entrada: conjunto de objetos a ordenar

Entradas Algoritmo Sal
• Salida: secuencia ordenada de objetos
• Objetivo de la ordenación:
– Facilitar la búsqueda de elementos en el conjunto ya
ordenado
• Existen multitud de algoritmos para realizar lo mismo, cada

uno con ciertas ventajas e inconvenientes
• Principal restricción: Espacio necesario en memoria RAM.

– Si los datos caben: ordenación interna
– Si no caben: ordenación externa

3
Clasificación de los algoritmos de ordenación
• Ordenación interna: Arrays en memoria RAM
• Ordenación externa: Ficheros secuenciales (discos, cintas)
Ordenación Ordenación
interna externa
Todas las tarjetas están visibles Sólo visibles las tarjetas superiores
D ato s a ord enarAuxiliar A lmacen ami ent o p ri mario D ato s a ord enar
I/O
RAM RAM
A lmacen ami ent o
secu nd ari o
(externo )
CPU CPU
Algoritmo Algoritmo
Ordenación Interna Ordenación Externa
4
Algoritmos de ordenación externa (I)
• La información a ordenar no cabe toda al mismo tiempo en

memoria RAM
– La estrategia a utilizar es muy diferente
RAM
Fichero de
datos a ordenar
• Dos diferencias importantes con la ordenación interna:
– El coste de acceso a un elemento es ahora varios ordenes de
magnitud superior que cualquier cálculo en CPU
– Restricción severa de acceso a los elementos, dependiente del tipo
de almacenamiento secundario utilizado.
• Limitar los movimientos entre el almacenamiento externo y
la memoria principal
5
Algoritmos de ordenación externa (II)
• Idea:
– Trabajar con varios dispositivos adicionales (discos, cintas) para
guardar operaciones intermedias
• Fases:
– Generación de tramos (división+distribución)
• Trocear el fichero inicial en bloques de datos ordenados (tramos)
• Guardar los tramos en dispositivo externo auxiliar
– Mezcla de tramos
• Fundir los tramos en sucesivas pasadas hasta tener un único tramo
Datos a ordenar Cintas disponibles
Cinta 1
División Cinta 2
+ Mezcla
Distribución Cinta 3
Bloque ordenado o "Tramo"

6
Algoritmos de ordenación interna
• Métodos directos (simples) Ordenación “in situ”: se

– Basados en inserción ordena sin utilizar otro
• Inserción directa, binaria array del mismo tamaño
– Basados en selección
• Selección directa
– Basados en intercambio
• Intercambio directo (burbuja y sacudida)
• Métodos sofisticados
– Basados en inserción
• Algoritmo de Shell
– Basados en selección
• ´Montículo (Heapsort)
– Basados en intercambio
• Rápido (Quicksort)

7
Algoritmos simples vs. sofisticados
• ¿Por qué tiene interés un

algoritmo simple si los hay
mejores (los sofisticados)?
• Para invertir una matriz

puede compensar utilizar el
ordenador pero para sumar
26+14 quizá es demasiada
molestia encenderlo
8
Tipos de algoritmos según su comportamiento
• Natural/antinatural
– Cuando tarda lo mínimo posible si ya está ordenado y lo máximo
cuando está en orden inverso
• Estable/intestable
– Cuando el orden relativo de los elementos con la misma clave de
ordenación no se altera Campo clave
Campo 1 1 3 4 3 5 4 3
Campo 2 20 10 10 20 30 40 10 utilizado en la
ordenación
Ordenación Campo 1 1 3 3 3 4 4 5
estable Campo 2 20 10 20 10 10 40 30
Campo 1 1 3 3 3 4 4 5 Ordenación
Campo 2 20 10 10 20 10 40 30 inestable
• Simétrico/asimétrico
– Cuando cuesta lo mismo ordenar 2341 que 5123
• Correcto/incorrecto
– Cuando siempre encuentra la solución correcta
– Es "lo típico"
9
Algoritmos de ordenación interna: estructuras
• Lo normal es utilizar una array de registros

1 N
A:
A(k) ó A[k]
R.N omb re N omb re

R.A pel li d os A pel li do s Registro R
R.Ed ad Ed ad con 4 campos
R.D NI D NI
Lo normal es ordenar por uno de los campos, el

denominado campo “clave”: A(k).clave
10
Inserción directa (I)
• Idea
• Utilizando un vector de registros y ordenando sobre el

mismo (utilizando espacio auxiliar para un registro):
5 2 196 8
Espacio disponible en
memoria

11
Inserción directa (II)
• Ejemplo
A={ 5 2 1 9 6 8 } i=2
Selecciona
carta 25 1 96 8 i=3,
carta=1
ordenado por ordenar
j =2 i=3
Busca 25 5 96 8 i=3,j=2
posición
22 5 96 8 i=3,j=1
Inserta
carta 12 5 96 8
ordenado por ordenar
12
Inserción directa (III)
A = InserciónDirecta(A, N) %A vector de registros a ordenar, N: nº de registros
1 For i=2 to N
carta = A[i]; % selecciona última carta
j=i-1; %busca punto de inserción
2 While (j>0 & carta < A[j]) % alternando comparaciones
A[j+1]=A[j]; % y movimientos
j=j-1;
end 2
A[j+1]=carta; % inserta la carta
end 1
Inserción directa
Seleccionar el
siguiente Búsqueda
Secuencia origen Secuencia de stino

13
Inserción directa (IV)
• Uso de un centinela
– Evita salirse del array simplificando la condición
– Se añade el centinela en el extremo del array para detectar que se
llega al final del mismo
• Nota: Será necesario dimensionar A para tener N+1 elementos
A = InserciónDirectaCentinela(A, N)
1 For i=2 to N
carta = A[i]; % selecciona última carta
j=i-1;
A[0]=carta;
2 While (carta < A[j]) % comparación más sencilla
A[j+1]=A[j];
j=j-1;
end 2
A[j+1]=carta; % inserta la carta
end 1
14
Inserción binaria
• En inserción directa A(1:i-1) ya ordenado
– Mejora en la búsqueda del punto de inserción (mediante bisección)
IANSERCIÓN _BINARIA
= InserciónBinaria (A,(A)
N) iz m de
1 For i=2 to N
carta = A[i]; iz=1; de = i-1; 1 2 5 67 8 9
2 While iz  de
m = floor[(iz+de)/2]; Zona ya ordenada
If (carta < A[m]) then de = m-1;

else iz = m+1; iz i-1
end 2
3 For j=i-1 to iz step -1 %mueve items
(hace hueco
A[j+1]=A[j]; para carta)
end 3
A[iz]=carta;
end 1
15
Selección directa (I)
• Idea
Inserción directa
Seleccionar el
siguiente Búsqueda

Selección d irecta
Búsqueda Insertar en el
siguiente

16
Selección directa (II)
A = SelecciónDirecta(A, N) % A vector de registros a ordenar, N: nº de registros
1 For i=1 to N-1 % separación secuencia origen/destino
k=i;
x = A[i]; % inicializa búsqueda mínimo en origen
2 For j=i+1 to N
3 if (A[j]<x) then % busca mínimo en origen
k=j;
x=A[j];
end 3
end 2
A[k]=A[i]; % intercambio, inserta al final
A[i]=x; % de la secuencia destino
end 1
i =1 i i =N -1
j =i +1 j j =N
k Selección
A={ } +
Intercambio
d esti no S ecuen ci a o rig en
(ya ordenado) (por ordenar)
17
Selección directa (III)
• Ejemplo:
p or orden ar
A={ 5 2 1 9 6 8 } i =1
min item 5 2 1 9 6 8
Selecciona
i =1 ,
i =1 k =3 k =3 ,x=1
Intercambia 1 2 5 9 6 8
o rd enad o p or orden ar

18
Mezcla directa (I)
• Utiliza divide y vencerás:

– Divide el array en dos partes más pequeñas
– Se ordenan recursivamente. Si son suficientemente pequeñas se
resuelve directamente
– Se combinan esas soluciones para ordenar finalmente el array
1 2 4 8
Ya
3 5 6 7 ordenadas

19
Mezcla directa (II)
A = MezclaDirecta (A, iz, de)
1 If (iz < de) then % sale si sólo un item

me = floor ( (iz+de)/2 ); % valor entero por debajo de iz
A = MezclaDirecta (A, iz, me); % lado izquierdo

A = MezclaDirecta (A, me+1, de); % lado derecho
A = Mezclar (A, iz, me, de); % Combina dos secuencias ordenadas

end 1
Fin
A = Mezclar (A, iz, me, de) iz me

1 2 4 8
Ya
3 5 6 7 ordenadas
de
Fin
20
Mezcla directa (III)
• Ejemplo

21
Intercambio directo
• Característica dominante: :
– Intercambio entre pares de elementos
– Mezcla de inserción y selección directa
• IDEA:
– Hacer repetidas pasadas sobre el array ordenando parejas de
elementos contiguos
Intercambio
- +

22
Intercambio directo: burbuja (I)
i =2 i i =N
j =i j j =N
A={ - + }
d esti no S ecuen cia or ig en
(ya ordenado) (por ordenar)
A = IntercambioBurbuja (A, N)
1 For i=2 to N % separación secuencia origen/destino

2 For j=N to i step -1 % mueve de dcha a izq
3 if (A[j-1] > A[j]) then
x = A[j-1];
A[j-1] = A[j]; % intercambio
A[j] = x;
end 3
end 2
end 1
Fin
23
Intercambio directo: burbuja (II)
i -1
• Ejemplo p or orden ar
A={ 5 2 1 9 6 8 } i =2
mueve 6 y 1 1 5 2 6 9 8 i =2 ,
j =6 :-1: 2
i =3 ,
mueve 8 y 2 1 2 5 6 8 9 j =6 :-1: 3
o rd enad o
• Se hacen pasadas inútiles
– controlar lo que realmente está ordenado
• Asimetría antinatural
– Alternar el sentido de las pasadas
1 pasada 3 pasadas
256 1 6 12 5
24
Intercambio directo: sacudida (I)
iz i z' d e Alternancia iz de
j j
A={ - + k - +} A={ - + - +}
d esti no S ecuen cia o rig en d esti no d esti no o rig en d esti no
(ya ordenado) (por ordenar) (ya ordenado) (ya ordenado) [iz ... d e](ya ordenado)
A = IntercambioSacudida (A, N)
iz=2; de=N; k=N; % inicializa origen [iz ... de]
1 Repeat
2 For j=de to iz step -1 % movimiento derecha-izquierda
if (A[j-1]>A[j]) then
x=A[j-1]; A[j-1]=A[j]; A[j]=x; k=j;
end 2
iz = k+1; % mueve extremo izq de origen
4 For j=iz to de % movimiento izquierda-derecha
if (A[j-1]>A[j]) then
x=A[j-1]; A[j-1]=A[j]; A[j]=x; k=j;
end 4
de = k-1; % mueve extremo dcha de origen
1 until (iz>de)
Fin
25
Intercambio directo: sacudida (II)
• Ejemplo p or orden ar
A={ 5 2 1 9 6 8 } i z=2 de=6
k =6
mueve 6 y 1 1 5 2 6 9 8 k =2
i z=3 de=6
mueve 5 y 9 1 2 5 6 8 9 k =6
i z=3 de=5
k =6
stop 1 2 5 6 8 9 i z=7 de=5
• Las mejoras sólo afectan al número de comparaciones
La ordenación por intercambio es inferior a la

ordenación por selección o por inserción

26
Incrementos decrecientes –Shell- (I)
• Mejora real de Inserción Directa

– Inserción funciona mal con muchos datos
– Inserción trabaja mejor cuando los datos están bastante ordenados
• Concepción curiosa del paradigma “Divide y vencerás”:
– Utilizar Inserción Directa como elemento básico para solucionar
subproblemas
– Llamar a Inserción directa con pocos datos y bastante ordenados
• Agrupar los elementos de p en p y ordenarlos por separado
5 2 8 4 en 4
2 5 8 2 en 2
1 en 1
No se conoce la secuencia de incrementos

mejor, una razonable acabaría así: ...,31,15,7,3,1
27
Incrementos decrecientes –Shell- (II)
• IDEA básica agrupar de 3 en 3

4 2 7 3
4 2 7 3
Inserción
directa
2 3 4 7
• Además las ordenaciones de los distintos grupos para un mismo

incremento se realizan "en paralelo“
28
Incrementos decrecientes –Shell- (III)
A = IncrementosDecrecientes (A, N, INC, N_INC)
1 For m=1 to N_INC

p = INC[m]; % fija incremento, agrupa de "p en p"
2 For i=p+1 to N % empieza en el "segundo" elemento
carta = A[i];
j=i-p; % el elemento anterior de ese grupo
3 While (j>0 & carta < A[j])
A[j+p]=A[j];
A = InserciónDirecta(A, N)
j=j-p; 1 For i=2 to N
end 3 carta = A[i];
A[j+p]=carta; j=i-1;
end 2 2 While (j>0 & carta < A[j])
end 1 A[j+1]=A[j];
j=j-1;
Fin end 2
A[j+1]=carta;
end 1
• Ejemplo de secuencia de incrementos típica (tiene que terminar en 1):

• INC = (9, 5, 3, 1); N_INC = 4;
29
Incrementos decrecientes –Shell- (IV)
• Ejemplo p=4
de 4 en 4 53 1 9 24 78
4 grupos
23 1 85 4 7 9
2 3 1 8 5 4 7 9 i=3
grupo 1
p=2 1 3 2 8 5 4 7 9 i=4
grupo 2
2 grupos 1 3 2 8 5 4 7 9
de 2 en 2 i=5
grupo 1
1 3 2 8 5 4 7 9 i=6
grupo 2
1 3 2 4 5 8 7 9 i=7
grupo 1
1 3 2 45 87 9
de 1 en 1 1 3 2 4 5 8 7 9
p=1
1 grupo
ordenado
30
Heapsort
• Mejora REAL de selección directa:

Selección Insertar en el siguiente
directa Selección en
C=N-1
N items
Secuencia origen Secuencia destino
Siguiente Insertar en el siguiente
iter Selección en
C=N-2
N-1 items
Secuencia origen Secuencia destino
• TRUCO:
– guardar en cada iteración más información que el elemento mínimo
-> Estructura "montículo"
31
Heapsort: estructura montículo (I)
• Montículo:
– Secuencia estructurada ("ordenada") de items en árbol
• Representación + Propiedad (ejemplo):

1
como árbol
binario 25 como array
2 3
4
18 5 6
20 7 1 2 3 4 5 6 7 8 9 10
16 14 19 11 25 18 20 16 14 19 11 12 15 13
8 9 10
12 15 13
Propiedad: Propiedad:
A[Padre (i)] A[i] i1 A[2i]  A[i] A[2i1] i iz....de /2
32
Heapsort: estructura montículo (II)
• A[1] tiene el elemento de mayor clave

• Funciones elementales (ojo si se programa en C):
1 Usando A[0] A[N  1]:
25 3 Padre (i) floor( i / 2) Hijo_ izq(i)  2i  1
20 Hijo _ izq (i)  2 i Hijo_ dcha(i)  2i  2
6 7
Hijo _ decha (i)  2 i 1
19 11
• Final del montículo
1
como árbol
–
binario
Tam_Monti: índice como
del 25
array
último elemento del montículo
2 Tam_Monti3 ≤N
4
18 Ejemplo:
5 6
20 7 1 2 3 4 5 6 7 8 9 10
16 14 19 11 25 18 20 16 14 19 11 12 15 13
8 9 10
12 15– Altura
13de un nodo: número de nodos en el camino hasta la hoja
Propiedad:
más alejada del subárbol con raíz enPropiedad:
ese nodo
A[Padre (i)] A[i] i1 A[2i]  A[i] A[2i1] i iz....de /2 33
Heapsort: Mantener la propiedad (I)
• El poder mantener la propiedad de un montículo en el que

únicamente se modifica el nodo raíz es una pieza clave en
el algoritmo
• IDEA: considerar tres nodos cada vez
i
Intercambia
-
iz de
Continua
comprobando +
propiedad
• Suposición
– Subárboles hijos 'iz' y 'de' tienen que ser ya montículos
• Versión recursiva o iterativa
34
Heapsort: Mantener la propiedad (II)
A = Monticuliza (A, Tam_Mont, i) % hunde o criba el elemento i
iz=Hijo_izq(i); de = Hijo_dch(i); % hijos tienen que ser ya montículos
1 if (iz ≤ Tam_Mont & A[iz] > A[i]) then% mayor = índice

mayor = iz; % nodo mayor clave
else 1 % entre i, iz y de
mayor = i; % controla salirse con Tam_Mont
end 1
2 if (de ≤ Tam_Mont & A[de] > A[mayor]) then
mayor = de;
end 2
3 if (mayor ≠ i) then % Padre i viola propiedad

x = A[i]; A[i] =A[mayor]; A[mayor] = x; % intercambiar A[i] con A[mayor]
A = Monticuliza (A, Tam_Mont, mayor);
end 3
Fin

35
Heapsort: Monticuliza (ejemplo)
1 1
(a) 25 (b) 25
i 2 3 2 3
4
15 5
20 7 6 4
18 5
20 76
i
18 14 19 11 15 14 19 11
8 9 10 8 9 10
12 16 13 12 16 13
1
(c) 25
2 3
18 20
4 5 6 7
16 14 19 11
8 9 10
12 15 13
36
Heapsort: construye montículo inicial
A = ConstruyeMonticuloInicial (A, N) % Crea el montículo inicial
Tam_Mont = N; % crea un montículo que ocupa todo el array

1 For i= floor(N/2) to 1, step –1 % la mitad dcha de A ya OK
A = Monticuliza (A, Tam_Mont, i);
end 1
Fin
• Se construye de abajo a arriba (árbol)

o de derecha a izquierda (array),
garantizándose que los subárboles de
los hijos son ya montículos

37
Heapsort: algoritmo de ordenación (I)
• Idea: La zona desordenada disminuye

sacando el elemento mayor. El
elemento mayor se encuentra
montando un montículo que permitirá La zona ordenada crecerá hacia
volver a encontrar rápidamente en la la izquierda añadiendo el
siguiente iteración el nuevo mayor elemento mayor de la zona
desordenada
Zona Zona
DESORDENADA ORDENADA
38
Heapsort: algoritmo de ordenación (II)
A = Heapsort (A, N) % Algoritmo de ordenación basado en el montículo
A = ConstruyeMonticuloInicial (A, N); % inicialmente todo desordenado

Tam_Mont = N;
1 For i= N to 2, step –1 % los elementos mayores se criban a la izquierda
x = A[1]; A[1] =A[i]; A[i] = x; % Intercambia A[1] con A[i]
Tam_Mont = Tam_Mont - 1;
A = Monticuliza (A, Tam_Mont, 1); % cribar desde la raíz
end 1
Fin
Tam_Mont

39
Heapsort: algoritmo de ordenación (II)
https://www.youtube.com/watch?v=EreoMaOBTzE

40
Heapsort: algoritmo de ordenación (ejemplo)
Datos iniciales
CONSTRUYE_MONTICULO: 1 1 1 1
(a) (b) (c)
YE_MONTICULO: 1 25 (a)
1
20 (b) 2 19 1 18 1
2 (c)
25
2
18
3
18
20 3
193
2
18 2
19
3
15 16
3
18
2 3 20 2 3 215 3
4 5 6 7 4 5 6 7 4 5 6 7 4 5 6 7
1816 5 14 6
20197 11 416 18 14 5
136 1911 7 16 4 18 14 135 11 6 15 127 4
14 1613 11 5 6
15
7
8 9 10 8 9 i 8 i i
6 12 15141319 11 12 16 15 2514 13 1112 20 16 25 14 131911 20 25 12 14 13 11
9 10 8 9 i 1 8 i 1 i 1
15 13 12 15 (d) 2516 12
(e) 20 1525 (f) 19 20 14 25
2 3 2 3 2 3
14 1 14 1 12 1
516 6
15 i 13
i 15
13
(d)4 4 (e) 5 4 (f) i 14
12 2 11 13 18 3 12 11
2 16 18 311 15 16
2 18 3
19
14 14
15 i 19 204 25 13 12 i 13
4 20 25 5 65 i 19 20 25 4
12 (g) 111
13 18 (h)12 1
11 16 18 11 1 15 16 18
13 12 (i) 11
2 3 2 i i
19 20
i
1225 11 19 11
20 25 13 19 20 13
12 25
14 151 16 18 14 15 16 118 14 15 16 18 1
(g) 13 (h) 12 (i) 11
19 20 2 25 3 19 20 252 i
19 20 25 i
ya ordenado
i
12 11 11 13 12 13
14 15 16 18 14 15 16 18 14 15 16 18
19 20 25 19 20 25 19 20 25 ya ordenado
41
Quicksort (Ordenación rápida)
• Mejora de Intercambio directo

– Se basa en hacer muchos intercambios de
elementos consecutivos
Intercambio directo
Intercambio Inventor:
A. Hoare, en 1962
- +
Método rápido
- +
– Quicksort: intercambios sobre distancias LARGAS

42
Quicksort
• Idea:
– Desacoplar la solución en dos problemas independientes,
solucionables por separado (paradigma divide y vencerás)
Solucionar
Ojo, no hay proceso de mezcla
para unir las soluciones (como en
Mezcla Directa)
dividir
Solucionar Solucionar
N pequeño
dividir
Solución
Solucionar Solucionar
– Punto clave: Cómo dividir rápidamente

43
Quicksort: Criterio de división
• El array A[iz ... de] se divide (reordena) en dos más pequeños A[iz ... d]
y A[d+1 ... de], en donde se cumple que:
– Cada elemento de A[iz ... d] es MENOR o IGUAL que cada elemento de
A[d+1 ... de]
iz d de
iz d d+1 de

Ejemplo:
d
1 3 1 42 9 58
El índice d se determina durante el
proceso de división a partir de un
valor umbral o "pivote"
44
Quicksort: Divide
[A, j] = Divide (A, iz, de) % devuelve el array reorganizado y la posición de corte d
[A, umbral] = SeleccionaUmbral (A, iz, de); % Además pone el pivote en A[iz]
i = iz ; j = de; % inicializa contadores
CONTINUAR = 1;
1 while (CONTINUAR = 1)
while (A[i] < umbral) i = i+1; end; % avanza a la derecha
while (umbral < A[j]) j = j- 1; end; % avanza a la izquierda
2 if (i<j) then
intercambiar A[i] con A[j];
i=i+1; j=j-1; % para salir while 1
else
CONTINUAR = 0; % j tiene la posición de corte
end 2
A[j]> umbral
end 1
iz
j
Fin
NOTA: Para que funcione el de

pivote tiene que estar en A[iz] i
A[i]< umbral
45
Quicksort: Ejemplo división
umbral= 5
[A, j] = Divide (A, iz, de) i j
[A, umbral] = SeleccionaUmbral (A, iz, de)

i = iz ; j = de;
5 3 1 92 4 18
i j
CONTINUAR = 1;
1 while (CONTINUAR = 1)
1 3 1 92 4 58
while (A[i] < umbral) i = i+1; end; i j
1 3 1 92 4 58
while (umbral < A[j]) j = j- 1; end;
2 if (i<j) then
intercambiar A[i] con A[j];
i=i+1; j=j-1; ij
1 3 1 42 9 58
else
CONTINUAR = 0;
end 2
end 1 j i
Fin
1 3 1 42 9 58 STOP
d
46
Quicksort: Algoritmo de ordenación
iz=1 d de=N
A={ }
1 d d+1 N
A = Quicksort (A, iz, de) % iz y de indican la zona del array A a ordenar
1 if (iz < de) then % ya está resuelto si sólo hay un elemento

[A, d] = Divide (A, iz, de); % divide y reordena (modifica A)
A = Quicksort (A, iz, d); % repite recursivamente lado izquierdo
A = Quicksort (A, d+1, de); % repite recursivamente lado derecho
end 1
Fin

47
Quicksort: Selección del umbral (I)
• Lo más sencillo:
– Hay un caso claramente malo ¿cuál es?
[A, u] = SeleccionaUmbral (A, iz, de) % iz y de indican la zona a considerar
u = A[iz]; % simplemente coge la clave del primer elemento (iz) como umbral
% también se podría coger el del final (es la misma idea)
Fin
• Lo deseable, pero demasiado “costoso”:

– Utilizar la mediana para asegurar una división balanceada
[A, u] = SeleccionaUmbral (A, iz, de) % iz y de indican la zona a considerar
m = CalculaMediana (A, iz, de); % A[m] = la mediana de A[iz ... de]

intercambiar A[iz] con A[m];
u = A[iz]; % asegura que el umbral está en iz
Fin

48
Counting sort: Planteamiento
• Suposición:
– Todas las claves son enteros en el rango 1-k, para algún
entero k
• Idea:
– determinar para cada elementos cuántos tienen menor clave que él y,
– utilizar dicho valor para determinar la posición en el array ordenado
1 N
A={ }
1 N
Hay 7 items con A[]<A[3]
Insertar en B[8]
B={ }
– Con cuidado para no poner varios elementos en la mismo sitio ...

49
Counting sort: Algoritmo
1 N=8
A={ 2 }
1 2 k=4
C={ 4 } N=8
B={ 2 }
B = CountingSort (A, B, N, k) % el resultado en B, tiene que tener tamaño N
Crear array e inicializar C[1...k]=Ø; % array auxiliar de tamaño k
1 For j=1 to N % C[i] contiene número items iguales a i
C[ A[j] ] = C[ A[j] ] +1 ;
end 1
2 For i=2 to k % C[i] contiene número items ≤ que i
C[i] = C[i] +C[i-1] ;
end 2
3 For j= N to 1, step -1
B[ C[A[j]] ]= A[j];
C[A[j]] = C[A[j]] -1; % ojo claves repetidas
end 3
Fin
50
Counting sort: Ejemplo
1 N=8
A={ 3 6 4 1 3 4 1 4 }
For 1:
1 2 3 4 5 k=6
B = CountingSort (A, B, N, k)
Crear array e inicializar C[1...k]=Ø; C={ 2 0 2 3 0 1 }
1 For j=1 to N
C[ A[j] ] = C[ A[j] ] +1 ; 1 2 3 4 5 k=6
end 1
2 For i=2 to k
For 2: C={ 2 2 4 7 7 8 }
C[i] = C[i] +C[i-1] ;
end 2 1 N=8
3 For j= N to 1, step -1
B[ C[A[j]] ]= A[j]; A={ 3 6 4 1 3 4 1 4 }
C[A[j]] = C[A[j]] -1; For 3:
end 3 1 2 3 4 5 k=6
Fin C={ 2 2 4 7 7 8 }
1 7 N=8
B={ 4 }
51
Radix sort
• Creado en los años 30 para ordenar las tarjetas perforadas

utilizadas en los ordenadores, ya sólo en museos
(programado mecánicamente)
• Util para ordenar información por múltiples campos:
– Fechas (año/mes/día) Personas (apellidos)
• Ordenar N items en donde la clave es

– clave_a_utilizar = digito1, digito2, digito3, ..., digitod
– - significativo a +significativo
• Formas de hacerlo:
– Utilizar un algoritmo en donde las comparaciones son
jerárquicas
– Ordenar la información d veces con un algoritmo estable, cada
vez en un dígito diferente
52
Radix sort: Algoritmo
• Idea básica:
– Ordenar primero por el dígito menos significativo
A = RadixSort (A, N, d)
1 For c=1 to d % se hacen d ordenaciones, una para cada ´”dígito”
A = AlgoritmoOrdEstable(A, N) utilizando clave ordenación c;
end 1
Fin
• Es importante identificar quién tiene

32 9 72 0 72 0 32 9
que ser el dígito menos significativo ... 45 7 35 5 32 9 35 5
65 7 43 6 43 6 43 6
• Si los dígitos son valores enteros en el 83 9 45 7 83 9 45 7
rango 1-k, y k no es muy grande 43 6 65 7 35 5 65 7
• AlgoritmoOrdEstable = CountingSort 72 0 32 9 45 7 72 0
35 5 83 9 65 7 83 9
53
Radix sort: Ejemplo mala utilización
d m a
Ordenar por fechas los siguientes elementos utilizando como
clave de ordenación
clave_a_utilizar = dd, mm, aaaa
(primero ordenamos por año, luego por mes,
y finalmente por día)
¿? Así no está
ordenado por
fechas (aunque el
algoritmo sea
estable)
54
Radix sort: Ejemplo bueno
a m d
Ordenar por fechas los siguientes elementos utilizando como
clave de ordenación
clave_a_utilizar = aaaa, mm, dd
(primero ordenamos por día, luego por mes,
y finalmente por año)
Así SÍ está
ordenado por
fechas

55
Bucket sort (I)
• Suposición:
– Las claves que aparecen en el array a ordenar, son valores
entre [0,1) y están "bastante bien repartidas“
Histograma Array a ordenar

1)
...
[0

56
Bucket sort (II)
• Cuantos más datos a ordenar tengamos, más eviente será

dicha suposición:
10 datos
300 datos
IDEAL: Las claves son
generadas por proceso
“aleatorio” que distribuye las
claves uniformemente en [0,1)

57
Bucket sort: Algoritmo (I)
• Supuesto que los valores de las claves están bien

repartidos:
• Se puede dividir el intervalo [0,1) en N subintervalos de
igual tamaño, llamados "buckets“ o “recipientes”
• Distribuir los N elementos en los recipientes
• No se sabe cuantos elementos irán a cada recipiente, pero no
serán muchos...
• Ordenar los elementos de cada recipiente utilizando
Inserción Directa (será un número pequeño)
• Juntar todos los elementos de los recipientes

58
Bucket sort: Algoritmo (II)
• Ejemplo (array con 10 elementos):

– A = [0.995 0.075 0.873 0.757 0.901 0.915 0.515 0.055 0.262 0.386];
Recipientes
1.0
0.9
0.8
0.7
0.6
0.5
0.4
0.3
0.2
0.1
0.0

59
Bucket sort: Algoritmo (III)
• El conjunto de recipientes se modela como un vector de

listas enlazadas
– B[0...N-1]: array auxiliar de listas enlazadas
B = BucketSort (A, N, k) % 0≤A[i]<1 , i=1:N

Crear array aux B[0...N-1]; % crea array auxiliar
1 For i=1 to N % guarda en los recipientes
insertar A[i] en lista B[floor(N*A[i])];
end 1
2 For i=0 to N-1 % ordena cada recipiente
Ordenar lista B[i] con InsercionDirecta;
end 2
Concatenar listas B[0], B[1], ... , B[N-1] ;
Fin

60
Bucket sort: Algoritmo (IV)
• Para ordenar el array:

– A = [0.995 0.075 0.873 0.757 0.901 0.915 0.515 0.055 0.262 0.386];
A B
0.995 0 0.075 0.055
0.075 1
0.873 2 0.262
0.757 3 0.386
0.901 4
0.915 5 0.515
0.515 6
0.055 7 0.757
0.262 8 0.873
0.386 9 0.995 0.901 0.915
61
Comparativa tiempos de ejecución

62

Tema 3 - Algoritmos de Ordenación

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

Tema 3 - Algoritmos de Ordenación

Cargado por

Copyright:

Formatos disponibles

ALGORITMICA

PARTE II: Algoritmos existentes

Eugenio Fco. Sánchez Úbeda

• Operación básica, se utiliza en casi todos los programas

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

• Entrada: conjunto de objetos a ordenar

• Existen multitud de algoritmos para realizar lo mismo, cada

• Principal restricción: Espacio necesario en memoria RAM.

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

• La información a ordenar no cabe toda al mismo tiempo en

Bloque ordenado o "Tramo"

• Métodos directos (simples) Ordenación “in situ”: se

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

• ¿Por qué tiene interés un

• Para invertir una matriz

• Lo normal es utilizar una array de registros

R.N omb re N omb re

Lo normal es ordenar por uno de los campos, el

• Utilizando un vector de registros y ordenando sobre el

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

Secuencia origen Secuencia de stino

If (carta < A[m]) then de = m-1;

Secuencia origen Secuencia de stino

Secuencia origen Secuencia de stino

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

• Utiliza divide y vencerás:

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

1 If (iz < de) then % sale si sólo un item

A = MezclaDirecta (A, iz, me); % lado izquierdo

A = Mezclar (A, iz, me, de); % Combina dos secuencias ordenadas

A = Mezclar (A, iz, me, de) iz me

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

1 For i=2 to N % separación secuencia origen/destino

• Las mejoras sólo afectan al número de comparaciones

La ordenación por intercambio es inferior a la

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

• Mejora real de Inserción Directa

No se conoce la secuencia de incrementos

• IDEA básica agrupar de 3 en 3

• Además las ordenaciones de los distintos grupos para un mismo

1 For m=1 to N_INC

• Ejemplo de secuencia de incrementos típica (tiene que terminar en 1):

• Mejora REAL de selección directa:

• Representación + Propiedad (ejemplo):

• A[1] tiene el elemento de mayor clave

• El poder mantener la propiedad de un montículo en el que

A = Monticuliza (A, Tam_Mont, i) % hunde o criba el elemento i

iz=Hijo_izq(i); de = Hijo_dch(i); % hijos tienen que ser ya montículos

1 if (iz ≤ Tam_Mont & A[iz] > A[i]) then% mayor = índice

3 if (mayor ≠ i) then % Padre i viola propiedad

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

Tam_Mont = N; % crea un montículo que ocupa todo el array

• Se construye de abajo a arriba (árbol)

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

• Idea: La zona desordenada disminuye

A = ConstruyeMonticuloInicial (A, N); % inicialmente todo desordenado

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

• Mejora de Intercambio directo

– Quicksort: intercambios sobre distancias LARGAS

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

– Punto clave: Cómo dividir rápidamente