Pobremia da crassificasão crescenti e descrescenti de uma matris do ti

[jotâo]

:wacko:

Ordenação de matriz do tipo Vetor.

Observação Algorítmica:

Fazer a ordenação(ou seja, colocar os dados e/ou valores segundo uma determinada classificação: ascendente ou descendente é uma das aplicações no campo da ciência da computação mais importante.

Praticamente todas as organizações devem classificar algum dado e/ou algum valor de dado e, em muitas ocasiões, quantidades extremas de Dados. Neste contexto,segue abaixo a análise e desen

volvimento do que talvez seja o esquema mais simples de classificação de uma matriz/vetor unidimensional.

O Programa abaixo classifica os valores inseridos nas casinhas e/ou endereços de um array de forma crescente e descrescente. A técnica empregada é denominada de bubble sort, ou sinking sort

porque os valores menores contidos no array "sobem" ou "descem" gradualmente ou se movimentam pela estrutura do array.

Inicialmente, o programa irá comparar o valor do inteiro no endereço array_inteiros[0], com array_inteiros[1] em cada interação do loop, assim sucessivamente.

#include<conio.h>

#include<iomanip>
using std::setiosflags;
using std::setprecision;
using std::setw;

#include<iostream>
using namespace std;
using std::cin;
using std::cout;
using std::endl;

#if !defined( z )
#define z 0
#endif

#if !defined( u )
#define u 1
#endif

#if !defined(inf) //Intervalo inferior para inicializar o loop da estrutura for.
#define inf z
#endif

#if !defined(sup) //Intervalo superior para determinar o comprimento da estrutura do array.
#define sup 5
#endif

unsigned long int main()
{
 system("CLS");

  unsigned long int subs_x = ( z );
  unsigned long int subs_y = ( z );
  unsigned long int entrar_inteiro = ( z );
  unsigned long int trocar_elemento = ( z );
  unsigned long int array_inteiros[sup];


   //Habitando as casinhas do array_inteiros com o valor 0.
  for(subs_x = (inf); subs_x < (sup); subs_x = (subs_x + u))
  {
   array_inteiros[subs_x] = ( z );
  }

  //Habitando as casinhas do array_inteiros com valores digitados.
  for(subs_x = (inf); subs_x < (sup); subs_x = (subs_x + u))
  {
   cout <<"\nInforme no campo abaixo o valor do: " <<(subs_x + u) <<"º Inteiro: " <<endl;
   cout <<"\nValor: "; cin >>entrar_inteiro;
   array_inteiros[subs_x] = (entrar_inteiro);
  }

  //Colocando os valores dos elementos do array em ordem crescente.
  for(subs_x = (inf); subs_x < (sup); subs_x = (subs_x + u))
  {
   for(subs_y = (subs_x + u); subs_y < (sup + u); subs_y++)
   {
    if(array_inteiros[subs_x] > array_inteiros[subs_y])
    {
     trocar_elemento = (array_inteiros[subs_x]);
     array_inteiros[subs_x] = (array_inteiros[subs_y]);
     array_inteiros[subs_y] = (trocar_elemento);
    }
   }
  }

  //Exibindo o array crescente.
  for(subs_x = (inf); subs_x < (sup); subs_x = (subs_x + u))
  {
    cout <<array_inteiros[subs_x];
    cout <<endl;
  }

  cout <<endl;
   //Colocando os valores dos elementos do array em ordem decrescente.
  for(subs_x = (inf); subs_x < (sup); subs_x = (subs_x + u))
  {
   for(subs_y = (subs_x + u); subs_y < (sup); subs_y++)
   {
    if(array_inteiros[subs_x] < array_inteiros[subs_y])
    {
     trocar_elemento = (array_inteiros[subs_x]);
     array_inteiros[subs_x] = (array_inteiros[subs_y]);
     array_inteiros[subs_y] = (trocar_elemento);
    }
   }
  }

   //Exibindo o array decrescente.
  for(subs_x = (inf); subs_x < (sup); subs_x = (subs_x + u))
  {
    cout <<array_inteiros[subs_x];
    cout <<endl;
  }
 system("PAUSE");

 return(NULL);
}

Edited December 1, 2011 by jotâo

[Dan Oliveira]

O programa bubble sort que se encontra no livro deitel como programar em c 6 edição

/* Fig. 6.15: fig06_15.c
   This program sorts an array's values into ascending order */
#include <stdio.h>
#define SIZE 10

/* function main begins program execution */
int main( void ) 
{   
   /* initialize a */
   int a[ SIZE ] = { 2, 6, 4, 8, 10, 12, 89, 68, 45, 37 }; 
   int pass; /* passes counter */
   int i;    /* comparisons counter */
   int hold; /* temporary location used to swap array elements */
   
   printf( "Data items in original order\n" );
   
   /* output original array */
   for ( i = 0; i < SIZE; i++ ) {
      printf( "%4d", a[ i ] );
   } /* end for */

   /* bubble sort */
   /* loop to control number of passes */
   for ( pass = 1; pass < SIZE; pass++ ) { 

      /* loop to control number of comparisons per pass */
      for ( i = 0; i < SIZE - 1; i++ ) {      

         /* compare adjacent elements and swap them if first 
         element is greater than second element */
         if ( a[ i ] > a[ i + 1 ] ) {  
            hold = a[ i ];                   
            a[ i ] = a[ i + 1 ];
            a[ i + 1 ] = hold;
         } /* end if */

      } /* end inner for */

   } /* end outer for */

   printf( "\nData items in ascending order\n" );

   /* output sorted array */
   for ( i = 0; i < SIZE; i++ ) {
      printf( "%4d", a[ i ] );
   } /* end for */

   printf( "\n" );

   return 0; /* indicates successful termination */

} /* end main */



/**************************************************************************
 * © Copyright 1992-2007 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 *************************************************************************/

Edited December 2, 2011 by Dan Oliveira