METODO BURBUJA

Concepto: Algoritmo que pone elementos de una lista o un vector, en una secuencia dada por
una relacin de orden.

El procedimiento de la burbuja es el siguiente: Ir comparando desde la casilla 0 nmero tras

nmero hasta encontrar uno mayor, si este es realmente el mayor de todo el vector se llevar
hasta la ltima casilla, si no es as, ser reemplazado por uno mayor que l. Este procedimiento
seguir as hasta que haya ordenado todas las casillas del vector. Una de las deficiencias del
algoritmo es que ya cuando ha ordenado parte del vector vuelve a compararlo cuando esto ya
no es necesario.

Dado un vector a1, a2, a3,... an.

1) Comparar a1 con a2 e intercambiarlos si a1>a2 (o a12).

2) Seguir hasta que todo se haya comparado an-1 con an.

3) Repetir el proceso anterior n-1 veces.

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();

}
 MTODO DE INSERCIN

El mtodo de "insercin" est basado en la tcnica que utilizan los jugadores de cartas para
ordenar sus cartas. El jugador va insertando cada una de las cartas en la posicin
correspondiente.

Se considera una parte de la lista ya ordenada, ubicando cada elemento y colocndolo en el

lugar que corresponde tomando en cuenta su valor, como se muestra en la siguiente imagen:

Para implementar este mtodo en el lenguaje de programacin C, se debe emplear el siguiente

procedimiento:

void ordenar(int vector[])

int i, a, aux;

for (i=1; i < 4; i++)

aux = vector[i];

for (a=i-1; a >= 0 && vector[a] > aux; a--)

vector[a + 1] = vector[a];

vector[a+1] = aux;

}
Insercin
#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();
}
 MTODO POR 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.
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:
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();
}
 MTODO DE ORDENAMIENTO SHELL

El mtodo se denomina as en honor de su inventor Donald Shell. El algoritmo Shell es una

mejora de la ordenacin por insercin, donde se van comparando elementos distantes, al
tiempo que se los intercambian si corresponde. A medida que se aumentan los pasos, el
tamao de los saltos disminuye; por esto mismo, es til tanto como si los datos desordenados
se encuentran cercanos, o lejanos.

Es bastante adecuado para ordenar listas de tamao moderado, debido a que su velocidad es
aceptable y su codificacin es bastante sencilla. Su velocidad depende de la secuencia de
valores con los cuales trabaja, ordenndolos.

Ejemplo
Por ejemplo, considere 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 8, podramos visualizar esto dividiendo la
lista de nmeros en una tabla con 5 columnas. Esto quedara as:

Entonces ordenamos cada columna, lo que nos queda:

Cuando lo leemos de nuevo como una nica lista de nmeros, obtenemos [10 14 73 25 23 13
27 94 33 39 25 59 94 65 82 45]. Aqu, el 10 que estaba en el extremo final, se ha movido hasta
el extremo inicial.

Esta lista es entonces de nuevo ordenada usando un ordenamiento con un espacio de 3

posiciones, y despus un ordenamiento con un espacio de 1 posicin (ordenamiento por
insercin simple).

#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 MONTCULOS - HEAPSORT

El ordenamiento por montculos (heapsort en ingls) es un algoritmo de ordenamiento no

recursivo, no estable, con complejidad computacional.

Ordenacin por Montculos (Heapsort):

Un montculo es una estructura tipo rbol binario que garantiza que en la cima siempre est
el elemento mayor.

Si se van eliminando los elementos de la cima y se va rearmando el montculo

adecuadamente se puede ir ordenando el conjunto de mayor a menor.
#include <iostream>
#define max 100
using namespace std;
int main()
{
int A[max],j,item,temp,i,k,n;
cout<<"Ingresa la cantidad de elementos del arreglo: ";
cin>>n;
for(i=1;i<=n;i++)
cin >> A[i];

for(k=n;k>0;k--)
{
for(i=1;i<=k;i++)
{
item=A[i];
j=i/2;
while(j>0 && A[j]<item)
{
A[i]=A[j];
i=j;
j=j/2;
}
A[i]=item;
}
temp=A[1];
A[1]=A[k];
A[k]=temp;
}
cout<<"El orden es:"<<endl;
for(i=1;i<=n;i++)
cout<<A[i] << endl;
return 0;
}
 MergeSort (Ordenamiento por mezcla)
MergeSort es un algoritmo de ordenamiento muy eficiente que utiliza la tcnica "divide y
vencers". Su orden asinttico es O(n*log(n)).

Para ordenar un vector lo divide por la mitad en dos segmentos y ordena cada segmento de
forma recursiva osea nuevamente divide cada segmento y ordena los subsegmentos de forma
recursiva... hasta que en algn momento los segmentos sern de longitud 1 es cuando se llama
a la funcin "merge" (mezclar) que intercala los elementos del ltimo segmento dividido
colocando primero los elementos menores.

Descripcin
MergeSort (u Ordenamiento por mezcla) es uno de los Algoritmos de Ordenamientos ms
eficientes que existen, fue creado en 1945 por John Von Neumann. Consiste en dividir en dos
partes iguales el vector a ordenar, ordenar por separado cada una de las partes, y luego
mezclar ambas partes, manteniendo el orden, en un solo vector ordenado.
Utiliza los siguientes tres pasos:
Dividir: Divide la secuencia de n elementos a ordenar en dos subsecuencias de n/2
elementos cada una, pues es ms sencillo ordenar una parte de los datos que el
conjunto completo de ellos.
Ordenar: Ordena las dos subsecuencias de manera recursiva mediante el algoritmo
MergeSort, comparando cada elemento de las subsecuencias.
Combinar: Combina las dos subsecuencias ordenadas para generar la solucin, cuando
quede un solo dato en un subgrupo se termina el proceso de divisin pues ese
subgrupo ya est ordenado.
#include <stdlib.h>
#include <stdio.h>
void merge(int *v, int i, int m, int f);
int main() {
int *v, n;
printf("Ingrese N: ");
scanf("%d", &n);
v = new int[n];
for(int i=0; i<n; i++) {
printf("Elemento %d: ", i+1);
scanf("%d", &v[i]);
}
mergesort(v, 0, n-1);
for(int i=0; i<n; i++)
printf("%d ", v[i]);
return 0;
}
void mergesort(int *v, int i, int f) {
if(i!=f) {
int m = (i+f)/2;
mergesort(v, i, m);
mergesort(v, m+1, f);
merge(v, i, m, f);
}
}
void merge(int *v, int i, int m, int f) {
int *aux = new int[m-i+1];
for(int j=i; j<=m; j++)
aux[j-i] = v[j];
int c1=0, c2=m+1;
for(int j=i; j<=f; j++) {
if(aux[c1] < v[c2]) {
v[j] = aux[c1++];
if(c1==m-i+1)
for(int k=c2; k<=f; k++)
v[++j] = v[k];
}
else {
v[j] = v[c2++];
if(c2==f+1)
for(int k=c1; k<=m-i; k++)
v[++j] = aux[k];
}
}
}