PTACTICA 12 | Misitio

Practica 12

METODOS DE ORDENAMIENTO

Debido a que las estructuras de datos son utilizadas para almacenar información, para poder recuperar esa información de manera eficiente es deseable que aquella esté ordenada. Existen varios métodos para ordenar las diferentes estructuras de datos básicas.
En general los métodos de ordenamiento no son utilizados con frecuencia, en algunos casos sólo una vez. Hay métodos muy simples de implementar que son útiles en los casos en dónde el número de elementos a ordenar no es muy grande (ej, menos de 500 elementos). Por otro lado hay métodos sofisticados, más difíciles de implementar pero que son más eficientes en cuestión de tiempo de ejecución.

ORDENAMIENTO DE BURBUJA

La Ordenación de burbuja (Bubble Sort en inglés) es un sencillo algoritmo de ordenamiento. Funciona revisando cada elemento de la lista que va a ser ordenada con el siguiente, intercambiándolos de posición si están en el orden equivocado. Es necesario revisar varias veces toda la lista hasta que no se necesiten más 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 pequeñas "burbujas". También es conocido como el método del intercambio directo. Dado que solo usa comparaciones para operar elementos, se lo considera un algoritmo de comparación, siendo el más 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 inglés) es un algoritmo de ordenamiento. El método se denomina Shell en honor de su inventor Donald Shell. Su implementación original, requiere O(n2) comparaciones e intercambios en el peor caso. Un cambio menor presentado en el libro de V. Pratt produce una implementación 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 fácil desarrollar un sentido intuitivo de cómo funciona este algoritmo, es muy difícil analizar su tiempo de ejecución.

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 inserción (insertion sort en inglés) es una manera muy natural de ordenar para un ser humano, y puede usarse fácilmente para ordenar un mazo de cartas numeradas en forma arbitraria. Requiere O(n²) operaciones para ordenar una lista de n 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 selección (Selection Sort en inglés) es un algoritmo de ordenamiento que requiere Ooperaciones para ordenar una lista de n elementos.
Su funcionamiento es el siguiente:

Buscar el mínimo elemento de la lista
Intercambiarlo con el primero
Buscar el mínimo en el resto de la lista
Intercambiarlo con el segundo

Y en general:

Buscar el mínimo elemento entre una posición i y el final de la lista
Intercambiar el mínimo con el elemento de la posición i

De esta manera se puede escribir el siguiente pseudocódigo 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();

Ordenamiento Rápido (Quicksort)

El ordenamiento rápido (quicksort en inglés) es un algoritmo basado en la técnica de divide y vencerás, que permite, en promedio, ordenar n elementos en un tiempo proporcional a n log n. Esta es la técnica de ordenamiento más rápida conocida. Fue desarrollada por C. Antony R. Hoare en 1960. El algoritmo original es recursivo, pero se utilizan versiones iterativas para mejorar su rendimiento (los algoritmos recursivos son en general más lentos que los iterativos, y consumen más recursos).

C++

#include<iostream>
#include<math.h>

using namespace std;
int i,A[10],r,axu,n,menor,j,k,a,inc,izquierda,derecha;
float leer(),ordenar(),ver(),Seleccion(),Burbuja(),ordenar1(),Insercion(),ordenar2(),Shell(),QuickSort(),ordenar3(int A[],int n),ordenar4(int A[],int izquierda,int derecha);

int main(){
   int opcion;
   do{
       cout<<"**************Prueba 10**************\n";
       cout<<"1)BurbBuja\n";
       cout<<"2)SelecCion\n";
       cout<<"3)Insercion\n";
       cout<<"4)Shell\n";
       cout<<"5)Quick Sort\n";
       cout<<endl;
       cout<<"Eliga Opcion\n";
       cin>>opcion;
       if(opcion>0,opcion<6){
           switch (opcion){
               case 1:{
                   Burbuja();
                   break;
               }
               case 2:{
                   Seleccion();
                   break;
               }
               case 3:{
                   Insercion();
                   break;
               }
               case 4:{
                   Shell();
                   break;
               }
               case 5:{
                   QuickSort();
                   break;
               }
           }
       }else
       cout<<"Opcion no existente\n";
       cout<<endl;
       cout<<endl;
   }while (opcion!=0);
   system("pause");
   return(0);
}

float Burbuja(){
   cout<<"*******Metodo Burbuja*******\n";
   int opcion1;
   cout<<"1)Leer\n";
   cout<<"1)Oredenar\n";
   cout<<"2)Ver\n";
   cout<<endl;
   cin>>opcion1;
   if(opcion1>0,opcion1<4){
       switch (opcion1){
       case 1:{
       leer();
               break;
           }
           case 2:{
               ordenar();
               break;
           }
           case 3:{
               ver();
               break;
           }
       }
   }
}

float leer(){
   cout<<endl;
   cout<<"*******Leer Vectores*******\n";
   cout<<endl;
   cout<<"Total= ";cin>>n;cout<<endl;
   i=1;
   cout<<"Vector[]\n";
   while(i<=n){
       cout<<"Vector["<<i<<"]= ";
       cin>>A[i];
       i=i+1;
   }cout<<endl;
}

float ordenar(){
   cout<<endl;
   cout<<"*******Ordenamiento*******\n";
   cout<<endl;
   for(r=1;r<=n-1;r++){
       for(i=1;i<=n;i++){
           if(A[i]>A[i+1]){
               axu=A[i];
               A[i]=A[i+1];
               A[i+1]=axu;

           }
       }
   }
}

float ver(){
   cout<<endl;
   cout<<"*******Mirar Vectores*******\n";
   cout<<endl;
   i=1;
   cout<<"Vector[]\n";
   while(i<=n){
       cout<<"Vector["<<i<<"]= ";
       cout<<A[i];
       i=i+1;
       cout<<endl;
   }
   cout<<"#vueltas: "<<r<<endl;
   cout<<endl;
}
float Seleccion(){
   cout<<"*******Metodo Seleccion*******\n";
   int opcion2;
   cout<<"1)Oredenar\n";
   cout<<"2)Ver\n";
   cout<<endl;
   cin>>opcion2;
   if(opcion2>0,opcion2<3){
       switch (opcion2){
           case 1:{
               ordenar1();
               break;
           }
           case 2:{
               ver();
               break;
           }
       }
   }
}
float ordenar1(){
   for(i=1;i<=n;i++){
       menor=A[i];
       k=i;
       for(j=1;j<=n;j++){
           if(A[j]<menor){
               menor=A[j];
               k=j;

           }
       }A[k]=A[i];
       A[i]=menor;
   }
}
float Insercion(){
   cout<<"*******Metodo Insercion*******\n";
   int opcion3;
   cout<<"1)Oredenar\n";
   cout<<"2)Ver\n";
   cout<<endl;
   cin>>opcion3;
   if(opcion3>0,opcion3<3){
       switch (opcion3){
           case 1:{
               ordenar2();
               break;
           }
           case 2:{
               ver();
               break;
           }
       }
   }
}

float ordenar2(){
   for (i=1; i<n; i++){
       a=A[i];
j=i - 1;
while ( (A[j] >a) && (j >= 0) ){
   A[j+1] = A[j];
j--;
A[j+1] = a;
       }
}
}

float Shell(){
   cout<<"*******Metodo Shell*******\n";
   int opcion4;
   cout<<"1)Oredenar\n";
   cout<<"2)Ver\n";
   cout<<endl;
   cin>>opcion4;
   if(opcion4>0,opcion4<3){
       switch (opcion4){
           case 1:{
               ordenar3(A,n);
               break;
           }
           case 2:{
               ver();
               break;
           }
       }
   }
}

float ordenar3(int A[],int n){
   int i, j, inc,axu;
for(inc=1 ; inc>0;){
   for (i=inc;i=inc;A[j-inc]>axu){
       A[j] = A[j-inc];
j = j-inc;
       }A[j] = axu;
   }inc/= 2;
}

float QuickSort(){
   cout<<"*******Metodo Quick Sort*******\n";
   int opcion5;
   cout<<"1)Oredenar\n";
   cout<<"2)Ver\n";
   cout<<endl;
   cin>>opcion5;
   if(opcion5>0,opcion5<3){
       switch (opcion5){
           case 1:{
               ordenar4(A,izquierda,derecha);
               break;
           }
           case 2:{
               ver();
               break;
           }
       }
   }
}

float ordenar4(int A[],int izquierda,int derecha){
   int i,j,x,axu;
i=izquierda;
j=derecha;
x=A[(izquierda+derecha)/2];
do{
while((A[i]<x) && (j<=derecha)){
i++;
}
while((x<A[j]) && (j>izquierda)){
j--;
}
if( i<= j){
axu=A[i];
           A[i]=A[j];
           A[j]=axu;
i++;
           j--;
}
}while( i <= j );
if( izquierda < j ){
ordenar4(A,izquierda,j);
       }
if( i < derecha ){
ordenar4(A,i,derecha);
   }

// FIN PROCESO
}