Transcript Unidad 6 Métodos de ordenamiento

Ingeniería en Sistemas Computacionales
Estructura de Datos
Unidad 6
Métodos de Ordenamiento
Internos
6. Ordenación interna
6.1. Algoritmos de ordenamiento por
intercambio
6.1.1. Burbuja
6.1.2. Quicksort
6.1.3. Shellsort
6.2. Algoritmos de ordenamiento por
distribución
6.2.1. Radix
Inserción directa
• Este método consiste en buscar el lugar
adecuado para cada registro recorriendo los
registros anteriores para dejar un lugar vacío
para el nuevo elemento. El proceso de acomodo
de cada elemento se repite hasta llegar al último
elemento, los elementos previos al elemento a
acomodar se encuentran en orden.
• Este es el método usado por los jugadores de
cartas para acomodar su juego.
Ordenamiento por inserción directa
Variables
–
–
–
–
K arreglo de datos a ordenar
V variable auxiliar
i, j índices para el arreglo
N número de elementos
InserciónDirecta
Inicio
Para i=2 hasta N incremento 1
v = K(i) //elemento a acomodar
j=i
Mientras (j > 1) y (K(j-1) > v)
K(j) = K(j-1) //mueve elementos
j = j-1
K(j) = v // inserta el elemento actual
Fin
K
1
2
3
4
5
6
3
8
2
1
4
2
3
8
2
3
8
1
2
3
8
1
2
3
4
8
1
2
2
3
4
8
Burbuja (Bubble)
• Este método realiza comparaciones de
todas las posibles parejas de llaves
intercambiando aquellas que se encuentran
fuera de orden.
• Utiliza un proceso repetitivo comparando
las parejas de datos adyacentes del inicio
al final del arreglo donde, después de la
primer pasada la llave mayor queda en la
última posición del arreglo.
Burbuja (Bubble)
Variables
•
n es el total de elementos
•
K arreglo de llaves
•
t variable auxiliar para el intercambio
•
i,j variables para los indices
K
0
1
2
3
4
5
3
8
2
1
4
2
3
8
2
1
4
2
3
2
8
1
4
2
3
2
1
8
4
2
3
2
1
4
8
2
3
2
1
4
2
8
Primera
pasada
Burbuja
Inicio
para i= n-1 ; i>0 ; i-para j=0; i>j; j++
si (k[j] > k[j+1])
t = k[j];
k[j]= k[j+1];
k[j+1] = t;
Fin
Segunda
pasada
Cuarta
pasada
3
2
1
4
2
8
2
3
1
4
2
8
2
1
3
4
2
8
2
1
3
4
2
8
2
1
3
2
4
8
1
2
2
3
4
8
1
1
2
2
2
2
3
3
4
4
Tercer
pasada
Quinta
pasada
2
1
3
2
4
8
1
2
3
2
4
8
1
2
3
2
4
8
1
2
2
3
4
8
1
2
2
3
4
8
1
2
2
3
4
8
8
8
Shell sort
• El método shell divide el arreglo a ordenar en
varios grupos haciendo comparaciones e
intercambios entre ellos. El tamaño de los
subgrupos se decrementa y el número de
subgrupos se incrementa hasta llegar a tener n
grupos de tamaño 1. A partir de este punto, el
método funciona como el de inserción directa.
• El tamaño de los subgrupos así como el total de
estos puede determinarlos el usuario para
hacer mas eficiente el algoritmo.
Shell sort
Variables
–
–
–
–
–
–
K arreglo de datos a ordenar
H tamaño del grupo
i, j índices para el arreglo
V variable auxiliar
N número de elementos
grupo arreglo con los tamaños de grupo
379051 6 842061 5 734982
3790516 8420615 734982
3320515 7440616 879982
Shellsort
Inicio
grupo = [ 21, 7, 3, 1]
para g=0; g<4; g++
h=grupo[g];
para i=h; i<n; i++
v=k[i];
j=i;
mientras (j>=h && a[j-h]>v)
k[j]=k[j-h];
j=j-h;
k[j]=v;
Fin
332 051 574 406 168 799 82
001 122 334 456 5 68 779 89
00112233445656877989
00112233445566778899
Radix
• Radix Sort (ordenamiento Radix) es un algoritmo de
ordenamiento estable* para ordenar elementos
identificados por llaves (o claves) únicas. Cada llave
debe ser una cadena o un número capaz de ser
ordenada alfanuméricamente.
• Este método ejecuta un número de repeticiones igual al
número de caracteres de las llaves a ordenar. El Radix
Directo, inicia con el dígito más a la derecha repartiendo
los datos en “canastas”, estos datos se reparten de
nuevo de acuerdo al siguiente dígito y así
sucesivamente hasta terminar con el dígito de mas a la
izquierda.
329 248 123 423 226 825 132 335 231 432 256 218
231
Distribución y
reacomodo
Digito
derecho
132 123
825 226
248 329
432 423
335 256
218
231 132 432 123 423 825 335 226 256 248 218 329
218
Distribución y
reacomodo
Digito
central
123
231 248 256
423
132
825
432
226
335
329
218 123 423 825 226 329 231 132 432 335 248 256
218 123 423 825 226 329 231 132 432 335 248 256
123 218 329 423
825
132 226 335 432
Distribución y
reacomodo
Digito
izquierdo
231
248
256
123 132 218 226 231 248 256 329 335 423 432 825
Ejemplo
Algoritmo: Quicksort
Profesora: Dra. Maria Lucia Barrón Estrada
Alumno: Guillermo Alberto Sandoval Sánchez
Descripción
• Se elige un pivote.
• Se reubican los elementos respecto al pivote los
menores antes, los mayores atrás.
• El arreglo queda separado en dos subarreglos
• Se repite el proceso con los subarreglos resultantes
• El arreglo esta ordenado
Pseudo-código
•
•
•
•
•
•
•
•
•
•
•
quicksort(q)
variables arreglos menores, arrPivotes, mayores
si la longitud de q es menor o igual que 1
devolver q
sino
seleccionar un pivote de q
para cada elemento en q excepto el pivote
si el elemento < pivote entonces agregarlo al arreglo menores
si el elemento ≥ pivote entones agregarlo al arreglo mayores
agregar el pivote al arrPivotes
devolver unir(quicksort(menores), arrPivotes, quicksort(mayores))
Ejecución por pasos
•
•
•
•
•
•
•
•
•
4-8-1-7-2-3-5
4-8-1-7-2-3-5
4-8-1-7-2-3-5
3-8-1-7-2-4-5
3-8-1-7-2-4-5
3-4-1-7-2-8-5
3-4-1-7-2-8-5
3-4-1-2-7-8-5
3-4-1-2-5-8-7
• 3-4-1-2
• 1-4-3-2
• 1-2-3-4
• 8-7
• 7-8
• 1-2-3-4-5-7-8
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
Implementación
en Java
import java.util.Comparator;
import java.util.Random;
public class Quicksort {
public static final Random RND = new Random();
private void swap(Object[] array, int i, int j) {
Object tmp = array[i];
array[i] = array[j];
array[j] = tmp;
}
private int partition(Object[] array, int begin, int end, Comparator cmp) {
int index = begin + RND.nextInt(end - begin + 1);
Object pivot = array[index];
swap(array, index, end);
for (int i = index = begin; i < end; ++ i) {
if (cmp.compare(array[i], pivot) <= 0) {
swap(array, index++, i);
}
}
swap(array, index, end);
return (index);
}
private void qsort(Object[] array, int begin, int end, Comparator cmp){
if (end > begin) {
int index = partition(array, begin, end, cmp);
qsort(array, begin, index - 1, cmp);
qsort(array, index + 1, end, cmp);
}
}
•
•
•
•
•
•
•
•
•
•
public void sort(Object[] array, Comparator cmp){
qsort(array, 0, array.length - 1, cmp);
}
}
Ordenamiento por conteo
• Este método utiliza un arreglo auxiliar para
contabilizar el numero de llaves que son
mayores que la llave actual.
• El arreglo de contadores, especifica la
posición final donde debería estar cada
elemento.
Ordenamiento por conteo
Variables
– K arreglo de datos a ordenar
– Cont arreglo de contadores
– N número de elementos a ordenar
ComparacionPorConteo
Inicio
inicializar el arreglo de contadores con cero en todas sus posiciones
Para i=N hasta 2 decremento 1
Para j=i-1 hasta 1 decremento 1
si K(i) < K(j) Cont(j)++
sino Cont(i)++
Fin
Ejemplo
1
K
Cont
2
3
4
5
23 11 19
8
7
1
2
3
4
5
0
0
0
0
0
Inicial
1
1
1
1
0
Primera pasada
2
2
2
1
0
Segunda pasada
3
2
3
1
0
Tercera pasada
4
2
3
1
0
Cuarta pasada
Ordenamiento por distribución
• Este método es bueno aplicarlo cuando
existen muchas claves repetidas y estas
se encuentran en un rango pequeño entre
u y v.
Rango u<=K1..n<=v
• Utiliza un arreglo contador con posiciones
desde u hasta v, además de un arreglo
para generar la salida.
Ordenamiento por distribución
Variables
–
–
Distribución
–
–
–
–
K arreglo de datos a ordenar
Cont arreglo de contadores con índices desde u hasta
v
S arreglo de salida
N número de elementos a ordenar
U llave menor
V llave mayor
Inicio
inicializar el arreglo de contadores con cero en todas sus posiciones
Para i=1 hasta N incremento 1
Cont(K(i))++
// cuenta las llaves iguales
Para j=u+1 hasta v incremento 1
Cont(j) = Cont(j) + Cont(j-1) // localiza la posición de cada llave
Para j=N hasta 1 decremento 1
i = Cont(K(j))
S(i) = K(j)
// envía la llave al vector de salida
Cont(K(j)) = Cont(K(j)) - 1
Fin
Ejemplo
1
Arreglo a ordenar
K
Arreglo de contadores
Cont
Arreglo de salida
2
3
4
5
29 31 29 34 29
29 30 31 32 33 34
0
0
0
0
0
0
Inicial
3
0
1
0
0
1
Cuenta llaves repetidas
3
3
4
4
4
5
Posición de cada llave
2
3
4
4
4
4
Acomodo en la salida
29
S
1
2
3
34
4
5