radix

fonte/u05 Ordenação em memória principal/c/makefile

@@ -1,7 +1,7 @@
 all: exec
  
-exec: principal.o geracao.o bolha.o countingsort.o heapsort.o insercao.o mergesort.o quicksort.o selecao.o shellsort.o
+exec: principal.o geracao.o bolha.o countingsort.o radixsort.o heapsort.o insercao.o mergesort.o quicksort.o selecao.o shellsort.o
-	gcc -o exec principal.o geracao.o bolha.o countingsort.o heapsort.o insercao.o mergesort.o quicksort.o selecao.o shellsort.o
+	gcc -o exec principal.o geracao.o bolha.o countingsort.o radixsort.o heapsort.o insercao.o mergesort.o quicksort.o selecao.o shellsort.o
  
 principal.o: principal.c 
 	gcc -o principal.o principal.c -c -W -Wall -pedantic
@@ -12,6 +12,9 @@ bolha.o: bolha.c
 countingsort.o: countingsort.c 
 	gcc -o countingsort.o countingsort.c -c -W -Wall -pedantic
 
+radixsort.o: radixsort.c 
+	gcc -o radixsort.o radixsort.c -c -W -Wall -pedantic
+
 geracao.o: geracao.c 
 	gcc -o geracao.o geracao.c -c -W -Wall -pedantic
 

fonte/u05 Ordenação em memória principal/c/principal.c

@@ -1,11 +1,13 @@
 #include "bolha.h"
 #include "countingsort.h"
+#include "radixsort.h"
 #include "heapsort.h"
 #include "insercao.h"
 #include "mergesort.h"
 #include "quicksort.h"
 #include "selecao.h"
 #include "shellsort.h"
+#include "geracao.h"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -39,7 +41,8 @@ int main(int argc, char **argv) {
     //insercao(array, n);
     //mergesort(array, n);
     //quicksort(array, n);
-    selecao(array, n);
+    //selecao(array, n);
+    radixsort(array,n);
     //shellsort(array, n);
 	 fim = clock();
     total = ((fim - inicio) / (double)CLOCKS_PER_SEC);    

fonte/u05 Ordenação em memória principal/c/radixsort.c

@@ -0,0 +1,51 @@
+#include "geracao.h"
+#include "radixsort.h"
+//=============================================================================
+int getMax(int *array, int n) {
+    int maior = array[0];
+
+    for (int i = 1; i < n; i++) {
+        if(maior < array[i]){
+            maior = array[i];
+        }
+    }
+    return maior;
+}
+//=============================================================================
+void radixsort(int *array, int n) {
+    //Array para contar o numero de ocorrencias de cada elemento
+    int max = getMax(array, n);
+    for (int exp = 1; max/exp > 0; exp *= 10) {
+            radcountingSort(array, n, exp);
+    }
+}
+
+  void radcountingSort(int *array, int n, int exp) {
+        int count[10];
+        int output[n];
+
+        //Inicializar cada posicao do array de contagem 
+        for (int i = 0; i < 10; count[i] = 0, i++);
+
+        //Agora, o count[i] contem o numero de elemento iguais a i
+        for (int i = 0; i < n; i++) {
+            count[(array[i]/exp) % 10]++;
+        }
+
+        //Agora, o count[i] contem o numero de elemento menores ou iguais a i
+        for (int i = 1; i < 10; i++) {
+            count[i] += count[i-1];
+        }
+
+        //Ordenando
+        for (int i = n-1; i >= 0; i--) {
+            output[count[(array[i]/exp) % 10] - 1] = array[i];
+            count[(array[i]/exp) % 10]--;
+        }
+
+        //Copiando para o array original
+        for (int i = 0; i < n; i++) {
+            array[i] = output[i];
+        }
+    }
+//=============================================================================

fonte/u05 Ordenação em memória principal/c/radixsort.h

@@ -0,0 +1,10 @@
+#ifndef RADIXSORT_H
+#define RADIXSORT_H
+//=============================================================================
+int getMax(int *array, int n);
+//=============================================================================
+void radixsort(int *array, int n);
+
+void radcountingSort(int *array, int n, int exp);
+//=============================================================================
+#endif