viernes, 24 de junio de 2011

Ordenamiento de Burbuja en C++

El ordenamiento burbuja es un algoritmo simple para ordenar los elementos de un arreglo. Consiste en ir comparando cada entrada con la siguiente e intercambiar sus posiciones en caso de que no estén ordenados. La primera pasada garantiza que el elemento más grande vaya hasta el último elemento del algoritmo, en la segunda el segundo mayor, y así sucesivamente los elementos grandes van "subiendo" como las burbujas en un líquido. El programa presentado aquí es el básico. Se puede hacer más eficiente tomando en cuenta ciertos aspectos. Aquí se considera el peor de los casos; sin embargo podría suceder que el arreglo ya estuviera total o parcialmente ordenado, en tal situación este algoritmo de todas formas cumple con los dos ciclos, lo cual desde luego no es apropiado. Las mejoras, sin embargo, corresponden a otras entradas, ( Ordenamiento Burbuja Mejorado ) La principal característica de ésta versión es su sencillez.
El siguiente video explica bien de qué se trata este algoritmo.





 #include <iostream>
 using namespace::std;

 enum { Tamano = 10};
 // Cambiar la variable Tamano para ordenar una
 // cantidad diferente de datos
 

 /*Prototipo de funcion Imprime */
 void Imprime( int A[]);

 /*prototipo de funcion Recibe */
 void Recibe ( int B[]);

 /*Prototipo de funcion Burbuja */
 void Burbuja( int C[]);
 

 int main()

 {           // Abre main

 int Arreglo[Tamano] = {0, 0};
 // El Arreglo se ha inicializado a 0
 
 cout <<"\nEste programa recibe una serie de %d numeros enteros" << Tamano;
 cout <<" y los ordena por medio del algoritmo de ordenacion burbuja. "<< endl; 

 /*Se llena el arreglo mediante un llamado a la funcion Recibe*/
 Recibe(Arreglo);

 /*Se imprime el arreglo con las entradas en el orden original */
 cout <<"\nEsta es el orden en que se introdujeron los elementos: " <<endl;
 Imprime(Arreglo);

 /*Se ordena el arreglo mediante una llamada a la funcion Burbuja*/
 Burbuja(Arreglo);

 /*Se imprime el arreglo ordenado */
 cout <<"\nEste es el orden despues de el ordenamiento burbuja. " <<endl;
 Imprime(Arreglo);

 return 0;
 }           // Cierra main


 //////////////////////////////////////////////////
 //FUNCION IMPRIME 
 /////////////////////////////////////////////////
 
 void Imprime( int A[] )
 {     // Abre la funcion Imprime
 
 for ( int j = 0; j < Tamano; j++ )
 {      // Abre for
 cout << "\t" << A[j]; 

 if ( 0 == j + 1 % 10)
 cout <<endl <<endl;

 }      // Cierra for

 cout <<endl <<endl;
 }     // Cierra la funcion Imprime

 ////////////////////////////////////////////////////////////////////////////
 //FUNCION RECIBE
 //////////////////////////////////////////////////////////////////////////
 

 void Recibe( int B[] )
 {         // Abre funcion Recibe
 
 for ( int i = 0; i < Tamano; i++ )
 {      // Abre for
 cout << "\nIntroduzca el elemento " << i + 1 << " del arreglo: " << endl;
 cin >> B[i];
 }
 }         // Cierra funcion Recibe



 ///////////////////////////////////////////////
 //FUNCION BURBUJA
 /////////////////////////////////////////////////
 

  void Burbuja( int C[])
 {                 // Abre funcion Burbuja

 int temporal;

 for ( int m = 0; m < Tamano - 1; m++ )
 for ( int n = 0; n <= Tamano - 1; n++ )
 {    // Abre for
     
 if ( C[n] > C[n + 1] )
 {    // Abre if
 temporal = C[n]; 
 C[n] = C[n + 1];
 C[n + 1] = temporal;

 }    // Cierra if 
 }         //Cierra for
 }                 // Cierra funcion Burbuja

1 comentario:

  1. #include
    #include


    int main()
    {
    int MAXNUM = 5;
    int arreglo [MAXNUM],temporal,i,j;
    for (i=0; i
    {
    temporal = arreglo[j];
    arreglo[j] = arreglo[i];
    arreglo[i] = temporal;
    }
    }
    //Aqui termina el método.

    printf("El arreglo ardenado es: \n");
    for (i=0; i<MAXNUM; i++)
    printf("%d\n",arreglo[i]);

    getchar();
    getchar();
    }

    ResponderEliminar

Related Posts Plugin for WordPress, Blogger...