METODOS DE ORDENAMIENTO

Debido a que las estructuras de datos son utilizadas para almacenar informacin,
para poder recuperar esa informacin de manera eficiente es deseable que aquella est
ordenada. Existen varios mtodos para ordenar las diferentes estructuras de datos
bsicas.
En general los mtodos de ordenamiento no son utilizados con frecuencia, en
algunos casos slo una vez. Hay mtodos muy simples de implementar que son tiles en
los casos en dnde el nmero de elementos a ordenar no es muy grande (ej, menos de
500 elementos). Por otro lado hay mtodos sofisticados, ms difciles de implementar
pero que son ms eficientes en cuestin de tiempo de ejecucin.
Los mtodos sencillos por lo general requieren de aproximadamente n x n pasos
para ordenar n elementos.
Los mtodos simples son: insertion sort (o por insercin directa) selection sort,
bubble sort, y shellsort, en dnde el ltimo es una extensn al insertion sort, siendo ms
rpido. Los mtodos ms complejos son el quick-sort, el heap sort, radix y addresscalculation sort. El ordenar un grupo de datos significa mover los datos o sus referencias
para que queden en una secuencia tal que represente un orden, el cual puede ser
numrico, alfabtico o incluso alfanumrico, ascendente o descendente.
Se ha dicho que el ordenamiento puede efectuarse moviendo los registros con las
claves. El mover un registro completo implica un costo, el cual se incrementa conforme
sea mayor el tamao del registro. Es por ello que es deseable evitar al mximo el
movimiento de los registros. Una alternativa es el crear una tabla de referencias a los
registros y mover las referencias y no los datos. A continuacin se mostrarn los
mtodos de ordenamiento empezando por el ms sencillo y avanzando hacia los ms
sofisticados
La eficiencia de los algoritmos se mide por el nmero de comparaciones e intercambios
que tienen que hacer, es decir, se toma n como el nmero de elementos que tiene el
arreglo a ordenar y se dice que un algoritmo realiza O(n2) comparaciones cuando
compara n veces los n elementos, n x n = n2.

ORDENAMIENTO DE BURBUJA
La Ordenacin de burbuja (Bubble Sort en ingls) es un sencillo algoritmo de
ordenamiento. Funciona revisando cada elemento de la lista que va a ser ordenada con
el siguiente, intercambindolos de posicin si estn en el orden equivocado. Es
necesario revisar varias veces toda la lista hasta que no se necesiten ms intercambios,
lo cual significa que la lista est ordenada. Este algoritmo obtiene su nombre de la
forma con la que suben por la lista los elementos durante los intercambios, como si
fueran pequeas "burbujas". Tambin es conocido como el mtodo del intercambio
directo. Dado que solo usa comparaciones para operar elementos, se lo considera un
algoritmo de comparacin, siendo el ms sencillo de implementar.
burbuja
#include<stdio.h>
#include<conio.h>
int a[3]={3,2,1};
int i,j,aux,n=3;
void main(){
clrscr();
for(i=0;i<=n;i++){
for(j=0;j<n-1;j++){
if(a[j]>a[j+1]){
aux=a[j];
a[j]=a[j+1];
a[j+1]=aux;
}
}
}
for(i=0;i<3;i++)
{
printf("%d",a);
}
getch();
}

ORDENAMIENTO SHELL
El ordenamiento Shell (Shell sort en ingls) es un algoritmo de ordenamiento. El mtodo se
denomina Shell en honor de su inventor Donald Shell. Su implementacin original,
requiere O(n2) comparaciones e intercambios en el peor caso. Un cambio menor presentado en
el libro de V. Pratt produce una implementacin con un rendimiento de O(n log2 n) en el peor
caso. Esto es mejor que las O(n2) comparaciones requeridas por algoritmos simples pero peor
que el ptimo O(n log n). Aunque es fcil desarrollar un sentido intuitivo de cmo funciona este
algoritmo, es muy difcil analizar su tiempo de ejecucin. El algoritmo Shell sort mejora el
ordenamiento por insercin comparando elementos separados por un espacio de varias
posiciones. Esto permite que un elemento haga "pasos ms grandes" hacia su posicin esperada.
Los pasos mltiples sobre los datos se hacen con tamaos de espacio cada vez ms pequeos. El
ltimo paso del Shell sort es un simple ordenamiento por insercin, pero para entonces, ya est
garantizado que los datos del vector estn casi ordenados.

shell
#include<stdio.h>
#include<conio.h>
int a[5];
int n=5;
void main()
{
int inter=(n/2),i=0,j=0,k=0,aux;
clrscr();
for (i=0; i<5; i++)
{
printf("INSERTA UN VALOR DEL INDICE %d", i);
scanf("%d",& a);
}
while(inter>0){
for(i=inter;i<n;i++)
{
j=i-inter;
while(j>=0) {
k=j+inter;
if(a[j]<=a[k]){

j--;
}
else{
aux=a[j];
a[j]=a[k];
a[k]=aux;
j=j-inter;
}
}
}
inter=inter/2;
}
for(i=0;i<5;i++)
{
printf("%d n",a);
getch();
}
}

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.
iinserccion
#include<stdio.h>
#include<conio.h>
int a[4]={4,1,7,2};
int n=4;

int i,j,aux;
void main(){
clrscr();
for(i=1;i<n;i++)
{
j=i;
aux=a;
while(j>0 && aux<a[j-1])
{
a[j]=a[j-1];
j--;
}
a[j]=aux;
}
for(i=0;i<4;i++)
{
printf("%d",a);
}
getch();
}

ORDENAMIENTO POR SELECCION

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 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:
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
seleccin
#include<stdio.h>
#include<conio.h>
int x[4]={1,4,8,6};
int n=4,j=0,i=0;
int temp=0,minimo=0;
void main(){
clrscr();
for(i=0;i<n-1;i++)
{
minimo=i;
for(j=i+1;j<n;j++)
{
if(x[minimo] > x[j])
{
minimo=j;
}
}
temp=x[minimo];
x[minimo]=x;
x=temp;
}
for(i=0;i<n;i++)
{
printf("%d",x);
}
getch();
}