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]
y, por otro lado, se dice:
que esta ordenado de manera descendente s 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, prerequisitos 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<A.length-1;i++)
for(int j=0;j<A.length-i-1;j++)
if(A[ j ] > A[ j+1 ]){
temp=A[ j ];
A[ j ]=A[ j+1 ];
A[ j+1 ]=temp;
}
}

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(n 2)

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 <= limit; i++)
if (matrix[i] < matrix[p]) p = i;
if (p != k){
buffer = matrix[p];
matrix[p] = matrix[k];
matrix[k] = buffer;
}
}
}
El bucle principal de la ordenacin por insercin va examinando sucesivamente todos los
elementos de la matriz desde el segundo hasta el n-esimo, e inserta cada uno en el lugar
adecuado entre sus precedesores dentro de la matriz.
La ordenacin por seleccin funciona seleccionando el menor elemento de la matriz y
llevando lo al principio; a continuacin selecciona el siguiente menor y lo pone en la
segunda posicin de la matriz y as sucesivamente.

5 ORDENAMIENTO POR MEZCLA

Fue desarrollado en 1945 por John Von Neumann. Conceptualmente, el ordenamiento por
mezcla funciona de la siguiente manera:
1.
2.
3.
4.

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

Dividir la lista desordenada en dos sublistas de aproximadamente la mitad del tamao.
Ordenar cada sublista recursivamente aplicando el ordenamiento por mezcla.
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 <= to){
buf = matrix[from];
matrix[from] = matrix[to];
matrix[to] = buf;
from++;
to--;
}
}while(from <= to);
if(a < to){
Quicksort(matrix, a, to);
}
if(from < b){
Quicksort(matrix, from, b);
}
this.matrix = matrix;
}
El mtodo ordena un array A d eenteros desde la posicin izq hasta la posicin der. En la
primera llamada recibir los valores izq = 0, der = ELEMENTOS-1.

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

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

i=izq; // i realiza la bsqueda de izquierda a derecha
j=der; // j realiza la bsqueda de derecha a izquierda
aux;

while(i<j){
// mientras no se crucen las bsquedas
while(A[i]<=pivote && i<j) i++; // busca elemento mayor que pivote
while(A[j]>pivote) j--;
// busca elemento menor que pivote
if (i<j) {
// si no se han cruzado
aux= A[i];
// los intercambia
A[i]=A[j];
A[j]=aux;
}
}
A[izq]=A[j]; // se coloca el pivote en su lugar de forma que tendremos
A[j]=pivote; // los menores a su izquierda y los mayores a su derecha
if(izq<j-1)
quicksort(A,izq,j-1); // ordenamos subarray izquierdo
if(j+1 <der)
quicksort(A,j+1,der); // ordenamos subarray derecho
}
8 COMPLEJIDAD
Cada algoritmo de ordenamiento por definicin tiene operaciones y clculos mnimos y
mximos que realiza (complejidad), a continuacin una tabla que indica la cantidad de
clculos que corresponden a cada mtodo de ordenamiento:

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