Algoritmos de Ordenamiento 1 - INTRODUCCION

La ordenacin o clasificacin de datos consiste en la disposicin de los mismos de acuerdo

con algn valor o caracterstica. Por ejemplo, cada elemento de una agenda telefnica tiene

un campo nombre, un campo direccin y un campo nmero telefnico. Por lo regular los

datos en la agenda se encuentran organizados en un orden de la A la Z. De la misma forma

un lista vector de datos se dice:

que esta ordenado de manera ascendente, si X [ i ] = X [ i +1].

El proceso de ordenacin es uno de los mecanismos ms interesantes cuando llega el

momento de mostrar que existen mltiples soluciones para un mismo problema, y que cada

solucin algortmica tiene sus propias ventajas y desventajas.

Los algoritmos de ordenamiento nos permiten, como su nombre dice, ordenar. En este caso,

nos servirn para ordenar vectores o matrices con valores asignados aleatoriamente. Nos

centraremos en los mtodos ms populares, analizando la cantidad de comparaciones que

suceden, el tiempo que demora y revisando el cdigo, escrito en Java, de cada algoritmo.

En esta unidad vamos a conocer ms a fondo cada mtodo de ordenacin, desde el ms

simple hasta el ms complejo. Se realizaran comparaciones en tiempo de ejecucin, pre-

requisitos de cada algoritmo, funcionalidad, alcance, etc.

Como por ejemplo los siguientes mtodos:

ORDENAMIENTO BURBUJA ( BUBBLE SORT)

SELECCION DIRECTA (SELECCION SORT)

INSERCION DIRECTA (INSERTION SORT)

SHELL SORT

MERGE SORT

QUICK SORT

1.1 - Ordenamiento Interno

Los mtodos de ordenamiento interno trabajan en memoria principal y sus

implementaciones son muy variadas, de manera que la eleccin del algoritmo adecuado

debe realizarse con criterios de eficiencia (tiempo y ejecucin) y en funcin de la memoria

disponible. Dividiremos los mtodos en dos grandes grupos:

Directos (burbuja, seleccin e insercin).

Logartmicos (Shell sort, Merge sort, Heap sort, Quick sort, Radix).

En el caso de listas pequeas, los mtodos directos se desempean de manera

relativamente eficientes, ya que la codificacin del algoritmo correspondiente no es

compleja. Su uso es muy frecuente. Sin embargo, en arreglos grandes las ordenaciones

directas resultan ineficientes y se necesitara un mtodo logartmico para su solucin.

2 TIPOS DE ALGORITMOS

Una forma de medir la eficiencia de un algoritmo de esta clase, es verificar el nmero de

comparaciones entre valores clave, adems del nmero de movimientos que se tengan que

realizar entre elementos (intercambios) de la lista.

Los mtodos de ordenamiento que trabajan con estructuras de datos residentes en memoria

principal se denominan Ordenamientos Internos, mientras que las implementaciones que

utilizan estructuras de datos residentes en archivos se conocen como Ordenamientos

externos.

Para poder ordenar una cantidad determinada de nmeros almacenados en un vector o

matriz, existen distintos mtodos (algoritmos) con distintas caractersticas y complejidad.

Existe desde el mtodo ms simple, como el Bubblesort (o Mtodo Burbuja), que son

simples iteraciones, hasta el Quicksort (Mtodo Rpido), que al estar optimizado usando

recursin, su tiempo de ejecucin es menor y es ms efectivo.

2.1 METODOS ITERATIVOS

Estos mtodos son simples de entender y de programar ya que son iterativos, simples ciclos

y sentencias que hacen que el vector pueda ser ordenado.

Dentro de los Algoritmos iterativos encontramos:

Burbuja Insercin Seleccin Shellsort

2.2 - METODOS RECURSIVOS

Estos mtodos son an ms complejos, requieren de mayor atencin y conocimiento para

ser entendidos. Son rpidos y efectivos, utilizan generalmente la tcnica Divide y vencers,

que consiste en dividir un problema grande en varios ms pequeos para que sea ms fcil

resolverlos. Mediante llamadas recursivas a s mismos, es posible que el tiempo de

ejecucin y de ordenacin sea ms ptimo.

Dentro de los algoritmos recursivos encontramos:

Ordenamiento por Mezclas (merge) Ordenamiento Rpido (quick)

3 METODO DE LA BURBUJA

El algoritmo de la burbuja es uno de los mtodos de ordenacin ms conocidos y uno de los

primeros que aprenden los programadores. El mtodo de la burbuja es uno de los ms

sencillos e intuitivos, es tan fcil como comparar todos los elementos de una lista contra

todos, si se cumple que uno es mayor o menor a otro, entonces los intercambia de posicin.

Se basa en la ordenacin por cambio, y recibe su nombre de la semejanza con las burbujas

de un depsito de agua donde cada burbuja busca su propio nivel.

Los pasos a efectuar en el caso de una ordenacin ascendente (en el caso de la ordenacin

descenderte solo habra que cambiar el signo de comparacin) son:

1. Comparar el primer y segundo elemento, intercambiarlos si el primero es mayor que

el segundo; luego se compara el primero con el tercero, intercambindose en caso

necesario, y el proceso se repite hasta llegar al ltimo elemento. De este modo, tras

la primera iteracin la casilla primera conservara el elemento ms pequeo de esa

iteracin.

2. Se repite el paso anterior, pero ahora con el segundo y tercero, en caso de ser

necesario se intercambian, y as hasta llegar a comparar el segundo con el ultimo.

Consiste en comparar pares de elementos adyacentes en un array y si estn desordenanos

intercambiarlos hasta que estn todos ordenados.

Si A es el array a ordenar, se realizan A.length-1 pasadas. Si la variable i es la que cuenta

el nmero de pasadas, en cada pasada i se comprueban los elementos adyacentes desde el

primero hasta A.length-i-1 ya que el resto hasta el final del array estn ya ordenados. Si los

elementos adyacentes estn desordenados se intercambian.

Ejemplo: Imaginemos que tenemos los siguientes valores: 50 26 7 9 15 27

Lo que hara el mtodo burbuja simple, seria comenzar recorriendo los valores de izquierda

a derecha, comenzando por el 50. Lo compara con el 26, con el 7, con el 9, con el 15 y con

el 27, si es mayor o menor (dependiendo si el orden es ascendiente o descendiente) se

intercambian de posicin.

Luego continua con el siguiente, con el 26, y lo compara con todos los elementos de la lista,

esperando ver si se cumple o no la misma condicin que con el primer elemento. As,

sucesivamente, hasta el ltimo elemento de la lista.

Ejemplo de ejecucin:

Ya estn ordenados, pero los dos bucles for seguirn ejecutndose hasta el final. El mtodo

de ordenacin del mtodo burbuja en Java para ordenar un vector o array A es:

public static void Burbuja( int [ ] A ){

int temp;

for(int i=0;i

Observa cmo se declara un vector A de tipo entero que contendr una cantidad n que

ser A.length-1 de casillas, declaramos tambin las variables i y j que nos ayudaran a

desplazarnos entre casilla y casilla para hacer las comparaciones. Y finalmente la variable

temp, almacenara temporalmente el valor a intercambiar entre las casillas que lo necesiten.

El tiempo de ejecucin del algoritmo de la burbuja es del orden O(n2)

3.1 BURBUJA SIMPLE

Como hemos descrito en el apartado anterior, la burbuja ms simple de todas es la que

compara todos con todos, generando comparaciones extras, por ejemplo, no tiene sentido

que se compare con sigo mismo o que se compare con los valores anteriores a l, ya que

supuestamente, ya estn ordenados.

Es uno de los peores algoritmos de ordenacin en cuanto a tiempo de ejecucin, solamente

es recomendable su uso para ordenar listas con un nmero pequeo de elementos.

3.2 - BURBUJA MEJORADA

Una nueva versin del mtodo de la burbuja seria limitando el nmero de comparaciones,

dijimos que era intil que se compare consigo misma. Si tenemos una lista de 10.000

elementos, entonces son 10.000 comparaciones que estn sobrando.

Imaginemos si tenemos 1.000.000 de elementos. El mtodo sera mucho ms ptimo con

n comparaciones menos (n = total de elementos).

Est versin mejorada de dicho algoritmo integra una variable que funge como disparador

(bandera) que permite detectar el momento en que ya no se presenten ms intercambios

aunque su mejora no suele ser tan importante pues el algoritmo sigue comportndose como

una ordenacin cuadrtica O(n2).

Public static void burbuja2(int[ ]v, int n){

bool sw = true;

int temp;

int li = 0;

do {

li++;

sw = true;

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

if ( v[i] > v[i+1] ) { // compara los valores

// intercambia los datos

temp = v[i];

v[i] = v[i+1];

v[i+1] = temp;

sw = false;

}

}

} while(!sw);

}

3.3 - BURBUJA OPTIMIZADA

Si al cambio anterior (el de la burbuja mejorada) le sumamos otro cambio, el hecho que los

elementos que estn detrs del que se est comparando, ya estn ordenados, las

comparaciones serian an menos y el mtodo seria an ms efectivo.

Si tenemos una lista de 10 elementos y estamos analizando el quinto elemento, que sentido

tiene que el quinto se compare con el primero, el segundo o el tercero, si supuestamente,

ya estn ordenados? Entonces optimizamos ms aun el algoritmo, quedando nuestra

versin final del algoritmo optimizado de la siguiente manera:

Public static void Bubblesort( int matriz[ ] ){

int temp;

for (int i = 0; i < matriz.length-1; i++){

for (int j = i+1; j< matriz.lenght; j++){

if (matriz[ i ] > matriz[ j ]){

temp = matriz[ i ];

matriz[ i ] = matriz[ j ];

matriz[ j ] = temp;

}

}

}

}

Ejemplo: Se cuenta con un vector de 6 posiciones donde se inicia una lista de nmeros

{ 7, 2, 8, 3, 5, 1 }, la cual ser ordenada en forma ascendente { 1, 2, 3, 5, 7, 8 }, El

proceso sera de la siguiente manera:

4 INSERCION Y SELECCIN

4.1. - Mtodo de Seleccin

La idea bsica es encontrar el elemento ms pequeo (grande), en orden ascendente de la lista, e intercambiarlo con el elemento que ocupa la primera posicin en la lista, a continuacin se busca el siguiente elemento ms pequeo y se transfiere a la segunda posicin. Se repite el proceso hasta que el ltimo elemento ha sido transferido a su posicin correcta. El algoritmo de ordenacin depende a su vez del algoritmo necesario para localizar el componente mayor (menor) de un array o vector. Es un proceso muy similar al mtodo de la burbuja pero haciendo ms eficiente la bsqueda y evitando intercambios innecesarios. Consideremos el mismo arreglo del ejemplo anterior { 7, 2, 8, 3, 5, 1 }. El proceso sera de la siguiente manera:

Este mtodo de ordenacin de vectores consiste en repetir los siguientes pasos: Se busca el elemento ms pequeo del vector y se coloca en la primera posicin. Entre los restantes, se busca el elemento ms pequeo y se coloca en la segunda posicin. Entre los restantes se busca el elemento ms pequeo y se coloca en la tercera posicin. Este proceso se repite hasta colocar el ltimo elemento.

De forma grfica el proceso sera el siguiente:

El mtodo de ordenacin por seleccin en java para ordenar un vector o array de enteros A

es el siguiente:

//mtodo java de ordenacin por seleccin

public static void seleccion(int A[]) {

int i, j, menor, pos, temp;

for (i = 0; i < A.length - 1; i++) { // tomamos como menor el primero

menor = A[i]; // de los elementos que quedan por ordenar

pos = i; // y guardamos su posicin

for (j = i + 1; j < A.length; j++){ // buscamos en el resto

if (A[j] < menor) { // del array algn elemento

menor = A[j]; // menor que el actual

pos = j;

}

}

if (pos != i){ // si hay alguno menor se intercambia

temp = A[i];

A[i] = A[pos];

A[pos] = temp;

}

}

}

Otro mtodo:

Public static void seleccion( int[] v){

/* ordenamiento de seleccion */

int k=0;

for (int i = 0; i < v.length-1; i++) {

k = i;

for (int j = i+1; j < v.length; j++)

if ( v[k] > v[j] ) k = j;

int temp = v[i];

v[i] = v[k];

v[k] = temp;

}

}

El tiempo de ejecucin del algoritmo de ordenacin por seleccin es del orden O(n2)

4.2. - Mtodo de Insercin

Este mtodo tambin se denomina mtodo del jugador de cartas, por la semejanza con la

forma de clasificar las cartas de una baraja, insertando cada carta en el lugar adecuado.

El algoritmo ordena los dos primeros elementos de la lista, a continuacin el tercer

elemento se inserta en la posicin que corresponda, el cuarto se inserta en la lista de tres

elementos, y as sucesivamente.

Este proceso continua hasta que la lista este totalmente ordenada.

Sea una lista A[1], A[2], ... A[n]. Los pasos a dar para una ordenacin ascendente son:

1. Ordenar A[1] y A[2].

2. Comparar A[3] con A[2], si A[3] es mayor o igual a que A[2], sigue con el siguiente

elemento si no se compara A[3] con A[1]; si A[3] es mayor o igual que A[1], insertar

A[3] entre A[1] yA[2]. Si A[3] es menor que A[1], entonces transferir A[3] a A[1],

A[1] a A[2] y A[2] a A[3].

3. Se suponen ordenados los n-1 primeros elementos y corresponde insertar el n-simo

elemento. Si A[m] es mayor que A[k] (con K = 1, 2, ..., m-1), se debe correr una

posicin A[k+1], ... A[m-1] y almacenar A[m] en la posicin k+1.

Consideremos el mismo arreglo del ejemplo anterior { 7, 2, 8, 3, 5, 1 }. El proceso sera de

la siguiente manera:

Public static void insercion( int[] v){

/* ordenamiento de insercion */

int j=0,temp;

for (int i = 1; i < v.length; i++) {

temp = v[i];

j = i - 1;

while ( j >= 0 && temp < v[j]) {

v[j+1] = v[j];

j--;

}

v[j+1] = temp;

}

}

4.3. - Mtodo Insercin y Seleccin

Public static void Insercion (int[] matrix){

int temp, j;

for (int i = 1; i < matrix.length; i++) {

temp = matrix[i];

j = i - 1;

while ( (matrix[j] > temp) && (j >= 0) ){

matrix[j + 1] = matrix[j];

j--;

}

matrix[j + 1] = temp;

}

}

Public static void Seleccion (int[] matrix){

int j, p, buffer, limit = matrix.length-1;

for (int k = 0; k < limit; k++){

p = k;

for (int i = k+1; i

5 ORDENAMIENTO POR MEZCLA

Fue desarrollado en 1945 por John Von Neumann. Conceptualmente, el ordenamiento por

mezcla funciona de la siguiente manera:

1. Si la longitud de la lista es 0 1, entonces ya est ordenada. En otro caso:

2. Dividir la lista desordenada en dos sublistas de aproximadamente la mitad del tamao.

3. Ordenar cada sublista recursivamente aplicando el ordenamiento por mezcla.

4. Mezclar las dos sublistas en una sola lista ordenada.

El ordenamiento por mezcla incorpora dos ideas principales para mejorar su tiempo de

ejecucin:

Una lista pequea necesitar menos pasos para ordenarse que una lista grande.

Se necesitan menos pasos para construir una lista ordenada a partir de dos listas

tambin ordenadas, que a partir de dos listas desordenadas.

Por ejemplo, slo ser necesario entrelazar cada lista una vez que estn ordenadas.

A continuacin se describe el algoritmo en pseudocdigo (se advierte de que no se incluyen

casos especiales para vectores vacos, una implementacin en un lenguaje de programacin real debera tener en cuenta estos detalles):

funcion merge_sort( list m )

if length(m) 1 return m

var list left, right, result

var integer middle = length(m) / 2

for each x in m up to middle

add x to left

for each x in m after middle

add x to right

left = merge_sort(left)

right = merge_sort(right)

result = merge(left, right)

return result

funcion merge( list left, right)

var list result

while length(left) > 0 or length(right) > 0

if length(left) > 0 and length(right) > 0

if first(left) first(right) append first(left) to result

left = rest(left)

else

append first(right) to result

right = rest(right)

else if length(left) > 0

append first(left) to result

left = rest(left)

else if length(right) > 0

append first(right) to result

right = rest(right)

end while

return result

Este algoritmo consiste bsicamente en dividir en partes iguales la lista de nmeros y luego

mezclarlos comparando y dejandolos ordenados.

Si se piensa en este algoritmo recursivamente, podemos imaginar que dividir la lista hasta

tener un elemento en cada lista, luego lo compara con el que est a su lado y segn

corresponda, lo sita donde corresponde.

En la siguiente figura podemos ver cmo funciona:

Ejemplo: Tenemos una lista { 5, 2, 4, 6, 1, 3, 2, 6 }, la lista es dividida en la primera de

las dos llamadas a merge con { 5, 2, 4, 6 }, despus nuevamente es dividida en { 5, 2 },

se intercala obteniendo { 2, 5 }, la segunda llamada recupera { 4, 6 } y se intercalan para

obtener { 2, 4, 5, 6 }. Con la mitad { 1, 3, 2, 6 } ocurre la misma reduccin de elementos

tras las llamadas intercalando finalmente la salida para obtener { 1, 2, 2, 3, 4, 5, 6, 6 }.

El algoritmo de ordenamiento por mezcla (Mergesort) se divide en dos procesos, primero se

divide en partes iguales la lista:

public static void mergesort (int[ ] matrix, int init, int n){

int n1, n2;

if (n > 1){

n1 = n / 2;

n2 = n - n1;

mergesort(matrix, init, n1);

mergesort(matrix, init + n1, n2);

merge(matrix, init, n1, n2);

}

}

Y el algoritmo que nos permite mezclar los elementos segn corresponda:

private static void merge(int[ ] matrix, int init, int n1, int n2){

int[ ] buffer = new int[n1+n2];

int temp = 0;

int temp1 = 0;

int temp2 = 0;

int i;

while ((temp1 < n1) && (temp2 < n2)){

if (matrix[init + temp1] < matrix[init + n1 + temp2])

buffer[temp++] = matrix[init + (temp1++)];

else

buffer[temp++] = matrix[init + n1 + (temp2++)];

}

while (temp1 < n1) buffer[temp++] = matrix[init + (temp1++)];

while (temp2 < n2) buffer[temp++] = matrix[init + n1 + (temp2++)];

for (i = 0; i < n1+n2; i++) matrix[init + i] = buffer[i];

}

6 METODO SHELLSORT Shellsort lleva este nombre en honor a su inventor, Donald Shell, que lo public en 1959. La

idea bsica de este mtodo es distribuir el arreglo de manera que se genere una matriz de

valores donde cada elemento es comparado de manera adyacente empleando un

mecanismo de insercin directa simple, dicho rango que genera grupos de manera matricial

que es reducido gradualmente hasta estabilizarse en un valor uniforme de 1.

En el mtodo de ordenacin por insercin directa es empleado en cada subgrupo de manera

que cada elemento se compara para su ubicacin correcta en el arreglo con los elementos

que se encuentran en su parte izquierda. Si el elemento a insertar es ms pequeo que el

grupo de elementos que se encuentran a su izquierda, ser necesario efectuar varias

comparaciones antes de su ubicacin.

Shell propone que las comparaciones entre elementos se efecten con saltos de mayor

tamao, pero con incrementos decrecientes; as, los elementos quedaran ordenados ms

rpidamente.

El algoritmo para Shellsort sera el siguiente. Algunos autores suponen una secuencia

geomtrica de decremento (2.2) que permite una distribucin presumiblemente ms

razonable para el acomodo de los grupos de elementos a comparar.

El algoritmo emplea un arreglo a de 0 a n-1:

inc = round(n/2)

mientras inc > 0 {

para i = inc hasta n 1 { temp = a[i]

j = i

mientras j = inc && a[j - inc] > temp {

a[j] = a[j - inc]

j = j inc }

a[j] = temp

}

inc = round(inc / 2.2)

}

Ejemplo: tenemos una lista de nmeros como 13 14 94 33 82 25 59 94 65 23 45 27 73 25

39 10. Si comenzamos con un tamao de paso de 5, podramos visualizar esto dividiendo la

lista de nmeros en una tabla con 5 columnas. Esto quedara:

Este mtodo es una mejora del algoritmo de ordenamiento por Insercin (Insertsort).Si

tenemos en cuenta que el ordenamiento por insercin es mucho ms eficiente si nuestra

lista de nmeros esta semi-ordenada y que desplaza un valor una nica posicin a la vez.

Durante la ejecucin de este algoritmo, los nmeros de la lista se van casi-ordenando y

finalmente, el ltimo paso o funcin de este algoritmo es un simple mtodo por insercin

que, al estar casi-ordenados los nmeros, es ms eficiente.

public void shellSort(int[] matrix){

for ( int increment = matrix.length / 2; increment > 0; increment =

(increment == 2 ? 1 : (int) Math.round(increment / 2.2))){

for (int i = increment; i < matrix.length; i++){

for (int j = i; j >= increment && matrix[j - increment] >

matrix[j]; j -= increment){

Int temp = matrix[j];

matrix[j] = matrix[j - increment];

matrix[j - increment] = temp;

}

}

}

}

Otro Mtodo:

void shell_sort(int[] A){

int j, temp;

int incremnt = A.length/2;

while (incremnt > 0) {

for (int i = incremnt; i < size; i++) {

j = i;

temp = A[i];

while ((j >= incremnt) && (A[j-incremnt] > temp)) {

A[j] = A[j - incremnt];

j = j - incremnt;

}

A[j] = temp;

}

incremnt /= 2;

}

}

7 - METODO RAPIDO (quicksort)

El mtodo de ordenacin Quicksort fue desarrollado por Hoare en el ao 1960.

Es el algoritmo de ordenacin ms rpido. Se basa en la tcnica divide y vencers, que

consiste en ir subdividiendo el array en arrays ms pequeos, y ordenar stos. Para hacer

esta divisin, se toma un valor del array como pivote, y se mueven todos los elementos

menores que este pivote a su izquierda, y los mayores a su derecha. A continuacin se

aplica el mismo mtodo a cada una de las dos partes en las que queda dividido el array.

Despus de elegir el pivote se realizan dos bsquedas:

Una de izquierda a derecha, buscando un elemento mayor que el pivote

Otra de derecha a izquierda, buscando un elemento menor que el pivote.

Cuando se han encontrado los dos elementos anteriores, se intercambian, y se sigue

realizando la bsqueda hasta que las dos bsquedas se encuentran.

La implementacin del mtodo de ordenacin Quicksort es claramente recursiva.

Suponiendo que tomamos como pivote el primer elemento, el mtodo Java Quicksort que

implementa este algoritmo de ordenacin para ordenar un array de enteros se presenta a

continuacin. Una vez dividida, lo que hace, es dejar todos los mayores que el pivote a su

derecha y todos los menores a su izq. Al finalizar el algoritmo, nuestros elementos estn

ordenados.

Es un algoritmo relativamente eficiente y representa una mejora sustancial al mtodo de

intercambio directo.

El algoritmo es el siguiente:

1. Elegir un elemento de la lista de elementos a ordenar (pivote).

2. Resituar los dems elementos de la lista a cada lado del pivote, de manera que a un

lado queden todos los menores que l, y al otro los mayores. Los elementos iguales

al pivote pueden ser colocados tanto a su derecha como a su izquierda, dependiendo

de la implementacin deseada. En este momento, el pivote ocupa exactamente el

lugar que le corresponder en la lista ordenada.

3. La lista queda separada en dos sub-listas, una formada por los elementos a la

izquierda del pivote, y otra por los elementos a su derecha.

4. Repetir este proceso de forma recursiva para cada sub-lista mientras stas

contengan ms de un elemento. Una vez terminado este proceso todos los

elementos estarn ordenados.

Como se puede suponer, la eficiencia del algoritmo depende de la posicin en la que

termine el pivote elegido. En el mejor caso, el pivote termina en el centro de la lista,

dividindola en dos sublistas de igual tamao. En este caso, el orden de complejidad del

algoritmo es O(n log n).

En el peor caso, el pivote termina en un extremo de la lista. El orden de complejidad del

algoritmo es entonces de O(n). El peor caso depender de la implementacin del

algoritmo, aunque habitualmente ocurre en listas que se encuentran ordenadas, o casi

ordenadas. Pero principalmente depende del pivote, por ejemplo el algoritmo implementado

toma como pivote siempre el primer elemento del arreglo, y el arreglo que le pasamos est

ordenado, siempre va a generar a su izquierda un arreglo vaco, lo que es ineficiente.

La eleccin del pivote determinar la eficiencia de este algoritmo ya que determina la

particin del array. Si consideramos que el array est desordenado, podemos elegir el

primer elemento y el algoritmo funcionara de forma eficiente. Pero si el array est casi

ordenado, elegir el primer elemento como pivote sera una mala solucin ya que

obtendramos un subarray muy pequeo y otro muy grande. Por la misma razn, elegir el

ltimo elemento del array como pivote tambin es una mala idea. Pretendemos conseguir

que el tamao de los subarrays sea lo ms parecido posible.

Una alternativa a elegir el primer elemento es elegir como pivote un elemento al azar de

entre todos los del array.

Otra estrategia es calcular la mediana de los valores de la izquierda, centro y derecha del

vector.

Ejemplo1: Para el vector: 9 8 1 6 10 2 3, se calcula la mediana de los elementos que

ocupan el primer lugar, el ltimo y el centro o sea 9 3 6. La mediana es 6 que determinara

las particiones {1 3 2} {6} {8 10 9}.

Ejemplo2: Si tenemos 3 5 4 8 bsicamente lo que hace el algoritmo es dividir la lista de 4

elementos en partes iguales, por un lado 3, por otro lado 4 8 y como comodin o pivote el 5.

Luego pregunta, 3 es mayor o menor que el comodin? Es menor, entonces lo deja al lado

izq. Y como se acabaron los elementos de ese lado, vamos al otro lado. 4 Es mayor o menor

que el pivote? Menor, entonces lo tira a su izq. Luego pregunta por el 8, al ser mayor lo

deja donde esta, quedando algo asi: 3 4 5 8

Ejemplo3: Se marcan el pivote y los ndices i y j con las letras p,i y j respectivamente:

De forma grfica el proceso sera el siguiente:

El algoritmo es el siguiente:

public void Quicksort(int matrix[], int a, int b){

this.matrix = new int[matrix.length];

int buf;

int from = a;

int to = b;

int pivot = matrix[(from+to)/2];

do{

while(matrix[from] < pivot){

from++;

}

while(matrix[to] > pivot){

to--;

}

if(from

Otro mtodo:

public static void quicksort(int A[], int izq, int der) {

int pivote=A[izq]; // tomamos primer elemento como pivote

int i=izq; // i realiza la bsqueda de izquierda a derecha

int j=der; // j realiza la bsqueda de derecha a izquierda

int aux;

while(i

9 COMPARACION DE TIEMPOS Se han ordenado una cantidad determinada de elementos aleatorios en una lista mediante

distintos mtodos de ordenamiento. (en segundos)

Como podemos analizar, el algoritmo que se va demorando cada vez ms tiempo es el de la

burbuja, luego de seleccin y tercero el insercin. Los algoritmos que los siguen son el Shell

y el de ordenacin por mezcla, pero el ms ptimo es el Rapido o Quicksort.

10 ORDENACION BASADA EN COMPARACIONES (HeapSort)

El ordenamiento por montculos(Heapsort), es una variante del algoritmo de seleccin, el

cual es un algoritmo de ordenacin no recursivo, no estable, con complejidad computacional

O(n log n).

Este algoritmo consiste en almacenar todos los elementos del vector a ordenar en un

montculo (heap), y luego extraer el nodo que queda como nodo raz del montculo (cima)

en sucesivas iteraciones obteniendo el conjunto ordenado. Basa su funcionamiento en una

propiedad de los montculos, por la cual, la cima contiene siempre el menor elemento (o el

mayor, segn se haya definido el montculo) de todos los almacenados en l.

El significado de heap en computacin es el de una cola de prioridades (priority queue).

Tiene las siguientes caractersticas:

Un heap es un arreglo de n posiciones ocupado por los elementos de la cola.

Se mapea un rbol binario de tal manera en el arreglo que el nodo en la posicin i es

el padre de los nodos en las posiciones (2*i) y (2*i+1).

El valor en un nodo es mayor o igual a los valores de sus hijos. Por consiguiente, el

nodo padre tiene el mayor valor de todo su subrbol.

Heap Sort consiste esencialmente en:

convertir el arreglo en un heap.

construir un arreglo ordenado de atrs hacia adelante (mayor a menor) repitiendo los siguientes pasos:

o sacar el valor mximo en el heap (el de la posicin 1)

o poner ese valor en el arreglo ordenado

o reconstruir el heap con un elemento menos

utilizar el mismo arreglo para el heap y el arreglo ordenado.

11 ORDENAMIENTO EXTERNO

La ordenacin de archivos se lleva a cabo cuando el volumen de los datos a tratar es

demasiado grande y los mismos no caben en la memoria principal de la computadora.

Al ocurrir esta situacin no pueden aplicarse los mtodos de ordenacin interna, de modo

que debe pensarse en otro tipo de algoritmos para ordenar datos almacenados en archivos.

Por ordenacin de archivos se entiende, entonces, la ordenacin o clasificacin de stos,

ascendente o descendentemente, de acuerdo con un campo determinado al que se

denominar campo clave. La principal desventaja de esta ordenacin es el tiempo de

ejecucin, debido a las sucesivas operaciones de entrada y salida.

Los dos mtodos de ordenacin externa ms importantes son los basados en la mezcla

directa y en la mezcla equilibrada.

11.1. ORDENACIN POR MEZCLA DIRECTA

El mtodo de ordenacin por mezcla directa es probablemente el ms utilizado por su fcil

comprensin.

La idea central de este algoritmo consiste en la realizacin sucesiva de una particin y una

fusin que produce secuencias ordenadas de longitud cada vez mayor. En la primera pasada

la participacin es de longitud 1 y la fusin o mezcla produce secuencias ordenadas de

longitud 4.

Este proceso se repite hasta que la longitud de la secuencia para la particin sea mayor o

igual que la longitud de la secuencia para la particin sea mayor o igual que el nmero de

elementos del archivo original.

Ejemplo: Supngase que se desean ordenar las claves del archivo F. Para realizar tal

actividad se utilizan dos archivos auxiliares a los que se les denominar F1 y F2.

F: 09 75 14 68 29 17 31 25 04 05 13 18 72 46 61

PRIMERA PASADA

Particin en secuencias de longitud 1.

F1: 09 14 29 31 04 13 72 61

F2: 75 68 17 25 05 18 46

Fusin en secuencias de longitud 2.

F1: 09 75 14 68 17 29 25 31 04 05 13 18 46 72 61

SEGUNDA PASADA

Particin en secuencias de longitud 2.

F1: 09 75 17 29 04 05 46 72

F2: 14 68 25 31 13 18 61

Fusin en secuencias de longitud 4.

F1: 09 14 68 75 17 25 29 31 04 05 13 18 46 61 72

TERCERA PASADA

Particin en secuencias de longitud 4.

F1: 09 14 68 75 04 05 13 18

F2: 17 25 29 31 46 61 72

Fusin en secuencias de longitud 8.

F1: 09 14 75 25 29 31 68 75 04 05 13 18 46 61 72

CUARTA PASADA

Particin en secuencias de longitud 8.

F1: 09 14 17 25 29 31 68 75

F2: 04 05 13 18 46 61 72

Fusin en secuencias de longitud 16.

F1: 04 05 09 13 14 17 18 25 29 31 46 61 68 72 75

11.2 ORDENACIN POR MEZCLA EQUILIBRADA

El mtodo de ordenacin por mezcla equilibrada, conocido tambin con el nombre de mezcla

natural, es una optimizacin del mtodo de mezcla directa.

La idea central de este mtodo consiste en realizar las particiones tomando secuencias

ordenadas de mxima longitud en lugar de secuencias de tamao fijo previamente

determinadas.

Luego realiza la fusin de las secuencias ordenadas, alternativamente sobre dos archivos

aplicando estas acciones en forma repetida se lograra que el archivo original quede

ordenado.

Para la realizacin de este proceso de ordenacin se necesitaran cuatro archivos. El archivo

original F y tres archivos auxiliares a los que se denominaran F1, F2 y F3. De estos

archivos, dos sern considerados de entrada y dos de salida; esto, alternativamente, con el

objeto de realizar la fusin-particin. El proceso termina cuando en la realizacin de una

fusin-particin el segundo archivo quede vaco.

Ejemplo: Suponga que se desean ordenar las claves del archivo F utilizando el mtodo de

mezcla equilibrada.

F: 09 75 14 68 29 17 31 25 04 05 13 18 72 46 61

Los pasos que se realizan son los siguientes:

PARTICIN INICIAL

F2: 09 75 29 25 46 61

F3: 14 68 17 31 04 05 13 18 72

PRIMERA FUSION-PARTICION

F: 09 14 68 75 04 05 13 18 25 46 61 72

F1: 17 29 31

SEGUNDA FUSION-PARTICION

F2: 09 14 17 29 31 68 75

F3: 04 05 13 18 25 46 61 72

TERCERA FUSION-PARTICION

F: 04 05 09 13 14 17 18 25 29 31 46 61 68 72 75

F1:

Obsrvese que al realizar la tercera fusin-particin el segundo archivo queda vaci, por lo

que se puede afirmar que el archivo ya se encuentra ordenado.

12 EJEMPLOS EN FLASH Aplicaciones Flash de ejemplo para estos mtodos de ordenacin:

SELECCION DIRECTA (SELECCION SORT)

http://aniei.org.mx/paginas/uam/CursoPoo/Recursos/SelectionSort.swf

http://aniei.org.mx/paginas/uam/CursoPoo/curso_poo_SelectionSort.html

INSERCION DIRECTA (INSERTION SORT)

http://aniei.org.mx/paginas/uam/CursoPoo/Recursos/InsertionSort.swf

http://aniei.org.mx/paginas/uam/CursoPoo/curso_poo_InsertionSort.html

QUICK SORT

http://aniei.org.mx/paginas/uam/CursoPoo/curso_poo_QuickSort.html

SHELL SORT

http://aniei.org.mx/paginas/uam/CursoPoo/curso_poo_ShellSort.html

ORDENAMIENTO BURBUJA( BUBBLE SORT)

http://aniei.org.mx/paginas/uam/CursoPoo/curso_poo_BubbleSort.html