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 address-calculation 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 registo 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 mas 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 Shellen 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

seleccion

#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();
}
EJERCICIOS METODO DE ORDENAMIENTO EJERCICIO 01
#include <stdio.h>
#define SIZE 7
void main(void) {
int vector[SIZE];
int j, i, temp;
printf("Introduce los %d valores para ordenar:\n", SIZE);

for(i=0; i<SIZE; i++) {

printf("%d: ", i+1);
scanf("%d", &vector[i]);
printf("\n");
}
/* se aplica el algoritmo de la burbuja */
for(i=0; i<(SIZE-1); i++) {
for (j=i+1; j<SIZE; j++) {
if(vector[j]<vector[i]) {
temp=vector[j];
vector[j]=vector[i];
vector[i]=temp;
}
}
}
printf("El vector ordenado es:\n");
for(i=0; i<SIZE ; i++) {
printf("%d ", vector[i]);
}
printf("\n");
}
EJERCIO 02
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void OrdenaBurbuja (float v[], int n)
{
int t, h, e;
for (h=1; h<n; h++)
{
for(e=0; e<n;e++)
{
if (v[e]>v[e+1])
{
v[e+1] = t;
v[e] = v[e+1];
t= v[e];
}
}

}
}

void ImprimirVector(float v[], int n)

{
int i;
for (i=0; i<n; i++)
{
printf("%f ", v[i]);
}
}
int main(int argc, char *argv[])
{
if(strcmp(argv[1], "burbuja")==0)
{
int n, i, m=2, o;
float *v;
{
n=argc-2;
v =(float *)malloc(n*sizeof(float));
for (i=0; i<n; i++)
{
v[i] = atof(argv[i+2]);
}
}
OrdenaBurbuja(v, n);
ImprimirVector(v, n);
}

system("PAUSE");
return 0;
}