Algoritmo de Ordenação Radix

Publicado por João Cristiano Monteiro da Silva (última atualização em 07/07/2011)

[ Hits: 7.133 ]

Download Ordena_Radix.cpp




Essa classe implementa um paradigma de ordenação usado originalmente para ordenação de cartões perfurados, onde os valores são empilhados dinamicamente.

Em suma, esse método agrupa os elementos levando em consideração um conjunto de combinações, levando em consideração o valor específico de cada algarismo.


  



Esconder código-fonte

#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <vector>


using namespace std;

class Radix{
   private:
      int *vetor;   
      int n;
   public:
      Radix(int size){
         this->vetor = new int[size];
         this->n = size;
         memset(vetor, 0, size*sizeof(vetor));         
      }
      
      Radix(int *origem, int size){         
         this->n = size;
         vetor = origem;
      }
      
      int *getVetor(){
         return(this->vetor);
      }
      
      int getVetorSize(){
         return(this->n);
      }
      
      void ordenacaoRadix(){
         vector<int> pilha[10];
         int iCont = 0;
         int max = getDigInteiros(getMaxValue());
         int alg = 1;
         do {
            for(int i = 0; i < 10 && !iCont; i++)
               pilha[i].clear();
            pilha[getAlgRangeInt(vetor[iCont], alg)].push_back(vetor[iCont]);
            iCont++;
            if(iCont >= this->n){
               iCont = 0;
               for(int i = 0; i < 10; i++){
                  for(int j = 0; j < pilha[i].size(); j++){
                     vetor[iCont++] = pilha[i][j];
                  }
               }
               iCont = 0;
               alg++;
            }
         } while(pilha[0].size() != this->n || (max+1) >= alg);
      }
      
   private:
      int getMaxValue(){         
         int maior = 0;
         for(int i = 1; i < this->n; i++){
            if(*(vetor + i) > *(vetor + maior)){
               maior = i;
            }
         }
         return(*(vetor + maior));
      }
      
      int getAlgRangeInt(int valor, int algarismo){
         unsigned quociente, divisor;
         quociente = (int) pow(10, algarismo);
         divisor = (int) pow(10, algarismo - 1);
         return ((valor % quociente) / divisor);
      }
      
      int getDigInteiros(int valor){
         if(valor<10) return 1;
         return(1 + getDigInteiros(valor / 10));
      }
};

int main(int argc, char **argv){
   int vetor[] = {20, 10, 2348, 22, 2, 50, 80, 5};

   Radix radix(vetor, 8);
   radix.ordenacaoRadix();

   int *retorno = radix.getVetor();

   for(int i = 0; i < 8; i++){
      cout << (i + 1) << ": " << *(retorno + i) << endl;
   }
   
   return(EXIT_SUCCESS);
}

Scripts recomendados

Métodos de Ordenação - Radix Sort

Um parser para tratar opções passadas para um programa em C

Fila estática em C

RNA - PERCEPTRON

Exemplo de uso de Math.h


  

Comentários

Nenhum comentário foi encontrado.


Contribuir com comentário




Patrocínio

Site hospedado pelo provedor RedeHost.
Linux banner

Destaques

Artigos

Dicas

Tópicos

Top 10 do mês

Scripts