Vous êtes sur la page 1sur 10

ORDENAMIENTO

1. Burbuja
El algoritmo de la burbuja es uno de los mtodos de ordenacin ms conocidos y
uno
de
los
primeros
que
aprenden
los
programadores.
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.
El mtodo de ordenacin de la burbuja en java para ordenar un array A es el
siguiente:
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;
}
}
Ejemplo de ejecucin:

Ya estn ordenados, pero los dos bucles for seguirn ejecutndose hasta el final.
El tiempo de ejecucin del algoritmo de la burbuja es del orden O(n2)
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.

2. Seleccin

Algoritmo
de
ordenamiento
por
Seleccin
(Selection
Sort
en ingls): Consiste en encontrar el menor de todos los elementos del arreglo
o vector e intercambiarlo con el que est en la primera posicin. Luego el
segundo mas pequeo, y as sucesivamente hasta ordenarlo todo. Su
implementacin requiere O(n2) comparaciones e intercambios para ordenar
una secuencia de elementos.

Descripcin
Este algoritmo mejora ligeramente el algoritmo de la burbuja. En el caso de
tener que ordenar un vector de enteros, esta mejora no es muy sustancial, pero
cuando hay que ordenar un vector de estructuras ms complejas, la operacin
de intercambiar los elementos sera ms costosa en este caso. Su
funcionamiento se puede definir de forma general como:

Buscar el mnimo elemento entre una posicin i y el final de la lista

Intercambiar el mnimo con el elemento de la posicin i

As, se puede escribir el siguiente pseudocdigo para ordenar una lista de n


elementos indexados desde el 1:
para i=1 hasta n-1;
minimo = i;
para j=i+1 hasta n
si lista[j] < lista[minimo] entonces
minimo = j
fin si
fin para

intercambiar(lista[i], lista[minimo])

fin para

Ejemplo
El arreglo a ordenar es a = ['a','s','o','r','t','i','n','g','e','x','a','m','p','l','e']. Se
empieza por recorrer el arreglo hasta encontrar el menor elemento. En este
caso el menor elemento es la primera 'a'. De manera que no ocurre ningn
cambio. Luego se procede a buscar el siguiente elemento y se encuentra la
segunda 'a'. Esta se intercambia con el dato que est en la segunda posicin,
la 's', quedando el arreglo as despus de dos recorridos: a =
['a','a','o','r','t','i','n','g','e','x','s','m','p','l','e']. El siguiente elemento, el tercero en
orden de menor mayor es la primera 'e', la cual se intercambia con lo que est
en la tercera posicin, o sea, la 'o'. Le sigue la segunda 's', la cual es
intercambiada con la 'r'. El arreglo ahora se ve de la siguiente manera: a =
['a','a','e','e','t','i','n','g','o','x','s','m','p','l','r']. De esta manera se va buscando el
elemento que debe ir en la siguiente posicin hasta ordenar todo el arreglo.

Implementacin
A continuacin se muestra el Ordenamiento por Seleccin en algunos de los
lenguajes de programacin de alto nivel ms usados:
Java void selecccion(int[] a) {
for (int i = 0; i < a.length - 1; i++)
{
int min = i;
for (int j = i + 1; j < a.length; j++)
{
if (a[j] < a[min])
{
min = j;
}
}
if (i != min)

{
int aux= a[i];
a[i] = a[min];
a[min] = aux;
}
}}

3. Insercin
El mtodo de ordenacin por insercin directa consiste en recorrer todo el array
comenzando desde el segundo elemento hasta el final. Para cada elemento, se trata
de colocarlo en el lugar correcto entre todos los elementos anteriores a l o sea
entre los elementos a su izquierda en el array.
Dada una posicin actual p, el algoritmo se basa en que los elementos A[0],
A[1], ..., A[p-1] ya estn ordenados.
De forma grfica el proceso que sigue el mtodo de insercin directa es el
siguiente:

El mtodo de Ordenamiento por insercin directa en Java es el siguiente:


public static void insercionDirecta(int A[]){
int p, j;
int aux;
for (p = 1; p < A.length; p++){ // desde el segundo elemento hasta
aux = A[p]; // el final, guardamos el elemento y
j = p - 1; // empezamos a comprobar con el anterior
while ((j >= 0) && (aux < A[j])){ // mientras queden
posiciones y el
// valor de aux sea menor que
los

A[j + 1] = A[j];

// de la izquierda, se

desplaza a
j--;
// la derecha
}
A[j + 1] = aux; // colocamos aux en su sitio
}
}
En el peor de los casos, el tiempo de ejecucin en O(n2).
En el mejor caso (cuando el array ya estaba ordenado), el tiempo de ejecucin de
este mtodo de ordenamiento es O(n).
El caso medio depender de cmo estn inicialmente distribuidos los elementos.
Cuanto ms ordenada est inicialmente ms se acerca a O(n) y cuanto ms
desordenada, ms se acerca a O(n2).
El peor caso el mtodo de insercin directa es igual que en los mtodos de burbuja
y seleccin, pero el mejor caso podemos tener ahorros en tiempo de ejecucin

4. Shell
El mtodo de ordenacin Shell debe su nombre a su inventor, Donald Shell, y fue
uno de los primeros algoritmos de ordenamiento en romper la barrera del tiempo
cuadrtico.
Es una mejora del mtodo de insercin directa, utilizado cuando el array tiene
un gran nmero de elementos.
Cualquier algoritmo de ordenacin que intercambia elementos adyacentes (como
los algoritmos burbuja, seleccin o insercin) tiene un tiempo promedio de
ejecucin de orden cuadrtico (n2). El mtodo Shell mejora este tiempo
comparando cada elemento con el que est a un cierto nmero de posiciones
llamado salto, en lugar de compararlo con el el que est justo a su lado. 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 con el mismo salto 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.
El mtodo Shell de ordenacin en Java para ordenar un array A de enteros es el
siguiente:
public static void shell(int A[]){
int salto, aux, i;
boolean cambios;
for(salto=A.length/2; salto!=0; salto/=2){
cambios=true;
while(cambios){ // Mientras se intercambie algn elemento
cambios=false;

for(i=salto; i< A.length; i++) // se da una pasada


if(A[i-salto]>A[i]){ // y si estn desordenados
aux=A[i]; // se reordenan
A[i]=A[i-salto];
A[i-salto]=aux;
cambios=true; // y se marca como cambio.
}
}
}
}
Ejemplo de ejecucin:

Con slo 6 intercambios se ha ordenado el array, cuando por insercin se


necesitaban muchos ms. El rendimiento del mtodo Shell de ordenacin es
bastante aceptable, an para el caso de un nmero de elementos muy grande. Se
ha comprobado que el tiempo de ejecucin promedio es de O(n2/3) para la
mayora de las secuencias de salto

5. Quisk sourt

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
irsubdividiendo 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 loselementos 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. Los parmetros izq y der son el primer y ltimo
elemento del array a tratar en cada momento.
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.
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<j){

// mientras no se crucen las bsquedas

while(A[i]<=pivote && i<j) i++; // busca elemento mayor que pivote


while(A[j]>pivote) j--;
if

(i<j)

// busca elemento menor que pivote


// si

no

se

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
}

De forma grfica el proceso sera el siguiente:

han

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.
Por ejemplo 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}.
En el peor caso, cuando el pivote es el elemento menor del array el tiempo
de ejecucin del mtodo Quicksort es O(n2).
En general el tiempo medio de ejecucin del Quicksort es O(n log n).

BSQUEDA
1. Bsqueda binaria
uno de los requisitos para el algoritmo de bsqueda binaria es que los datos esten
previamente ordenados.
Este algoritmo se utiliza cuando el vector en el que queremos determinar la existencia
de un elemento est previamente ordenado. El algoritmo reduce el tiempo de
bsqueda considerablemente, ya que disminuye exponencialmente el nmero de
iteraciones necesarias (wikipedia).
Para implementar este algoritmo se compara el elemento a buscar con un elemento
cualquiera del array (normalmente el elemento central): si el valor de ste es mayor
que el del elemento buscado se repite el procedimiento en la parte del array que va
desde el inicio de ste hasta el elemento tomado, en caso contrario se toma la parte
del array que va desde el elemento tomado hasta el final. De esta manera obtenemos
intervalos cada vez ms pequeos, hasta que se obtenga un intervalo indivisible. Si el
elemento no se encuentra dentro de este ltimo entonces se deduce que el elemento
buscado no se encuentra en todo el array (wikipedia).

import java.util.Arrays;

public class binary_search {


public static void main(String[] args) {
int num[]={75,2,44,56,66,83,90,23,66};
int posicion, buscar=83;

// Buscamos la posicion del primer valor


// Si el array no esta ordenado nos puede dar un valor erroneo
posicion=Arrays.binarySearch(num, buscar);
System.out.println("Array no ordenado. Encontrado en el indice:
"+posicion);

// Ordenamos el array
Arrays.sort(num);

// Buscamos la posicion del primer valor


posicion=Arrays.binarySearch(num, buscar);

System.out.println("Array ordenado. Encontrado en el indice:


"+posicion);
}
}