INSTITUTO TECNOLGICO

DE LZARO CRDENAS
Estructura de datos
Ingeniera en Sistemas Computacionales
Unidad 5
Equipo:
Erick Amando Hernndez Toledo
Dominic Campos Avils
Kevin Daniel Romn Martnez

Profesor: Gabriel Nava Fombona

Cd. Y PUERTO LZARO CRDENAS MICHOACN

30 de Octubre del 2014

Unidad 5
Introduccin .............................................................................................................. 3
5.1. Algoritmos de Ordenamiento Internos ........................................................... 3
5.1.1 Burbuja........................................................................................................... 3
Ejemplo: .............................................................................................................. 5
5.1.2 Quicksort ....................................................................................................... 6
Ejemplo: .............................................................................................................. 7
5.1.3 Shell Sort........................................................................................................ 9
Ejemplo: ............................................................................................................ 10
5.1.4 Radix ............................................................................................................ 13
Ejemplo: ............................................................................................................ 14
5.2. Algoritmos de ordenamiento Externos ......................................................... 18
5.2.1 Intercalacin ................................................................................................ 18
Ejemplo: ............................................................................................................ 18
5.2.2 Mezcla Directa ............................................................................................ 20
Ejemplo: ............................................................................................................ 21
5.2.3 Mezcla Natural ............................................................................................ 22
Ejemplo: ............................................................................................................ 22

Introduccin
En esta unidad veremos el uso de los algoritmos de ordenamiento, conoceremos sus
ventajas y desventajas y as saber cul usar en diferentes ocasiones que se nos puedan
presentar en un futuro cuando queramos realizar algn programa.
Ordenar significa reagrupar o reorganizar un conjunto de datos u objetos en una secuencia
especfica, la cual puede ser de dos formas distintas:
Ascendente (menor a mayor) o
Descendente (mayor a menor).
Los mtodos de ordenacin se clasifican en dos categoras:
Ordenacin interna (de arreglos) y
Ordenacin externa (de archivos).
La ordenacin interna o de arreglos, recibe este nombre ya que los elementos o
componentes del arreglo se encuentran en la memoria principal de la computadora.

5.1. Algoritmos de Ordenamiento Internos

5.1.1 Burbuja
El mtodo de ordenacin por intercambio directo o mtodo de la burbuja, consiste en
ciclar repetidamente a travs de la lista, comparando elementos adyacentes de dos en dos.
Si un elemento es mayor que el que est en la siguiente posicin se intercambian.

Ventajas:

Fcil implementacin.
No requiere memoria adicional.

Desventajas:

Muy lento.
Realiza numerosas comparaciones.
Realiza numerosos intercambios.
Este algoritmo es uno de los ms pobres en rendimiento.

Primer procedimiento del mtodo de la burbuja:

1. Generar un ciclo que inicie desde uno hasta el nmero de elementos del arreglo.
2. Generar un segundo ciclo dentro del anterior que inicie desde cero hasta el nmero
de elementos del arreglo menos dos.
3. Dentro del segundo ciclo debe existir una comparacin que determina el tipo de
ordenamiento (ascendente o descendente) entre el primer elemento (posicin
generado por el segundo ciclo) y el segundo elemento (el que le sigue), si la
respuesta a la condicin 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.

Una vez que los ciclos terminan la estructura debe quedar ordenada de forma ascendente o
descendente, pero este procedimiento es considerado como el pero de los casos ya que si el
nmero de elementos de la estructura es de 100, se tienen que realizar 9900 comparaciones
entes de terminar la ejecucin del mtodo.

Segundo procedimiento del mtodo de la burbuja:

1. Generar un ciclo que inicie desde cero hasta el nmero de elementos menos dos.
2. Generar un segundo ciclo desde el valor del ciclo anterior ms uno hasta el nmero
de elementos menos uno;
3. Dentro del segundo ciclo debe existir una comparacin que determina el tipo de
ordenamiento (ascendente o descendente) entre el primer elemento (posicin
generada por el primer ciclo) y el segundo elemento (posicin generada por el
segundo ciclo), si la respuesta a la condicin 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.
Una vez que los ciclos terminan la estructura debe quedar ordenada, la diferencia con el
procedimiento anterior radica en el nmero de comparaciones y posibles intercambios que
se presentan, en este segundo procedimiento, es menor ya que cada pasada que se le da al
arreglo se realiza una comparacin menos que en la pasada anterior.

Ejemplo:
public static void burbuja(int [] A){
int i, j, aux;
for(i=0;i<A.length-1;i++)
for(j=0;j<A.length-i-1;j++)
if(A[j+1]<A[j]){
aux=A[j+1];
A[j+1]=A[j];
A[j]=aux;
}
}

5.1.2 Quicksort
El ordenamiento rpido (quicksort) es un algoritmo que permite, en promedio, ordenar n
elementos en un tiempo proporcional a n log n. Es la tcnica de ordenamiento ms rpida
conocida. El algoritmo original es recursivo.

Algoritmo fundamental:

Elegir un elemento de la lista de elementos a ordenar, al que llamaremos pivote.

Resituar los dems elementos de la lista a cada lado del pivote.
La lista queda separada en dos sublistas, una formada por los elementos a la
izquierda del pivote, y otra por los elementos a su derecha.
Repetir este proceso de forma recursiva para cada sublista mientras stas contengan
ms de un elemento.
En el mejor caso, el pivote termina en el centro de la lista, dividindola en dos
sublistas de igual tamao.
En el peor caso, el pivote termina en un extremo de la lista.
En el caso promedio, el orden es O(nlog n).

Elegir un pivote:
El pivote ser el primer elemento del arreglo,
El pivote ser el elemento que esta a la mitad del arreglo, o
Que el pivote se elija de entre tres elementos del arreglo (cualesquiera), los cuales se
deben comparar para seleccionar el valor intermedio de los tres y considerarlo
como el pivote.

Tcnica de reacomodo de los elementos del lado izquierdo y derecho:

Recorrer el arreglo simultneamente con izq y der: por la izquierda con izq (desde el
primer elemento), y por la derecha con der(desde el ltimo elemento).
Mientras el arreglo en su posicin izq (arreglo[izq]) sea menor que el pivote,
continuamos el movimiento a la derecha.
Mientras el arreglo en su posicin der (arreglo[der]) sea mayor que el pivote,
continuamos el movimiento a la izquierda.
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.
Repetir los pasos anteriores hasta que se crucen los ndices (izq sea menor o igual a
der).

El punto en que se cruzan los ndices es la posicin adecuada para colocar el pivote, porque
sabemos que a un lado los elementos son todos menores y al otro son todos mayores (o
habran sido intercambiados).

Ejemplo:
public class QuickSort{
public static void main(String a[]){
int i;
int array[] = {12,9,4,99,120,1,3,10,13};

System.out.println(" Quick Sort\n");

System.out.println("Valores antes de QuickSort:\n");
for(i = 0; i < array.length; i++)
System.out.print( array[i]+" ");
System.out.println();
quick_srt(array,0,array.length-1);
System.out.print("\n\n\nValores despues de QuickSort:\n\n");
for(i = 0; i <array.length; i++)
System.out.print(array[i]+" ");
System.out.println();
}
public static void quick_srt(int array[],int low, int n){
int lo = low;
int hi = n;
if (lo >= n) {
return;
}
int mid = array[(lo + hi) / 2];
while (lo < hi) {
while (lo<hi && array[lo] < mid) {
lo++;
}
while (lo<hi && array[hi] > mid) {
hi--;
}
if (lo < hi) {
int T = array[lo];
array[lo] = array[hi];
array[hi] = T;
}
}
if (hi < lo) {
int T = hi;
hi = lo;
lo = T;
}
quick_srt(array, low, lo);
quick_srt(array, lo == low ? lo+1 : lo, n);
}
}

5.1.3 Shell Sort

Este mtodo se conoce con el nombre de insercin por incrementos decrecientes.
Shell Propone que las comparaciones entre elementos se efecten con salto de mayor
tamao pero con incrementos decrecientes, as, los elementos quedaran ordenados en el
arreglo ms rpidamente.
Este mtodo, es una mejora del mtodo de insercin directa, utilizado cuando el array tiene
un gran nmero de elementos.
En este mtodo no se compara a cada elemento con el de su izquierda, como en el de
insercin, sino con el que est a un cierto nmero de lugares (llamado salto) a su izquierda.
Este salto es constante, y su valor inicial es N/2 (siendo N el nmero de elementos, y
siendo divisin entera). Se van dando pasadas hasta que en una pasada no se intercambie
ningn elemento de sitio. Entonces el salto se reduce a la mitad, y se vuelven a dar pasadas
hasta que no se intercambie ningn elemento, y as sucesivamente hasta que el salto vale 1.
Shell sort es una generalizacin de la ordenacin por insercin, con dos observaciones en
mente:
La ordenacin por insercin es eficiente si la entrada est "casi ordenada".
La ordenacin por insercin es ineficiente, en promedio, porque se mueve valores slo una
posicin a la vez.

Ejemplo:

Algoritmo

ENTERO N+1
Repetir mientras ( ENTERO >1 )
ENTERO parte entera ( ENTERO entre 2) Y BAND VERDADERO
Repetir mientras ( BAN = VERDADERO)
BAND FALSO
i1
Repetir mientras (( i + ENTERO) N)
Si A [ I ] > L[I + ENTERO ] entonces
aux L[I]
L[I] L[I+ENTERO] A[I+ ENTERO] AUX
BAND VERDADER O
Fin del condicional }
Hacer I I + 1
{Fin del paso ciclo }
{Fin del ciclo de paso}
{Fin del ciclo del paso}
(INT, I y AUX son variables de tipo entero Band es una variable de tipo booleano).

INT N+1
Repetir mientras (INT >1)
INT parte entera ( INT entre 2 )
Bandera True
Repetir mientras (Bandera == True)
BAND FALSO
i1
Repetir mientras ( ( i + INT ) N )

Si L [ i ] > L[ i + INT ] entonces

aux L[ i ]
L[ i ] L[ i + INT ]
L[ i + INT ] aux
Bandera True
FinSi
ii+1
FinRepetir
FinRepetir
FinRepetir

Analisis de Eficiencia del Metodo de Shell

No se ha podido establecer hasta el momento la mejor secuencia de incrementos cuando N

es grande.

En l969 Pratt descubri que el tiempo de ejecucin del algoritmo es del orden de n*(log n).

Se mencionar que en unos estudio realizados en la universidad de Stanford en 1971 por

Peterson y Rusell muestran que las mejores secuencia para los valores de N comprendidos
entre 100 y 60 000 son las presentadas a continuacin.

1,3,5,9, ... ,2 +1
1,3,7,15, ... ,2-1
SECUENCIAS 1,3,5,11, ... ,(21)/3
1,4,13,40, ... ,(3-1)/2
Donde = 0,1,2,3,......

5.1.4 Radix
El mtodo de Radix considera la estructura de los elementos a ordenar. La
ordenacin se realiza comparando nmeros o carcter en la misma posicin.

Considera que los datos que sern ordenados estn representados en una Base
B del sistema de nmeros ( B = Base = Radix = Raz)

Si B = 10, el sistema considerado es el decimal.

B = 10 Decimal

(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

B = 2 Binario

(0, 1)

B = 8 Octal

(0, 1, 2, 3, 4, 5, 6, 7)

B = 16 Hexadecimal

Ejemplo:

Ordenacin Radix:

Ordenacin Radix:

Ordenacin Radix:

Si B = 2, los datos a clasificar estn en forma Binaria:

00012 = 110
00102 = 210
00112 = 310
01002 = 410

Datos Iniciales

1ra Columna

2da Columna

Datos Clasificados

5.2. Algoritmos de ordenamiento Externos

5.2.1 Intercalacin
Algoritmo de ordenacin externa, que permite organizar los elementos de un archivo, de
forma ascendente o descendente.
Consiste en leer un registro de cada archivo y compararlos, el menor es almacenando en el
archivo de resultado y el otro se compara con el siguiente elemento del archivo si existe. El
proceso se repite hasta que alguno de los archivos quede vaco y los elementos del otro
archivo se almacenan directamente en el archivo resultado.

Ejemplo:
import java.util.Scanner;
Public class Intercalacion
{
public static void main (String[] args)
{
Scanner dato = new Scanner (System.in);
int n = 0;
System.out.println("Longitud de arreglo: ");

n= dato.nextInt();
int[] arreglo = new int [n];
for (int i=0 ;i<=n-1 ; i++)
{
System.out.println("Elemento [" +i+ "]= ");
arreglo [i]= dato.nextInt();
}

intercalacion (arreglo,n);

for (int i=0 ;i<=n-1 ; i++)

System.out.println("arreglo[i]+", ");
}

public static void intercalacion (int[] x, int n)

{
int[] aux = new int[n];
int tam = 1;

LinfUno = u2 + 1
}

for (i=LinfUno; k<n; i++)

aux[k++] = x[i];

for (i=0 ;i<n ; i++)

x[i] = aux[i];

tam = 2
}

5.2.2 Mezcla Directa

a) Descripcin
Este mtodo de llama mezcla porque combina dos o ms secuencias en una sola secuencia
ordenada por medio de la seleccin repetida de los componentes accesibles en ese
momento.

Un arreglo individual puede usarse en lugar de dos secuencias si se considera como de

doble extremo. En este caso se tomaran elementos de los dos extremos del arreglo para
hacer la mezcla. El destino de los elementos combinados se cambia despus de que cada
par ha sido ordenado para llenar uniformemente las dos secuencias que son el destino.
Despus de cada pasada los dos extremos del arreglo intercambian de papel, la fuente se
convierte en el nuevo destino y viceversa.

b) Algoritmo
1.- Inicio
2.- Dividir la secuencia A en dos mitades denominadas B y C.
3.- Mezclar B y C combinando cada elemento en pares ordenados.
4.- Llamar A la secuencia mezclada y repetir los pasos 1 y 2, esta vez combinando los pares
en cudruples ordenados.
5.- Repetir los pasos anteriores duplicando cada vez la longitud de las secuencias
combinadas hasta que quede ordenada la secuencia original.
6.- Fin del Algoritmo.

Ejemplo:

5.2.3 Mezcla Natural

La mezcla natural o mezcla equilibrada es un algoritmo de ordenacin 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
mxima longitud en lugar de secuencias ordenadas de tamao fijo previamente determinadas, como
la intercalacin directa. Posteriormente se realiza la fusin de esas secuencias ordenadas,
alternndolas entre los dos archivos auxiliares. Repitiendo este proceso, se logra que el archivo
quede completamente ordenado. Para aplicar este algoritmo, se necesitarn cuatro archivos. El
archivo original y tres archivos auxiliares. De estos cuatro archivos, dos sern considerados de
entrada y dos de salida, alternativamente en cada paso del algoritmo. El proceso termina cuando al
finalizar un paso, el segundo archivo de salida quede vaco y el primero queda completamente
ordenado.

Ejemplo: