Algoritmos de ordenamiento en arreglos.

Ordenamiento por Burbuja

Es probablemente el mtodo ms conocido entre los estudiantes y principiantes. Es de fcil comprensin y
programacin pero es probablemente el menos eficiente que existe. Este mtodo est dentro de la
categora de los mtodos de ordenacin por intercambio. Si se hace un estudio de la eficiencia de acuerdo al
nmero de comparaciones que se realizan con ste mtodo se llegar a:


C = (n
2
n)
El nmero de intercambios es cero en el mejor de los casos, en una lista ya ordenada. Los nmeros de
intercambios para el caso medio y para el caso peor son respectivamente:

M
prom
= (n
2
n)
M
max
= 3/2 (n
2
n)
Por lo anterior se dice que el mtodo de Ordenamiento de la Burbuja es de orden n
2
(O(n
2
)). El algoritmo en
C es el siguiente:

Burbuja(a,n)
{
int i,k,aux;
for (k=0; k<n-1; k++)
for (i=n-2; i>=k; i--)
if(a[i] > a[i+1])
{
aux = a[i];
a[i] = a[i+1];
a[i+1] = aux;
}}
El ordenamiento por seleccin (Selection Sort en ingls) es un algoritmo de ordenamiento que requiere O
operaciones para ordenar una lista de n elementos.
Su funcionamiento es el siguiente:
Buscar el mnimo elemento de la lista
Intercambiarlo con el primero
Buscar el siguiente mnimo en el resto de la lista
Intercambiarlo con el segundo
Y en general:
Buscar el mnimo elemento entre una posicin i y el final de la lista
Intercambiar el mnimo con el elemento de la posicin i
De esta manera se puede escribir el siguiente pseudocdigo para ordenar una lista de n elementos
indexados desde el 1: Ejemplo de seleccin.
for (i=0; i<TAM - 1; i++)
pos_menor = Menor (A, TAM, i);
temp = A[i];
A[i] = A [pos_menor];
A [pos_menor] = temp;

Ordenamiento por insercion
El ordenamiento por insercin (insertion sort en ingls) es una manera muy natural de ordenar para un ser
humano, y puede usarse fcilmente para ordenar un mazo de cartas numeradas en forma arbitraria.
Requiere O(n) operaciones para ordenar una lista de n elementos.
Inicialmente se tiene un solo elemento, que obviamente es un conjunto ordenado. Despus, cuando
hay k elementos ordenados de menor a mayor, se toma el elemento k+1 y se compara con todos los
elementos ya ordenados, detenindose cuando se encuentra un elemento menor (todos los elementos
mayores han sido desplazados una posicin a la derecha) o cuando ya no se encuentran elementos (todos
los elementos fueron desplazados y este es el ms pequeo). En este punto se inserta el
elemento k+1 debiendo desplazarse los dems elementos.
Ejemplo en C:
void ordIns(int vector[], int n)
{
int i, j, indice;

for (i=1; i < n; i++)
{
indice = vector[i];

for (j=i-1;j >= 0 && vector[j] > indice;j--)
{
vector[j + 1] = vector[j];
}
vector[j+1] = indice;
}}
Ordenamiento Quicksort
El ordenamiento rpido (quicksort en ingls) es un algoritmo creado por el cientfico britnico en
computacin C. A. R. Hoare basado en la tcnica de divide y vencers, que permite, en
promedio, ordenar n elementos en un tiempo proporcional a n log n.

El algoritmo trabaja de la siguiente forma:
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, 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.
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. 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(nlog 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, si por ejemplo el algoritmo implementado toma como pivote siempre el primer elemento
del array, y el array que le pasamos est ordenado, siempre va a generar a su izquierda un array vaco,
lo que es ineficiente.
Ejemplo:
int colocar(int *v, int b, int t)
{
int i;
int pivote, valor_pivote;
int temp;

pivote = b;
valor_pivote = v[pivote];
for (i=b+1; i<=t; i++){
if (v[i] < valor_pivote){
pivote++;
temp=v[i];
v[i]=v[pivote];
v[pivote]=temp;

}
}
temp=v[b];
v[b]=v[pivote];
v[pivote]=temp;
return pivote;
}

void Quicksort(int* v, int b, int t)
{
int pivote;
if(b < t){
pivote=colocar(v, b, t);
Quicksort(v, b, pivote-1);
Quicksort(v, pivote+1, t);
}
}