ED Material U5

ESTRUCTRA DE DATOS
Materia UNIDAD V. MÉTODOS DE

ORDENAMIENTO.
Instituto Tecnológico Superior de Macuspana

M.I.D.S. Angel León Ramos
7º
ESTRUCTURA DE DATOS
UNIDAD 5. METODO DE ORDENAMIENTO
Conoce, comprende y aplica los algoritmos de ordenamiento para el uso

adecuado en el desarrollo de aplicaciones que permita solucionar problemas
del entorno.
SEMESTRE
Agosto-diciembre 2020
Contenido
UNIDAD 5 METODO DE ORDENAMIENTO .................................................................. 3
5.1.1 BURBUJA. .............................................................................................................. 4
Práctica 1. Ordenamiento por burbuja. ........................................................................ 7
Actividad 1 para el estudiante ...................................................................................... 12
5.1.2 QUICKSORT. ....................................................................................................... 12
Práctica 2. ....................................................................................................................... 15
Actividad 2 para el estudiante...................................................................................... 19
5.1.3 SHELLSORT. ....................................................................................................... 20
Práctica 3 ...................................................................................................................... 22
Actividad 3 para el estudiante .............................................................................. 25
5.1.4 RADIX .................................................................................................................... 26
Práctica 4 ...................................................................................................................... 29
5.2 ALGORITMOS DE ORDENAMIENTO EXTERNOS ............................................. 32
5.2.1 INTERCALACIÓN ................................................................................................ 33
5.2.2 MEZCLA DIRECTA ............................................................................................. 34
5.2.3 MEZCLA NATURAL ............................................................................................ 36
Práctica 5 ...................................................................................................................... 39
2
UNIDAD 5 METODO DE ORDENAMIENTO
5.1 ALGORITMOS DE ORDENAMIENTO INTERNOS
Ordenar significa reagrupar o reorganizar un conjunto de datos u objetos
en una secuencia específica, la cual puede ser de dos formas distintas:
➢ Ascendente (menor a mayor) o - Descendente (mayor a menor).
➢ Los métodos de ordenación se clasifican en dos categorías:
✓ Ordenación interna (de arreglos) y
✓ Ordenación externa (de archivos).
La ordenación interna o de arreglos, recibe este nombre ya que los
elementos o componentes del arreglo se encuentran en la memoria
principal de la computadora.
Los métodos de ordenación interna a su vez se clasifican en:
- Métodos directos (n2) y - Métodos logarítmicos (n * log n).
Los métodos directos, son los más simples y fáciles de entender, son
eficientes cuando se trata de una cantidad de datos pequeña. Los
métodos logarítmicos, son más complejos, difíciles de entender y son
eficientes en grandes cantidades de datos.
Los métodos directos más conocidos son :
Ordenación por intercambio. - Ordenación por inserción. -
Ordenación por selección. Algoritmos de ordenamiento por intercambio.
La ordenación por intercambio consiste en comparar dos elementos del
arreglo y determinar si existe un intercamb io entre ellos, para esto debe
3
definirse el tipo de ordenamiento que se quiere ya sea ascendente o
descendente.
5.1.1 BURBUJA.
El método de ordenación por intercambio directo o método de la
burbuja, es el más simple y consiste en comparar dos elementos
adyacentes para determinar si se realiza un intercambio entre los mismos,
esto en caso de que el primero sea mayor
que el segundo (forma ascendente) o el caso de que el primero sea menor
que el segundo (forma descendente).
El primer procedimiento del método de la burbuja es:
1. Generar un ciclo que inicie desde uno hasta el número de elementos
del arreglo.
2. Generar un segundo ciclo dentro del anterior que inicie desde cero
hasta el número de elementos del arreglo menos dos.
3. Dentro del segundo ciclo debe existir una comparación que
determina el tipo de ordenamiento (ascendente o descendente)
entre el primer elemento (posición generada por el segundo ciclo) y
el segundo elemento (el que le sigue), si la respuesta a la condición
es verdadera se realiza un intercambio entre los dos elementos.
4. Para realizar el intercambio se genera un almacenami ento temporal,
el cual guarda el dato del primer elemento, el segundo elemento
toma el lugar del primero y en el lugar del segundo se coloca lo que
contiene el almacenamiento temporal.
4
Una vez que los ciclos terminan la estructura debe quedar ordenada d e
forma ascendente o descendente, pero este procedimiento es
considerado como el peor de los casos ya que si el número de elementos
de la estructura es de 100, se tienen que realizar 9900 comparaciones
entes de terminar la ejecución del método.
Un segundo procedimiento del método de la burbuja es:
1. Generar un ciclo que inicie desde cero hasta el número de
elementos menos dos.
2. Generar un segundo ciclo desde el valor del ciclo anterior más uno
hasta el número de elementos menos uno .
3. Dentro del segundo ciclo debe existir una c omparación que
determina el tipo de ordenamiento (ascendente o descendente)
entre el primer elemento (posición generada por el primer ciclo) y el
segundo elemento (posición generada por el segundo ciclo), si la
respuesta a la condición es verdadera se realiza un intercambio
entre los dos elementos.
4. Para realizar el intercambio se genera un almacenamiento temporal,
el cual guarda el dato del primer elemento, el segundo elemento
toma el lugar del primero y en el lugar del segundo se coloca lo que
Una vez que los ciclos terminan la estructura debe quedar ordenada, la
diferencia con el procedimiento anterior r adica en el número de
comparaciones y posibles intercambios que se presentan, en este
5
segundo procedimiento, es menor ya que cada pasada que se le da al
arreglo se realiza una comparación menos que en la pasada anterior.
Un tercer procedimiento del método de la burbuja es el siguiente:
1. Generar un ciclo que inicie desde uno hasta el número de
elementos menos uno.
2. Generar un segundo ciclo que inicie desde el número de
elementos menos uno y mientras que ese valor sea mayor o igual
al del ciclo anterior (con decrementos).
Dentro del segundo ciclo debe existir una comparación que
determina el tipo de ordenamiento Ascendente o descendente)
entre el primer elemento (posición generada por el segundo
ciclo) y el segundo elemento (posición generada por el segundo
ciclo menos uno), si la respuesta a la condición es verdadera se
realiza un intercambio entre los dos elementos. Par a realizar el
intercambio se genera un almacenamiento temporal, el cual
guarda el dato del primer elemento, el segundo elemento toma
el lugar del primero y en el lugar del segundo se coloca lo que
6
Práctica 1. Ordenamiento por burbuja.
Crear una clase llamada OrdenarBurbuja que utilizando el método de
burbuja permita ordenas los datos de un arreg lo, la clase debe calcular
las pasadas y las comparaciones realizadas (estadísticas). Deberá crear
un paquete llamado unidad5, dentro del proyecto inicial.
7
package unidad5;
/**
*
* @author Angel
*/
public class OrdenarBurbuja {
static String pasa, compara;
public static void ordenar(int [] arreglo){
int pasadas=0;
int comparaciones=0;
for(int i=0;i<arreglo.length;i++){
++ pasadas;
for(int j=0;j<arreglo.length-1;j++){
++ comparaciones;
if(arreglo [j]>arreglo[j+1]){
intercambiar(arreglo,j,j+1);
}
}
}
pasa=pasadas+"";
compara=comparaciones+"";
estadisticas(pasadas, comparaciones);
}
public static void ordenarMejorado(int [] arreglo){

int pasadas=0;
int comparaciones=0;
boolean hayCambios=true;
8
for(int i=0;hayCambios;i++){
++pasadas;
hayCambios=false;
for(int j=0;j<arreglo.length-1;j++){
++comparaciones;
if(arreglo[j]>arreglo[j+1]){
intercambiar(arreglo,j,j+1);
hayCambios=true;
}
}
}
estadisticas(pasadas,comparaciones);
}
private static void intercambiar(int []arreglo,int a,int b){
int tmp=arreglo[a];
arreglo[a]=arreglo[b];
arreglo[b]=tmp;
}
private static void estadisticas(int pasadas,int comparaciones){
System.out.println("Pasadas:"+pasadas);
System.out.println("Comparaciones:"+comparaciones);
}
public String Comparar(){
return compara;
}
public String Pasar(){
return pasa;
}
}
El siguiente paso consiste en agregar al paquete una interfaz gráfica
(jFrame).
9
Escribe el nombre: Ordenamiento y dar clic en siguiente
10
Como en la unidad se van a desarrollar 4 prácticas se sugiere que se
agregue el componente gráfico Tabbed Pane (para ir agregando Pane en
forma de pestañas visto en clases anteriores)
Diseño de la interfaz
Después de terminar el diseño, se debe crear el objeto :
OrdenarBurbuja n = new OrdenarBurbuja();

Posteriormente se crea un atributo llamado d para almacenar los datos
del arreglo, de igual manera se declara el arreglo y se le asignan valores:
String d = "";
int[] valores = {15, 35, 01, 05, 04, 03, 19, 45, 13, 02, 55, 8, 78, 997,
451, 546, 12, 16, 24, 103, 99, 784, 4541, 15};
Finalmente, dentro del botón se debe agregar el siguiente código:
for (int i = 0; i < valores.length; i++) {

d = d + (valores[i] + " ");
}
jTextField1.setText(d);
jTextArea1.append("Resultado:" + "\n");
n.ordenar(valores);
for (int i = 0; i < valores.length; i++) {
jTextArea1.append(valores[i] + "\n");
}
label3.setText("Pasadas " + n.Pasar());
label4.setText("Comparaciones " + n.Comparar());
El resultado es el siguiente:
11
Actividad 1 para el estudiante
Basado en el código anterior, crear un programa en donde los datos sean
ingresados por teclado.
5.1.2 QUICKSORT.
El método de ordenamiento rápido o método quicksort , es una
técnica basada en otra conocida con el nombre divide y vencerás, que
permite ordenar una cantidad de elementos en un tiempo proporcion al a
n2 en el peor de los casos o a n log n en el mejor de los casos. El algoritmo
original es recursivo, como la técnica en la que se basa.
12
La descripción del algoritmo para el método de ordenamiento quicksort es
la siguiente:
1. Debe elegir uno de los elementos del arreglo al que llamaremos pivote.
2. Debe acomodar los elementos del arreglo a cada lado del piv ote, de
manera que del lado izquierdo queden todos los menores al pivote y del
lado derecho
los mayores al pivote; considere que, en este momento, el pivote ocupa
exactamente el lugar que le corresponderá en el arreglo ordenado. 3.
Colocado el pivote en su lugar, el arreglo queda separado en dos
subarreglos, uno formado por los elementos del lado izquierdo del pivote,
y otro por los elementos del lado derecho del pivote. 4. Repetir este
proceso de forma recursiva para cada subarreglo mientras éstos
contengan más de un elemento. Una vez terminado este proceso todos
los elementos estarán ordenados.
Para elegir un pivote se puede aplicar cualquie ra de las siguientes tres
opciones:
1. El pivote será el primer elemento del arreglo,
2. El pivote será el elemento que esta a la mitad del arreglo, o
3. Que el pivote se elija de entre tres elementos del arreglo
(cualesquiera), los cuales se deben compar ar para seleccionar el valor
intermedio de los tres y considerarlo como el pivote.
La forma o técnica de reacomodo de los elementos del lado izquierdo y
derecho del pivote, aplica el siguiente procedimiento que es muy efectivo.
Se utilizan dos índices: izq, al que llamaremos índice inicial, y der, al que
13
llamaremos índice final. Conociendo estos elementos el algo ritmo
quedaría de la siguiente manera:
1. Recorrer el arreglo simultáneamente con izq y der: por la izquierda
con izq (desde el primer elemento), y por la derecha con der (desde
el último
elemento).
2. Mientras el arreglo en su posición izq (arreglo[izq]) s ea menor que
el pivote, continuamos el movimiento a la derecha.
3. Mientras el arreglo en su posición der (arreglo[der]) sea mayor que
el pivote, continuamos el movimiento a la izquierda.
4. Terminando los movimientos se compara los índices y si izq es
menor o igual al der, se intercambian los elementos en esas posiciones
y las posiciones se cambian izq a la derecha y der a la izquierda.
5. Repetir los pasos anteriores hasta que se crucen los índices (izq
sea menor o igual a der).
6. El punto en que se cruzan los índices es la posición adecuada para
colocar el pivote, porque sabemos que a un lado los elementos son
todos menores y al otro son todos ma yores (o habrían sido
intercambiados).
14
Práctica 2. Crear una clase que permita ordenar los datos de un arreglo utilizando
el método Quicksort.
package unidad5;
/**
*
* @author pc
*/
public class QuickSort {
public static void recQuickSort(int[] num, int izq, int der) {

int tam = der - izq + 1;
if (tam <= 3) {
manualSort(num, izq, der);
} else {
double media = divide(num, izq, der);
int particion = parteEntera(num, izq, der, media);
recQuickSort(num, izq, particion - 1);
recQuickSort(num, particion + 1, der);
}
}
public static int divide(int[] num, int izq, int der) {

int centro = (izq + der) / 2;
if (num[izq] > num[centro]) {

intercambio(num, izq, centro);
}
if (num[izq] > num[der]) {

intercambio(num, izq, der);
15
}
if (num[centro] > num[der]) {

intercambio(num, centro, der);
}
intercambio(num, centro, der - 1);

return num[der - 1];
}
public static void intercambio(int[] num, int dex1, int dex2) {

int temp = num[dex1];
num[dex1] = num[dex2];
num[dex2] = temp;
}
public static int parteEntera(int[] num, int izq, int der, double pivote
) {
int izqPtr = izq;
int derPtr = der - 1;
while (true) {
while (num[++izqPtr] < pivote)
;
while (num[--derPtr] > pivote)
;
if (izqPtr >= derPtr) {
break;
} else {
intercambio(num, izqPtr, derPtr);
}
}
intercambio(num, izqPtr, der - 1);
return izqPtr;
}
public static void manualSort(int[] num, int izq, int der) {

int tam = der - izq + 1;
if (tam <= 1) {
return;
}
if (tam == 2) {
}
16
return;
} else {
if (num[izq] > num[der - 1]) {
intercambio(num, izq, der - 1);
}
}
if (num[der - 1] > num[der]) {
intercambio(num, der - 1, der);
}
}
}
}
Componentes de la interfaz
Crear el objeto siguiendo las buenas prácticas de programación

QuickSort s = new QuickSort();
De igual manera declarar un arreglo y asignarle datos:

int[] quick = {15, 35, 01, 05, 04, 03, 19, 45, 13, 100, 02, 55, 8, 78, 997,
451, 546, 12, 16, 24, 103, 99, 784, 4541, 15};
17
Agregar dentro del botón el siguiente código:
// QuickSort
jTextArea2.setForeground(Color.GREEN);
jTextArea2.append("Arreglo original:" + "\n");
for (int i = 0; i < quick.length; i++) {
jTextArea2.append(quick[i] + " ");
}
jTextArea2.setForeground(Color.BLUE);
jTextArea2.append("\n" + "Arreglo ordenado:" + "\n");
s.recQuickSort(quick, 0, quick.length - 1);
for (int i = 0; i < quick.length; i++) {
jTextArea2.append(quick[i] + " ");
}
El resultado es el siguiente:
18
Actividad 2 para el estudiante. Tomando como base el diseño de la interfaz gráfica
de la práctica 2, agregar un cuadro de texto a la misma y que al hacer clic sobre el
botón ordenar muestre en ese cuadro los datos contenidos en el arreglo.
19
5.1.3 SHELLSORT.
El método de ordenación shellsort es una versión mejorada del
método de ordenación por inserción directa, que se utiliza cuando el
número de elementos es grande. Este método recibe su nombre gracias
a su creados Donald L. Shell, también se conoce con el no mbre inserción
con incrementos decrecientes.
En el método de ordenación por inserción directa, cada elemento se
compara con los elementos contiguos de su izquierda de uno por uno,
para lograr su ordenamiento; si por ejemplo, el elemento a comparar es
el más pequeño y se encuentra en la última posición del arreglo, hay que
ejecutar muchas comparaciones antes de colocar el elemento en su lugar
de forma definitiva.
El método de ordenación shellsort mejora el ordenamiento por inserción
comparando elementos separados por un espacio de varias posiciones.
Esto permite que un elemento haga p asos más grandes hacia la posición
que debe ocupar. Los pasos múltiples sobre los elementos se hacen con
tamaños de espacio cada vez más pequeños y el último paso del método
es un simple ordenamiento por inserción directa, pero para entonces, los
elementos de arreglo ya casi están ordenados.
Para determinar el tamaño de los incrementos (saltos) constantes, el
primero debe ser generado a partir del tamaño del arreglo entre dos,
obteniendo solo su parte entera de la división o redondeando el resultado
de la misma, y posteriormente ir reduciendo a la mitad el incremento en
cada repetición, hasta que el incremento sea un uno.
20
El procedimiento para aplicar el algoritmo de shel lsort es el siguiente:
1. Generar un ciclo que se encargue de controlar el tamaño que deben
tener los incrementos.
1. Este ciclo debe iniciar con la división del tamaño del arreglo entre
dos.
2. Mientras que el incremento sea mayor a cero debe continuar.
3. El cambio de incremento se elige de entre dos opciones: un uno
o la división del incremento anterior entre dos.
2. Un segundo ciclo dentro del anterior, controla el número de
comparaciones que se deben hacer según el tamaño del incremento.
1. El control de este ciclo debe iniciar con el incremento generado
anteriormente.
2. Mientras el control del ciclo sea menor que el tamaño del arreglo.
3. El control debe cambiar de uno en uno.
3. Un tercer ciclo dentro del segund o controla en que momento se
detienen las comparaciones o se hacen los posibles intercambios entre
los elementos.
1. El control de este ciclo debe iniciar con el valor del ciclo anterior.
2. Mientras que el control sea mayor o igual al incremento del primer
ciclo y el elemento del arreglo de la posición del control de este
ciclo menos el incremento, sea mayor que el elemento del arreglo
de la posición control de este ciclo, realice los intercambios entre
estas posiciones.
21
3. El control se decremente con el valor d el incremento.
Algoritmos de ordenamiento por distribución.
Los algoritmos de ordenamiento por d istribución, ordenan el arreglo
tomando cada número e insertándolo en la posición que toma su valor, es
decir, si se tiene un cinco se coloca en la posición ci nco del arreglo, algo
así como: “lo que valgas en esa posición te pongo”. Esto indica que no se
podrán ordenar los arreglos que tengan valores repetidos y el arreglo
necesita el tamaño del número más grande que se encuentre en él.
Lo que debemos hacer cuando se repitan los datos es incrementar la
capacidad de la posición (urna). Para lograrlo podem os hacer lo siguiente:
1. Definir un arreglo en el que cada posición puede ser ocupada por
más de un elemento (arreglo bidimensional) puede darse la
situación de ser insuficiente la cantidad de posiciones adicionales
o de existir demasiado desperdicio de memoria.
2. Definir el tamaño de la urna variable a través del uso de estructuras
de datos como las listas simples enlazadas.
Práctica 3. Crear un programa en consola que permita ingresar por
teclado los datos del arreglo que se utilizará para ordenarlo por el método
ShellSort, el programa debe contener una clase llamada ShellSort (la cual
contiene dos métodos para hacer el ordenamiento -el alumno deberá
hacer pruebas con ambas y determinar la diferen cia),
package unidad5;
/**
22
*
* @author pc
*/
public class ShellSort {
public void shellSort( int a[ ]){
for( int gap = a.length / 2; gap > 0; gap = gap == 2 ? 1 : (int) ( g
ap / 2.2 ) ){
for( int i = gap; i < a.length; i++ ){
int tmp = a[ i ];
int j;
for(j = i; j >= gap && tmp < a[ j - gap ] ; j -= gap ){
a[ j ] = a[ j - gap ];
}
a[ j ] = tmp;
}
}
}
public void ordenaShell(int[] v) {
final int N = v.length;
int incremento = N;
do {
incremento = incremento / 2;
for (int k = 0; k < incremento; k++) {
for (int i = incremento + k; i < N; i += incremento) {
int j = i;
while (j - incremento >= 0 && v[j] < v[j - incremento])
{
int tmp = v[j];
v[j] = v[j - incremento];
v[j - incremento] = tmp;
j -= incremento;
}
}
}
} while (incremento > 1);
}
}
23
La otra clase se llama ConsolaShellSort y contiene el m étodo principal
para poder realizar las pruebas.
package unidad5;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/**
*
* @author pc
*/
public class ConsolaShellSort {
public static void main(String[] args) throws IOException {
ShellSort shell=new ShellSort();

int arreglo[];
BufferedReader lee=new BufferedReader(new InputStreamReader(System.i
n));
System.out.println("Escriba el numero de datos a insetar en el arreg
lo");
int t=Integer.parseInt(lee.readLine());
arreglo=new int[t];
for(int c=0;c<t;c++){
System.out.println("Escriba el valor para la posicion "+c);
int b=Integer.parseInt(lee.readLine());
arreglo[c]=b;
}
shell.ordenaShell(arreglo);
for (int i=0;i < arreglo.length;i++){
System.out.print(arreglo[i]+" ");
}
}
}
24
Actividad 3 para el estudiante.
Tomando como base la clase ShellSort, el alumno debe crear una interfaz
gráfica que realice el mismo proceso que la interfaz de consola, es decir,
deberá solicitar la cantidad de datos a ingresar, así como los valores que
se agregarán al arreglo.
Posible diseño:
Al hacer clic sobre el botón que solicite la cant idad de datos a ingresar
utilizando
JOptionPane.showInputDialog(evento,"")
Posteriormente al dar clic en aceptar solicita la cantidad de datos que
contendrá el arreglo y finalmente muestra el arreglo original y luego
ordenado.
25
5.1.4 RADIX
El método de ordenación radix es un algoritmo que ordena datos
procesando sus elementos de forma individual, según la posición que
ocupan dentro del dato. Los datos numéricos los por dígitos y los datos
alfabéticos por letras.
El método radix se clasifica en dos tipos según el o rden en el que
procesan los datos:
✓ De derecha a izquierda y
✓ De izquierda a derecha.
26
Si aplicamos este método solo a enteros, el método se clasifica de
la siguiente manera:
✓ El digito menos significativo (LSD, Least Significat Digit) y
✓ El digito más significativo (MSD, More Significat Digit).
El radix LSD procesa los enteros in iciando por el digito menos significativo
y moviéndose al digito más significativo (de derecha a izquierda).
El radix MSD procesa los enteros iniciando por el digito más s ignificativo
y moviéndose al digito menos significativo (de izquierda a derecha).
El método más aplicado de radix, es el LSD, y se encarga de colocar los
números en una de las 10 colas que representan un digito cada una de
ella, iniciando desde la cola que controla el digito 0 hasta la cola que
controla el digito 9, en estas colas se col ocan los números dependiendo
del digito que se esté analizando en ese momento, hasta que termine con
el número que contenga la mayor cantidad de dígitos, en cada cambio de
digito los elementos se integran al arreglo nuevamente desde la cola 0
hasta la cola 9, para elegir el siguiente digito de ordenamiento. Cuando
se efectúa este proceso para cada dígito al arreglo está ordenado.
El procedimiento para aplicar el algoritmo d e radix es el siguiente:
1. Determinar cuál es la mayor cantidad de dígitos del e lemento mayor
del arreglo.
2. Crear un arreglo de colas, que permita almacenar cana uno de los
dígitos del 0 al 9.
27
3. Crear cada posición del arreglo como un objeto que permita
almacenar los elementos en cada cola, según el índice que le
corresponde.
4. Generar un ciclo que determine el número de digito que se esta
procesando y el factor que permite encontrar el digito .
1. Inicializar el número de digito y el factor en uno .
2. Mientras el digito sea menor o igual a la cantidad de dígitos
encontrados en el paso uno.
3. El número de digito se debe incrementar de uno en uno.
5. Crear un segundo ciclo que se encuentra d entro del anterior y que se
encarga de recorrer todo el arreglo desde la posición in icial hasta la final
del arreglo.
1. Iniciar el control del ciclo en cero.
2. Mientras el control sea menor al tamaño del arreglo, continuamos
en el ciclo.
3. El control del ciclo se cambia de uno en uno.
6. Generar un segundo ciclo que se encuentra den tro del primero, al igual
que el anterior y este controla el paso de los elementos de las colas al
arreglo nuevamente.
1. El control de este ciclo inicia desde la cola cer o, al igual que el
índice que controla el arreglo de los elementos.
2. Mientras el control sea menor a diez continua dentro del ciclo.
3. El control del ciclo se incrementa de uno en uno.
28
7. Dentro del ciclo anterior se genera otro ciclo que se encarga de colocar
el contenido de cada cola dentro del arreglo original y su condición es que
mientras la cola no esté vacía retire los elementos guardándolos en el
arreglo e incrementar el índice que controla el arreglo.
Práctica 4. Crear un programa de ordenamiento Radix, agregar al
paquete5 del proyecto una clase llamada Radix, la cu al contendrá el
siguiente código:
package unidad5;
import java.io.*;
import java.util.*;
class Radix {
static int ObtenerMax(int arr[], int n)

{
int mx = arr[0];
for (int i = 1; i < n; i++)
if (arr[i] > mx)
mx = arr[i];
return mx;
}
static void ContarSort(int arr[], int n, int exp)
{
int output[] = new int[n]; // output array
int i;
int count[] = new int[10];
Arrays.fill(count,0);
for (i = 0; i < n; i++)

count[ (arr[i]/exp)%10 ]++;
for (i = 1; i < 10; i++)

count[i] += count[i - 1];
for (i = n - 1; i >= 0; i--)

{
29
output[count[ (arr[i]/exp)%10 ] - 1] = arr[i];
count[ (arr[i]/exp)%10 ]--;
}
for (i = 0; i < n; i++)

arr[i] = output[i];
}
static void radixsort(int arr[], int n)

{
int m = ObtenerMax(arr, n);
for (int exp = 1; m/exp > 0; exp *= 10)

ContarSort(arr, n, exp);
}
static void Imprimir(int arr[], int n)

{
for (int i=0; i<n; i++)
System.out.print(arr[i]+" ");
}
public static void main (String[] args)

{
int arr[] = {170, 45, 75, 90, 802, 24, 2, 66};
int n = arr.length;
radixsort(arr, n);
Imprimir(arr, n);
}
}
Los últimos dos métodos Imprimir y main se usan exclusivamente para
crear una aplicación de consola, por lo cual los demás métodos s irven
para controlar el proceso de ordenamiento en una interfaz gráfica (J Frame
u otra).
Ahora solo se necesario ejecuta r el programa y ver que los datos del
arreglo se muestran en consola ordenados.
30
Dentro de la interfaz que se viene trabajando de la unidad 5 hay que
agregar otro Panel al JFrame y otros componentes gráficos como se
muestra a continuación:
Se debe crear el objeto:
Radix ord = new Radix();

Se declara y asigna valores al arreglo, aunque igual se puede usar
cualquiera de los creados en prácticas anteriores
int rad[] = {15, 35, 01, 05, 04, 03, 19, 45, 13, 100, 02, 55, 8, 78, 997, 45
1, 546, 12, 16, 24, 103, 99, 784, 4541, 15};
Se declara un atributo para determ inar el tamaño del arreglo:
int nt = rad.length;
Finalmente dentro del botón se escribe el siguiente código el cual se
encargar de mostrar en un primer momento el ar reglo original, después
31
aplicando el método radixsort al objeto ord, se realiza el ordenamiento y
se muestra el arreglo.
jTextArea4.append("Arreglo original\n");
for (int i = 0; i < nt; i++) {
jTextArea4.append(rad[i] + " ");
}
ord.radixsort(rad, nt);
jTextArea4.append("\nArreglo ordenado\n");
for (int i = 0; i < nt; i++) {
jTextArea4.append(rad[i] + " ");
}
Es importante que en cada una de las prácticas pongan atención a los
nombres de los componentes gráficos p ara que sepan que agregar (por si
ya se les olvidó como se hace).
5.2 ALGORITMOS DE ORDENAMIENTO EXTERNOS

La ordenación externa o de archivos, recibe este nombre ya que los
elementos se encuentran almacenados en un archivo, el cual se almacena
en un dispositivo de almacenamiento secundario o externo. Algoritmos de
ordenación externa.
Los algoritmos de ordenación externa son necesarios cuando l os datos
que se quiere ordenar no cabe en la memoria principal (RAM) de la
computadora y por tal motivo se encuent ran almacenados en un
dispositivo secundario externo (el disco duro, cinta, memori a usb, etc.).
La mayoría de estos algoritmos utilizan la téc nica de divide y vencerás y
la intercalación de archivos, para aplicar el ordenamiento.
32
Por intercalación de archivos se entiende la unión o fusión de dos o más
archivos, previamente ordenados, en un solo archivo, el cual debe quedar
ordenado al hacer la intercalación.
Si se cuenta con dos archivos con datos previamente ordenados, el
proceso de intercalación entre los dos archivos, consiste en extraer el
primer elemento de cada archivo y determin ar cuál es el menor, para
colocarlo en el tercer archivo, extraer el siguiente elemento del archivo y
compararlo nuevamente contra el otro elemento que ya se tenía del otro
archivo, para determinar cuál ingresa al tercer archivo, este proceso se
repita hasta que uno de los archivos originales llegue hasta el fin, en este
caso, solo resta transcribir los números del archivo que no se ha llegado
a su fin al tercer archivo.
Los algoritmos de ordenación externa más comunes son dos:
✓ Intercalación directa o mezcla directa y
✓ Mezcla natural o mezcla equilibrada.
5.2.1 INTERCALACIÓN
La ordenación de datos es un proceso muy frecuente en
programación. Esta operación es también un proceso que las personas
encuentran comúnmente en sus rutinas diarias. Por ejemplo, cada
elemento de la colección de datos de una agenda telefónica tiene un
campo nombre, dirección, y un número de teléfono. Una colección de
datos clasificados se puede almacenar en un archivo, un vector o tabla,
una lista enlazada o un árbol. Cuando los datos están almacenados en
33
vectores, tablas (arrays), listas enlazadas o árboles, la ordenación se
denomina ordenación interna. Cuando los datos a clasif icar se encuentran
almacenados en archivos, en soportes de almacenamiento masivo(cintas
o discos) el proceso de ordenación se denomina ord enación externa.
5.2.2 MEZCLA DIRECTA
La intercalación directa o mezcla directa es un algoritmo de
ordenación externa, que permite organizar los elementos de un archivo,
de forma ascendente o descendente.
La idea centrar de este algoritmo consiste en r ealizar de forma
sucesiva una partición y una fusión que produce secuencias ordenadas
de longitud cada vez mayor. En la primera pasada la partición es de
longitud 1 y la fusión produce secuencias ordenadas de longitud 2. En la
segunda pasada la partición es de longitud 2 y la fusión produce
secuencias ordenadas de longitud 4. Este proceso se repite hasta que la
longitud de la partición sea menor o igual al número de elementos del
archivo original.
Ejemplo. Considere el archivo F con los elementos 324, 230, 942,
700, 714, 139, 6, 915, 890 y 717, y los archivos auxiliares F1 y F2. El
proceso de ordenamiento según la descripción del algoritmo anterior
seria:
F: 324, 230, 942, 700, 714, 139, 6 , 915, 890, 717 T.
Partición: 1
34
Partición: Se construye tomando un número para cada una de las
particiones
F1: 324, 942, 714, 6, 890
F2: 230, 700, 139, 915, 717
Fusión: Se fusionan las dos particiones comparando el menor de la
partición va primero
F: 230, 324, 700, 942, 139, 714, 6, 915, 717, 890
Partición: 2
Partición: Se construye tomando dos números para cada una de las
particiones
F1: 230, 324, 139, 714, 717, 890
F2: 700, 942, 6, 915
Fusión:
F: 230, 324, 700, 942, 6, 139, 714, 915, 717, 890 T.
Partición: 4
Partición:
F1: 230, 324, 700, 942, 717, 8 90
F2: 6, 139, 714, 915
Fusión:
F: 6, 139, 230, 324, 700, 714, 915, 942, 717, 890 T.
Partición: 8
Partición:
F1: 6, 139, 230, 324, 700, 714, 915, 942
F2: 717, 890
35
Fusión:
F: 6, 139, 230, 324, 700, 714, 717, 890, 915, 942
5.2.3 MEZCLA NATURAL
La mezcla natural o mezcla equilibrada es un algoritmo de
ordenación externa, que se encarga de organizar los elementos de un
archivo de forma ascendente o descendente.
La idea central de este algoritmo consiste en realizar particiones tomando
secuencias ordenadas de máxima longitud en lugar de secuencias
ordenadas de tamaño fijo previamente determinadas, como la
intercalación directa. Posteriormente se realiza la fusión de esas
secuencias ordenadas, alternándolas entre los dos archivos auxiliares.
Repitiendo este proceso, se logra que el archivo quede completamente
ordenado. Para aplicar este algoritmo, se necesitarán cuatro archivos. El
archivo original y tres archivos auxiliares. De estos cua tro archivos, dos
serán considerados de entrada y dos de salida , alternativamente en cada
paso del algoritmo. El proceso termina cuando al fin alizar un paso, el
segundo archivo de salida quede vacío y el primero queda completamente
ordenado.
Ejemplo. Considere el archivo F con los elementos 324, 230, 942, 700,
714, 139, 6, 915, 890 y 717, y los archivos auxiliares F1, F2 y F3. El
proceso de ordenamiento según el algoritmo anterior seria:
36
F: 324, 230, 942, 700, 714, 139, 6, 915, 890, 717
Partición inicial
F1: 324, 700, 714, 6, 915, 717
F2: 230, 942, 139, 890
Fisión-Partición
F: 230, 324, 700, 714, 942
F3: 6, 139, 890, 915, 717
Fisión-Partición
F1: 6, 139, 230, 324, 700, 714, 890, 915, 942
F2: 717
Fisión-Partición
F: 6, 139, 230, 324, 700, 714, 717, 890, 915, 942
F3: (sin elementos)
Otra alternativa de solución a este algoritmo es un procedimiento
que solo utiliza tres archivos: el archivo original y dos auxiliar es, el primer
proceso consiste en dividir el archivo original en dos, colocando
secuencias ordenadas de máxima longitud en cada uno de los auxiliares,
una secuencia a la vez en cada auxiliar; el siguiente proceso consiste en
hacer una fusión de los dos auxiliares colocando los elementos en el
archivo original, con secuenciar ordenadas de máxima longitud, extraídas
37
de los dos archivos auxiliares. Estos do s pasos se repiten mientras que
el segundo archivo auxiliar sea diferente de cero.
Ejemplo. Considere el archivo F con los elementos 324, 230, 942,
700, 714, 139, 6, 915, 890 y 717, y los archivos auxiliares F1 y F2. El
proceso de ordenamiento según la d escripción del algoritmo anterior
seria:
F: 324, 230, 942, 700, 714, 139, 6, 915, 890, 717
Partición: Se crea con una intercalación (Se almacenan en la
primera partición mientras sean mayores y se pasa a la segunda partición
cuando sea menor y se siguen almacenando mientras sean mayores)
F1: 324, 700, 714, 6, 915, 717
F2: 230, 942, 139, 890
Fisión: Se aplica una intercalación
F: 230, 324, 700, 714, 6, 915, 717, 942, 139, 890
Partición
F1: 230, 324, 700, 714, 717, 942
F2: 6, 915, 139, 890
Fisión
F: 6, 230, 324, 700, 714, 717, 915 , 139, 890, 942
Partición
F1: 6, 230, 324, 700, 714, 717, 915
F2: 139, 890, 942
Fisión
F: 6, 139, 230, 324, 700, 714, 717, 890, 915, 942
38
Falta otra pasada y F2 se queda sin valores.
Práctica 5. Crear un programa en consola que contenga un menú de
opciones para elegir el tipo de ordenamiento, los datos se generan de
forma automática y son agregador a archivos externos en función de modo
de ordenamiento, la primer clase llamada Principal contiene el menú de
opciones y permite al usuario elegir entre:
Selecciona una de las Opciones
0: Crear Archivo
1: Leer
2: Mezcla Directa
3: Mezcla Natural
4: Intercalacion
5: Salir
package unidad5;
import java.util.*;
import java.io.*;
/**
*
* @author pc
*/
public class Principal {
public static void main(String[] args) throws IOException, ClassNotFound

Exception {
Scanner sc = new Scanner(System.in);
String NombreArchivo0 = "original";
String NombreArchivo1 = "mezcla directa";
String NombreArchivo2 = "mezcla natural";
String NombreArchivo3 = "Intercalacion";
File f = null;
File fd = null;
File fn = null;
39
File fi = null;
mezcladirecta MD = new mezcladirecta();
mezclanatural MN = new mezclanatural();
intercalacion IN = new intercalacion();
imprimir IM = new imprimir();
Random rnd = new Random();
long TInicio, TFin, tiempo;
boolean BAND1 = false, BAND2 = false;
String opcion, numero;
int op = 0, n = 0, valor;
do {
try {
System.out.println("");
System.out.println("----------------------------------------
--------------------");
System.out.println("Elija una de Las Opciones");
System.out.println("0: Crear Archivo");
System.out.println("1: Leer");
System.out.println("2: Mezcla Directa");
System.out.println("3: Mezcla Natural");
System.out.println("4: Intercalacion");
System.out.println("5: Salir");
--------------------");
opcion = sc.nextLine();
op = Integer.parseInt(opcion);
--------------------");
switch (op) {
case 0: {
System.out.println("Ingresa La Cantidad De Datos");
numero = sc.nextLine();
n = Integer.parseInt(numero);
f = new File(NombreArchivo0);
fd = new File(NombreArchivo1);
fn = new File(NombreArchivo2);
DataOutputStream FlujoO = null;

DataOutputStream FlujoD = null;
DataOutputStream FlujoN = null;
try {
FlujoO = new DataOutputStream(new BufferedOutput
Stream(new FileOutputStream(f)));
40
FlujoD = new DataOutputStream(new BufferedOutput
Stream(new FileOutputStream(fd)));
FlujoN = new DataOutputStream(new BufferedOutput

Stream(new FileOutputStream(fn)));
for (int j = 1; j <= n; j++) {
System.out.println("Valor " + j + ":");
valor = (int) (rnd.nextDouble() * 1000 + 0);
System.out.println(" " + valor + ".");
FlujoO.writeInt(valor);
FlujoD.writeInt(valor);
FlujoN.writeInt(valor);
}
System.out.println("Archivo Llenado con exito :3
");
FlujoO.close();
FlujoD.close();
FlujoN.close();
} catch (IOException e) {
System.out.println("Error de Entrada/Salida");
}
break;
}
case 1:
if (n != 0) {
System.out.println("Archivo Original");
IM.Imprimir(f, n);
} else {
System.out.println("El Archivo Esta Vacio");
}
break;
case 2:
if (n != 0) {
TInicio = System.currentTimeMillis();
MD.mdirecta(fd);
TFin = System.currentTimeMillis();
BAND1 = true;
System.out.println("Archvio (mezcla directa)");
IM.Imprimir(fd, n);
tiempo = TFin - TInicio;
41
System.out.println(" ");
} else {
}
break;
case 3:
if (n != 0) {
System.out.println("Archvio (mezcla natural)");
MN.MezclaNatural(fn);
BAND2 = true;
System.out.println("Tiempo De Ejcecucion " + tie
mpo + ".");
} else {
}
break;
case 4:
if (n != 0 && BAND1 == true && BAND2 == true) {
System.out.println("Archivo");
fi = new File(NombreArchivo3);
fn = fd;
IN.Intercalacion(fd, fn, fi, n);
} else {
System.out.println("Archivo Vacio");
}
break;
}
} catch (NumberFormatException e) {
System.out.println("Ingresa solo caracteres validos");
}
} while (op != 5);
}
}
42
Agregar al proyecto la clase imprimir, la cual permite leer la información
contenida en los archivos externos.
package unidad5;
/**
*
* @author pc
*/
import java.io.*;
public class imprimir {
public void Imprimir(File f, int n) throws IOException {

DataInputStream FlujoIm = null;
FlujoIm = new DataInputStream(new BufferedInputStream(new FileInputS
tream(f)));
for (int i = 1; i <= n; i++) {
System.out.println(" *" + FlujoIm.readInt() + " ");
}
}
}
La clase intercalacion contiene el código para ordenar los datos mediante
la intercalación de los valores almacenados en cada uno de los archiv os
generados.
package unidad5;
/**
*
* @author pc
*/
import java.io.*;
public class intercalacion {
public void Intercalacion(File f1, File f2, File f3, int n) throws IOExc
eption {
int var1 = 0;
int var2 = 0;
43
DataInputStream flujo1 = new DataInputStream(new BufferedInputStream
(new FileInputStream(f1)));
DataInputStream flujo2 = new DataInputStream(new BufferedInputStream
DataOutputStream flujo3 = new DataOutputStream(new BufferedOutputStr

eam(new FileOutputStream(f3)));
boolean Bandera1 = true;
boolean Bandera2 = true;
int Contador = 0;
int Contador1 = 0;
while (((Contador < (f1.length() / 4)) || (Bandera1 == false)) && ((
Contador1 < (f2.length() / 4)) || (Bandera2 == false))) {
if (Bandera1 == true) {
var1 = flujo1.readInt();
Bandera1 = false;
Contador++;
System.out.println(var1);
}
if (Bandera2 == true) {
Bandera2 = false;
Contador1++;
System.out.println(var2);
}
if (var1 < var2) {
flujo3.writeInt(var1);
Bandera1 = true;
} else {
Bandera2 = true;
}
}
if (Bandera1 == false) {
while (Contador < (f1.length() / 4)) {
Contador++;
}
}
if (Bandera2 == false) {
44
while (Contador1 < (f2.length() / 4)) {
Contador1++;
}
}
flujo1.close();
flujo2.close();
flujo3.close();
}
}
La clase mezcladirecta, al igual que la anterior hace uso de archivos
externos para el ordenamiento:
package unidad5;
/**
*
* @author pc
*/
import java.io.*;
public class mezcladirecta {
static void mdirecta(File f) throws IOException {

int longSec;
int numReg;
File f1 = new File("ArchivoAux1");
File f2 = new File("ArchivoAux2");
numReg = (int) f.length() / 4;
longSec = 1;
while (longSec < numReg) {
Distribuir(f, f1, f2, longSec, numReg);
Mezclar(f1, f2, f, longSec, numReg);
longSec *= 2;
}
}
static void Distribuir(File f, File f1, File f2, int longSec, int numReg
) throws IOException {
int numSec, Resto, i;
45
DataInputStream Flujo = new DataInputStream(new BufferedInputStream(
new FileInputStream(f)));
DataOutputStream Flujo1 = new DataOutputStream(new BufferedOutputStr
DataOutputStream Flujo2 = new DataOutputStream(new BufferedOutputStr

numSec = numReg / (2 * longSec);
Resto = numReg % (2 * longSec);
for (i = 1; i <= numSec; i++) {
subSecuencia(Flujo, Flujo1, longSec);
}
if (Resto > longSec) {
Resto -= longSec;
} else {
longSec = Resto;
Resto = 0;
}
subSecuencia(Flujo, Flujo2, Resto);
Flujo.close();
Flujo1.close();
Flujo2.close();
}
static void subSecuencia(DataInput f, DataOutput t, int longSec) throws

IOException {
int Clave;
for (int j = 1; j <= longSec; j++) {
Clave = f.readInt();
t.writeInt(Clave);
}
}
static void Mezclar(File f1, File f2, File f, int lonSec, int numReg) th
rows IOException {
int numSec, Resto, i, j, k;
int Clave1 = 0, Clave2 = 0;
numSec = numReg / (2 * lonSec);
Resto = numReg % (2 * lonSec);
DataOutputStream Flujo = new DataOutputStream(new BufferedOutputStre
am(new FileOutputStream(f)));
DataInputStream Flujo1 = new DataInputStream(new BufferedInputStream
46
DataInputStream Flujo2 = new DataInputStream(new BufferedInputStream
Clave1 = Flujo1.readInt();
for (int s = 1; s <= numSec + 1; s++) {
int n1, n2;
n1 = n2 = lonSec;
if (s == numSec + 1) {
if (Resto > lonSec) {
n2 = Resto - lonSec;
} else {
n1 = Resto;
n2 = 0;
}
}
i = j = 1;
while (i <= n1 && j <= n2) {
int Clave;
if (Clave1 < Clave2) {
Clave = Clave1;
try {
} catch (EOFException e) {;
}
i++;
} else {
Clave = Clave2;
try {
}
j++;
}
Flujo.writeInt(Clave);
}
for (k = i; k <= n1; k++) {
Flujo.writeInt(Clave1);
try {
}
}
for (k = j; k <= n2; k++) {
Flujo.writeInt(Clave2);
try {
47
}
}
}
Flujo.close();
Flujo1.close();
Flujo2.close();
}
}
Finalmente se crea la clase mezclanatural, esta al ejecutarse genera 6
archivos en el directorio raíz del proyecto con el fin de realizar el
ordenamiento.
package unidad5;
/**
*
* @author pc
*/
import java.io.*;
public class mezclanatural {
static final int N = 6;

static final int N2 = N / 2;
static File[] f = new File[N];
static final int NumReg = 10;
static final int TOPE = 999;
static void MezclaNatural(File fn) throws IOException, ClassNotFoundExce

ption {
int i, j, k, k1, t;
int anterior;
int[] c = new int[N];
int[] cd = new int[N];
int[] r = new int[N2];
Object[] Flujos = new Object[N];
DataInputStream FlujoEntradaActual = null;
DataOutputStream FlujoSalidaActual = null;
boolean[] actvs = new boolean[N2];
48
try {
String[] nomf = {"ar1", "ar2", "ar3", "ar4", "ar5", "ar6"};
for (int x = 0; x < N; x++) {
f[x] = new File(nomf[x]);
}
t = Distribuir(fn);
for (i = 0; i < N; i++) {
c[i] = i;
}
do {
k1 = (t < N2) ? t : N2;
for (i = 0; i < k1; i++) {
Flujos[c[i]] = new DataInputStream(new BufferedInputStre
am(new FileInputStream(f[c[i]])));
cd[i] = c[i];
}
j = N2;
t = 0;
for (i = j; i < N; i++) {
Flujos[c[i]] = new DataOutputStream(new BufferedOutputSt
ream(new FileOutputStream(f[c[i]])));
}
for (int n = 0; n < k1; n++) {
FlujoEntradaActual = (DataInputStream) Flujos[cd[n]];
r[n] = FlujoEntradaActual.readInt();
}
while (0 < k1) {
t++;
for (i = 0; i < k1; i++) {
actvs[i] = true;
}
FlujoSalidaActual = (DataOutputStream) Flujos[c[j]];
while (!finDeTramos(actvs, k1)) {
int n;
n = minimo(r, actvs, k1);
FlujoEntradaActual = (DataInputStream) Flujos[cd[n]]
;
FlujoSalidaActual.writeInt(r[n]);
anterior = r[n];
try {
r[n] = FlujoEntradaActual.readInt();
if (r[n] < anterior) {
actvs[n] = false;
}
} catch (EOFException e) {
49
k1--;
FlujoEntradaActual.close();
cd[n] = cd[k1];
r[n] = r[k1];
actvs[n] = actvs[k1];
actvs[k1] = false;
}
}
j = (j < N - 1) ? j + 1 : N2;
}
for (i = N2; i < N; i++) {
FlujoSalidaActual = (DataOutputStream) Flujos[c[i]];
FlujoSalidaActual.close();
}
for (i = 0; i < N2; i++) {
int a;
a = c[i];
c[i] = c[i + N2];
c[i + N2] = a;
}
} while (1 < t);
System.out.println(" ARCHIVO ORDENADO:");
escribir(f[c[0]]);
} catch (IOException er) {
er.printStackTrace();
}
}
private static int Distribuir(File f0) throws IOException, ClassNotFound

Exception {
int anterior, j, nt;
int clave;
DataInputStream Flujo = new DataInputStream(new BufferedInputStream(
new FileInputStream(f0)));
DataOutputStream[] FlujoSalida = new DataOutputStream[N2];
for (j = 0; j < N2; j++) {
FlujoSalida[j] = new DataOutputStream(new BufferedOutputStream(n
ew FileOutputStream(f[j])));
}
anterior = -TOPE;
clave = anterior + 1;
j = 0;
nt = 0;
try {
while (true) {
50
clave = Flujo.readInt();
while (anterior <= clave) {
FlujoSalida[j].writeInt(clave);
anterior = clave;
clave = Flujo.readInt();
}
nt++;
j = (j < N2 - 1) ? j + 1 : 0;
FlujoSalida[j].writeInt(clave);
anterior = clave;
}
} catch (EOFException eof) {
nt++;
System.out.println("Numero de tramos " + nt + ".");
Flujo.close();
for (j = 0; j < N2; j++) {
FlujoSalida[j].close();
}
return nt;
}
}
public static int minimo(int[] r, boolean[] activo, int n) {

int i, indice;
int m;
i = indice = 0;
m = TOPE + 1;
for (; i < n; i++) {
if (activo[i] && r[i] < m) {
m = r[i];
indice = i;
}
}
return indice;
}
private static boolean finDeTramos(boolean[] activo, int n) {

boolean s = true;
for (int k = 0; k < n; k++) {
if (activo[k]) {
s = false;
}
}
return s;
51
}
static void escribir(File f) {

int clave, k;
boolean mas = true;
DataInputStream Flujo = null;
try {
Flujo = new DataInputStream(new BufferedInputStream(new FileInpu
tStream(f)));
k = 0;
while (mas) {
k++;
System.out.println("* " + Flujo.readInt() + ".");
if (k % 10 == 0) {
}
}
} catch (IOException eof) {
try {
if (eof instanceof EOFException) {
Flujo.close();
}
} catch (IOException er) {
er.printStackTrace();
}
}
}
}
52

ED Material U5

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

ED Material U5

Cargado por

Copyright:

Formatos disponibles

ESTRUCTRA DE DATOS

Materia UNIDAD V. MÉTODOS DE

Instituto Tecnológico Superior de Macuspana

UNIDAD 5. METODO DE ORDENAMIENTO

Conoce, comprende y aplica los algoritmos de ordenamiento para el uso

Ordenar significa reagrupar o reorganizar un conjunto de datos u objetos

en una secuencia específica, la cual puede ser de dos formas distintas:

➢ Ascendente (menor a mayor) o - Descendente (mayor a menor).

➢ Los métodos de ordenación se clasifican en dos categorías:

✓ Ordenación interna (de arreglos) y

✓ Ordenación externa (de archivos).

La ordenación interna o de arreglos, recibe este nombre ya que los

elementos o componentes del arreglo se encuentran en la memoria

Los métodos de ordenación interna a su vez se clasifican en:

- Métodos directos (n2) y - Métodos logarítmicos (n * log n).

eficientes cuando se trata de una cantidad de datos pequeña. Los

métodos logarítmicos, son más complejos, difíciles de entender y son

eficientes en grandes cantidades de datos.

Los métodos directos más conocidos son :

Ordenación por intercambio. - Ordenación por inserción. -

Ordenación por selección. Algoritmos de ordenamiento por intercambio.

La ordenación por intercambio consiste en comparar dos elementos del

arreglo y determinar si existe un intercamb io entre ellos, para esto debe

El método de ordenación por intercambio directo o método de la

burbuja, es el más simple y consiste en comparar dos elementos

adyacentes para determinar si se realiza un intercambio entre los mismos,

esto en caso de que el primero sea mayor

que el segundo (forma ascendente) o el caso de que el primero sea menor

que el segundo (forma descendente).

El primer procedimiento del método de la burbuja es:

1. Generar un ciclo que inicie desde uno hasta el número de elementos

hasta el número de elementos del arreglo menos dos.

3. Dentro del segundo ciclo debe existir una comparación que

determina el tipo de ordenamiento (ascendente o descendente)

entre el primer elemento (posición generada por el segundo ciclo) y

el segundo elemento (el que le sigue), si la respuesta a la condición

es verdadera se realiza un intercambio entre los dos elementos.

4. Para realizar el intercambio se genera un almacenami ento temporal,

el cual guarda el dato del primer elemento, el segundo elemento

toma el lugar del primero y en el lugar del segundo se coloca lo que

contiene el almacenamiento temporal.

forma ascendente o descendente, pero este procedimiento es

considerado como el peor de los casos ya que si el número de elementos

de la estructura es de 100, se tienen que realizar 9900 comparaciones

entes de terminar la ejecución del método.

Un segundo procedimiento del método de la burbuja es:

1. Generar un ciclo que inicie desde cero hasta el número de

elementos menos dos.

hasta el número de elementos menos uno .

3. Dentro del segundo ciclo debe existir una c omparación que

determina el tipo de ordenamiento (ascendente o descendente)

entre el primer elemento (posición generada por el primer ciclo) y el

segundo elemento (posición generada por el segundo ciclo), si la

respuesta a la condición es verdadera se realiza un intercambio

entre los dos elementos.

4. Para realizar el intercambio se genera un almacenamiento temporal,

el cual guarda el dato del primer elemento, el segundo elemento

toma el lugar del primero y en el lugar del segundo se coloca lo que

contiene el almacenamiento temporal.

diferencia con el procedimiento anterior r adica en el número de

comparaciones y posibles intercambios que se presentan, en este

arreglo se realiza una comparación menos que en la pasada anterior.

Un tercer procedimiento del método de la burbuja es el siguiente: