From d2b47cd023080652c3d9e6a06825e2b2a262b7d1 Mon Sep 17 00:00:00 2001
From: Max do Val Machado <maxm@maxmachado.org>
Date: Sun, 23 Aug 2020 20:51:12 -0300
Subject: [PATCH] =?UTF-8?q?Atualiza=C3=A7=C3=A3o=20nos=20algoritmos=20de?=
 =?UTF-8?q?=20ordena=C3=A7=C3=A3o?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../c/bolha.c                                 |  14 +++
 .../c/bolha.h                                 |  15 +--
 .../c/bolha.o                                 | Bin 0 -> 1696 bytes
 .../c/bolha_teste.c                           |  64 ------------
 .../c/countingsort.c                          |  36 +++++++
 .../c/countingsort.h                          |  37 +------
 .../c/geracao.c                               |  70 +++++++++++++
 .../c/geracao.h                               |  59 ++---------
 .../c/heapsort.c                              |  57 +++++++++++
 .../c/heapsort.h                              |  58 +----------
 .../c/insercao.c                              |  15 +++
 .../c/insercao.h                              |  16 +--
 .../c/makefile                                |  40 ++++++++
 .../c/mergesort.c                             |   6 ++
 .../c/mergesort.h                             |   4 +-
 .../c/principal.c                             |   5 +
 .../c/quicksort.c                             |  22 ++++
 .../c/quicksort.h                             |  22 +---
 .../c/selecao.c                               |  14 +++
 .../c/selecao.h                               |  12 +--
 .../c/shellsort.c                             |  27 +++++
 .../c/shellsort.h                             |  27 +----
 .../java/Bolha.class                          | Bin 0 -> 474 bytes
 .../java/Bolha.java                           |  19 +---
 .../java/Countingsort.class                   | Bin 0 -> 744 bytes
 .../java/Countingsort.java                    |  45 +++-----
 .../java/ExercicioDuvidaAND.java              |  17 ----
 .../java/Geracao.class                        | Bin 0 -> 2444 bytes
 .../java/Geracao.java                         |  56 +++++-----
 .../java/Heapsort.class                       | Bin 0 -> 1045 bytes
 .../java/Heapsort.java                        |  96 ++++++++----------
 .../java/Insercao.class                       | Bin 0 -> 476 bytes
 .../java/Insercao.java                        |  19 +---
 .../java/Mergesort.class                      | Bin 0 -> 357 bytes
 .../java/Mergesort.java                       |  39 +++++++
 .../java/Principal.class                      | Bin 0 -> 1258 bytes
 .../java/Principal.java                       |   4 +-
 .../java/Quicksort.class                      | Bin 0 -> 624 bytes
 .../java/Quicksort.java                       |  21 +---
 .../java/Selecao.class                        | Bin 0 -> 493 bytes
 .../java/Selecao.java                         |   2 +-
 .../java/Shellsort.class                      | Bin 0 -> 659 bytes
 .../java/Shellsort.java                       |  21 +---
 .../c/arvoreBinariaC/no.o                     | Bin 1592 -> 0 bytes
 .../{c => cc}/arvoreBinariaCC/arvorebinaria.cc |   0
 .../{c => cc}/arvoreBinariaCC/arvorebinaria.h |   0
 .../{c => cc}/arvoreBinariaCC/makefile        |   0
 .../{c => cc}/arvoreBinariaCC/no.cc           |   0
 .../{c => cc}/arvoreBinariaCC/no.h            |   0
 .../{c => cc}/arvoreBinariaCC/principal.cc    |   0
 50 files changed, 478 insertions(+), 481 deletions(-)
 create mode 100644 fonte/U4 - Ordenação em memória principal/c/bolha.c
 create mode 100644 fonte/U4 - Ordenação em memória principal/c/bolha.o
 delete mode 100644 fonte/U4 - Ordenação em memória principal/c/bolha_teste.c
 create mode 100644 fonte/U4 - Ordenação em memória principal/c/countingsort.c
 create mode 100644 fonte/U4 - Ordenação em memória principal/c/geracao.c
 create mode 100644 fonte/U4 - Ordenação em memória principal/c/heapsort.c
 create mode 100644 fonte/U4 - Ordenação em memória principal/c/insercao.c
 create mode 100644 fonte/U4 - Ordenação em memória principal/c/makefile
 create mode 100644 fonte/U4 - Ordenação em memória principal/c/mergesort.c
 create mode 100644 fonte/U4 - Ordenação em memória principal/c/quicksort.c
 create mode 100644 fonte/U4 - Ordenação em memória principal/c/selecao.c
 create mode 100644 fonte/U4 - Ordenação em memória principal/c/shellsort.c
 create mode 100644 fonte/U4 - Ordenação em memória principal/java/Bolha.class
 create mode 100644 fonte/U4 - Ordenação em memória principal/java/Countingsort.class
 delete mode 100644 fonte/U4 - Ordenação em memória principal/java/ExercicioDuvidaAND.java
 create mode 100644 fonte/U4 - Ordenação em memória principal/java/Geracao.class
 create mode 100644 fonte/U4 - Ordenação em memória principal/java/Heapsort.class
 create mode 100644 fonte/U4 - Ordenação em memória principal/java/Insercao.class
 create mode 100644 fonte/U4 - Ordenação em memória principal/java/Mergesort.class
 create mode 100644 fonte/U4 - Ordenação em memória principal/java/Mergesort.java
 create mode 100644 fonte/U4 - Ordenação em memória principal/java/Principal.class
 create mode 100644 fonte/U4 - Ordenação em memória principal/java/Quicksort.class
 create mode 100644 fonte/U4 - Ordenação em memória principal/java/Selecao.class
 create mode 100644 fonte/U4 - Ordenação em memória principal/java/Shellsort.class
 delete mode 100644 fonte/U6 - Árvores binárias/c/arvoreBinariaC/no.o
 rename fonte/U6 - Árvores binárias/{c => cc}/arvoreBinariaCC/arvorebinaria.cc (100%)
 rename fonte/U6 - Árvores binárias/{c => cc}/arvoreBinariaCC/arvorebinaria.h (100%)
 rename fonte/U6 - Árvores binárias/{c => cc}/arvoreBinariaCC/makefile (100%)
 rename fonte/U6 - Árvores binárias/{c => cc}/arvoreBinariaCC/no.cc (100%)
 rename fonte/U6 - Árvores binárias/{c => cc}/arvoreBinariaCC/no.h (100%)
 rename fonte/U6 - Árvores binárias/{c => cc}/arvoreBinariaCC/principal.cc (100%)

diff --git a/fonte/U4 - Ordenação em memória principal/c/bolha.c b/fonte/U4 - Ordenação em memória principal/c/bolha.c
new file mode 100644
index 0000000..ee0d624
--- /dev/null
+++ b/fonte/U4 - Ordenação em memória principal/c/bolha.c	
@@ -0,0 +1,14 @@
+#include "geracao.h"
+#include "bolha.h"
+//=============================================================================
+void bolha(int *array, int n){
+    int i, j;
+    for (i = (n - 1); i > 0; i--) {
+      for (j = 0; j < i; j++) {
+         if (array[j] > array[j + 1]) {
+            swap(&array[j], &array[j + 1]);
+         }
+      }
+   }
+}
+//=============================================================================
diff --git a/fonte/U4 - Ordenação em memória principal/c/bolha.h b/fonte/U4 - Ordenação em memória principal/c/bolha.h
index 25ce7d2..0a0d246 100644
--- a/fonte/U4 - Ordenação em memória principal/c/bolha.h	
+++ b/fonte/U4 - Ordenação em memória principal/c/bolha.h	
@@ -1,17 +1,6 @@
 #ifndef BOLHA_H
 #define BOLHA_H
 //=============================================================================
-#include "geracao.h"
+void bolha(int *array, int n);
 //=============================================================================
-void bolha(int *array, int n){
-    int i, j;
-    for (i = (n - 1); i > 0; i--) {
-      for (j = 0; j < i; j++) {
-         if (array[j] > array[j + 1]) {
-            swap(&array[j], &array[j + 1]);
-         }
-      }
-   }
-}
-//=============================================================================
-#endif
\ No newline at end of file
+#endif
diff --git a/fonte/U4 - Ordenação em memória principal/c/bolha.o b/fonte/U4 - Ordenação em memória principal/c/bolha.o
new file mode 100644
index 0000000000000000000000000000000000000000..2c4735d19fc01be4f14995f4cd615c34194152ec
GIT binary patch
literal 1696
zcmbtTPiqrV5T8wI>z~v_>7h`Oy(lX7k?O&=f}{<bED|hebCkFnR|DoByBlo9>S0w_
zLNVU_3|{>Lp&qI?PvQrt5YdCuOOQaE*?q6stm{PwCNuMU^P72@dHYl;<YJNpLL|5b
zqe!3tcj6;I<GC4_h6L;<PyZ^a?ibbhF01ZV&u#6sl|82?xk~@*Gfdo729*A-(N+fP
zYju0(IfZIl>8aAkcFIScuB2`!0w?d=u(b2!O5ile+u^mw7^?e8b$5GI-BAV-rd(C}
zk6owMmz=FWBww1t;jq*B@DB3X?6Q2WsJH5NOI~7^S$cjU-SWaq=Y0SsuuKZ|5NiHL
z5n=#c!o(P6&?k`|-2`bPCCw$K4tH>Hrw}70c}qXa@zjf0c6u`Q1~UkV7Ml44{2WG|
z#v?aEcM-Q4XT`nSk7E?YVe(JV!>9g&M_)MZO=X;N1jCbodwTyJu_P+ZF)U{gh{8c{
zR4W=Q`xZ+1!rJOep|qCE-BQ*|>np1Tr3BVPt;q|%;+A%E40V7@CXqRgd!yZrgjt(4
zThoDAw&~l7@JyqsG27U%f!)<?4VZ3Oz{-tU&8Q<*Z`cOIw=i$nTKNHw@7G(bX*QaM
zX>S7aDj1d0JyWY0qn`ia$;hR*5#C$|F%mInKk{>hPj(KKW|Kh;N|z61mV-ypQXjE#
zfuH4g_@(W0Uf58Lpj^a&YW^#K0l8E&jT#iupWabWM1NtI@lg1|yxAx)BKJCC^mUBA
zA&doIMn5QGegf0cp;lr3BJaN_61ffYZzCSHzt0i-Bd*|!{YCYrR!!bt=9a!4`i8@N
h!os^l2s*s~1quSf%N-ym(2L^#;QZ=ArtgILzX7AdsEGgo

literal 0
HcmV?d00001

diff --git a/fonte/U4 - Ordenação em memória principal/c/bolha_teste.c b/fonte/U4 - Ordenação em memória principal/c/bolha_teste.c
deleted file mode 100644
index 0ec781d..0000000
--- a/fonte/U4 - Ordenação em memória principal/c/bolha_teste.c	
+++ /dev/null
@@ -1,64 +0,0 @@
-#include "bolha.h"
-//=============================================================================
-int main(int argc, char **argv) {
-
-    int n, *array;
-    clock_t comeco, fim;
-    double total;
-    srand(time(NULL));
-
-    if(argc < 2){
-        printf("Execute: %s n\n", argv[0]);
-        printf("n - tamanho do vetor (int)\n");
-        return 0;
-    }
-
-    n = atoi(argv[1]);
-
-    if(n <= 0){
-        printf("Erro: n deve ser > 0\n");
-        return 0;
-    }
-
-    array = (int*)malloc(n*sizeof(int));
-
-    printf("Teste Bolha: Ordem Crescente\n");
-    crescente(array, n);
-    mostrar(array, n);
-    comeco = clock();
-    bolha(array, n);
-    fim = clock();
-    total = ((fim - comeco) / (double)CLOCKS_PER_SEC) * 1000.0;    
-    mostrar(array, n);
-    printf("Tempo para ordenar: %f ms (%s).\n",
-            total,
-            isOrdenado(array, n) ? "ORDENADO" : "DESORDENADO");
-
-    printf("\nTeste Bolha: Ordem Decrescente\n");
-    decrescente(array, n);
-    mostrar(array, n);
-    comeco = clock();
-    bolha(array, n);
-    fim = clock();
-    total = ((fim - comeco) / (double)CLOCKS_PER_SEC) * 1000.0;    
-    mostrar(array, n);
-    printf("Tempo para ordenar: %f ms (%s).\n",
-            total,
-            isOrdenado(array, n) ? "ORDENADO" : "DESORDENADO");
-
-    printf("\nTeste Bolha: Ordem Aleatoria\n");
-    aleatorio(array, n);
-    mostrar(array, n);
-    comeco = clock();
-    bolha(array, n);
-    fim = clock();
-    total = ((fim - comeco) / (double)CLOCKS_PER_SEC) * 1000.0;    
-    mostrar(array, n);
-    printf("Tempo para ordenar: %f ms (%s).\n",
-            total,
-            isOrdenado(array, n) ? "ORDENADO" : "DESORDENADO");   
-
-    free(array);
-
-    return 0;
-}
diff --git a/fonte/U4 - Ordenação em memória principal/c/countingsort.c b/fonte/U4 - Ordenação em memória principal/c/countingsort.c
new file mode 100644
index 0000000..561afa4
--- /dev/null
+++ b/fonte/U4 - Ordenação em memória principal/c/countingsort.c	
@@ -0,0 +1,36 @@
+#include "geracao.h"
+#include "countingsort.h"
+//=============================================================================
+int getMaior(int *array, int n) {
+    int maior = array[0];
+
+    for (int i = 0; i < n; i++) {
+        if(maior < array[i]){
+            maior = array[i];
+        }
+    }
+    return maior;
+}
+//=============================================================================
+void countingsort(int *array, int n) {
+    //Array para contar o numero de ocorrencias de cada elemento
+    int tamCount = getMaior(array, n) + 1;
+    int count[tamCount];
+    int ordenado[n];
+
+    //Inicializar cada posicao do array de contagem 
+    for (int i = 0; i < tamCount; count[i] = 0, i++);
+
+    //Agora, o count[i] contem o numero de elemento iguais a i
+    for (int i = 0; i < n; count[array[i]]++, i++);
+
+    //Agora, o count[i] contem o numero de elemento menores ou iguais a i
+    for(int i = 1; i < tamCount; count[i] += count[i-1], i++);
+
+    //Ordenando
+    for(int i = n-1; i >= 0; ordenado[count[array[i]]-1] = array[i], count[array[i]]--, i--);
+
+    //Copiando para o array original
+    for(int i = 0; i < n; array[i] = ordenado[i], i++);
+}
+//=============================================================================
diff --git a/fonte/U4 - Ordenação em memória principal/c/countingsort.h b/fonte/U4 - Ordenação em memória principal/c/countingsort.h
index 54fff02..8c8859a 100644
--- a/fonte/U4 - Ordenação em memória principal/c/countingsort.h	
+++ b/fonte/U4 - Ordenação em memória principal/c/countingsort.h	
@@ -1,39 +1,8 @@
 #ifndef COUNTINGSORT_H
 #define COUNTINGSORT_H
 //=============================================================================
-#include "geracao.h"
+int getMaior(int *array, int n);
 //=============================================================================
-int getMaior(int *array, int n) {
-    int maior = array[0];
-
-    for (int i = 0; i < n; i++) {
-        if(maior < array[i]){
-            maior = array[i];
-        }
-    }
-    return maior;
-}
+void countingsort(int *array, int n);
 //=============================================================================
-void countingsort(int *array, int n) {
-    //Array para contar o numero de ocorrencias de cada elemento
-    int tamCount = getMaior(array, n) + 1;
-    int count[tamCount];
-    int ordenado[n];
-
-    //Inicializar cada posicao do array de contagem 
-    for (int i = 0; i < tamCount; count[i] = 0, i++);
-
-    //Agora, o count[i] contem o numero de elemento iguais a i
-    for (int i = 0; i < n; count[array[i]]++, i++);
-
-    //Agora, o count[i] contem o numero de elemento menores ou iguais a i
-    for(int i = 1; i < tamCount; count[i] += count[i-1], i++);
-
-    //Ordenando
-    for(int i = n-1; i >= 0; ordenado[count[array[i]]-1] = array[i], count[array[i]]--, i--);
-
-    //Copiando para o array original
-    for(int i = 0; i < n; array[i] = ordenado[i], i++);
-}
-//=============================================================================
-#endif
\ No newline at end of file
+#endif
diff --git a/fonte/U4 - Ordenação em memória principal/c/geracao.c b/fonte/U4 - Ordenação em memória principal/c/geracao.c
new file mode 100644
index 0000000..3caf2d3
--- /dev/null
+++ b/fonte/U4 - Ordenação em memória principal/c/geracao.c	
@@ -0,0 +1,70 @@
+#include "geracao.h"
+//=============================================================================
+#include <stdio.h>
+#include <math.h>
+#include <time.h>
+#include <stdlib.h>
+//=============================================================================
+// PROCEDIMENTO PARA TROCAR DOIS ELEMENTOS DO VETOR
+void swap(int *i, int *j) {
+   int temp = *i;
+   *i = *j;
+   *j = temp;
+}
+//=============================================================================
+// PROCEDIMENTO PARA PREENCHER UM ARRANJO COM ELEMENTOS EM ORDEM CRESCENTE
+void crescente(int *array, int n) {
+   for (int i = 0; i < n; i++) {
+      array[i] = i;
+   }
+}
+//=============================================================================
+// PROCEDIMENTO PARA PREENCHER UM ARRANJO COM ELEMENTOS EM ORDEM DECRESCENTE
+void decrescente(int *array, int n) {
+   for (int i = 0; i < n; i++) {
+      array[i] = n - 1 - i;
+   }
+}
+//=============================================================================
+// PROCEDIMENTO PARA PREENCHER UM ARRANJO COM ELEMENTOS EM ORDEM ALEATORIA
+void aleatorio(int *array, int n) {
+   crescente(array, n);
+   srand(time(NULL));
+   for (int i = 0; i < n; i++) {
+      swap(&array[i], &array[rand() % n]);
+   }
+}
+//=============================================================================
+// PROCEDIMENTO PARA PREENCHER UM ARRANJO COM ELEMENTOS DA ENTRADA PADRAO
+int entradaPadrao(int *array) {
+   int n;
+   scanf("%i", &n);
+   array = (int*) malloc(n*sizeof(int));
+   
+   for (int i = 0; i < n; i++) {
+      scanf("%i", &array[i]);
+   }
+   return n;
+}
+//=============================================================================
+// PROCEDIMENTO PARA EXIBIR OS DADOS PRESENTES NO ARRANJO
+void mostrar(int *array, int n) {
+   printf("[ ");
+   for (int i = 0; i < n; i++) {
+      printf("%d ", array[i]);
+   }
+   printf("] \n");
+}
+//=============================================================================
+// PROCEDIMENTO PARA VERIFICAR SE O ARRANJO ESTA ORDENADO
+bool isOrdenado(int *array, int n){
+   bool resp = true;
+   for(int i = 1; i < n; i++){
+      if(array[i-1] > array[i]){
+         i = n;
+         resp = false;
+      }
+   }
+   return resp;
+}
+//=============================================================================
diff --git a/fonte/U4 - Ordenação em memória principal/c/geracao.h b/fonte/U4 - Ordenação em memória principal/c/geracao.h
index ed7ee7a..a77cfb0 100644
--- a/fonte/U4 - Ordenação em memória principal/c/geracao.h	
+++ b/fonte/U4 - Ordenação em memória principal/c/geracao.h	
@@ -1,65 +1,18 @@
 #ifndef GERACAO_H
 #define GERACAO_H
 //=============================================================================
-#include <stdio.h>
-#include <math.h>
-#include <time.h>
-#include <stdlib.h>
 #include <stdbool.h>
 //=============================================================================
-// PROCEDIMENTO PARA TROCAR DOIS ELEMENTOS DO VETOR
-void swap(int *i, int *j) {
-   int temp = *i;
-   *i = *j;
-   *j = temp;
-}
+void swap(int *i, int *j);
 //=============================================================================
-// PROCEDIMENTO PARA PREENCHER UM ARRANJO COM ELEMENTOS EM ORDEM CRESCENTE
-void crescente(int *array, int n) {
-    int i;
-    for (i = 0; i < n; i++) {
-        array[i] = i;
-    }
-}
+void crescente(int *array, int n);
 //=============================================================================
-// PROCEDIMENTO PARA PREENCHER UM ARRANJO COM ELEMENTOS EM ORDEM DECRESCENTE
-void decrescente(int *array, int n) {
-    int i;
-    for (i = 0; i < n; i++) {
-        array[i] = n - 1 - i;
-    }
-}
+void decrescente(int *array, int n);
 //=============================================================================
-// PROCEDIMENTO PARA PREENCHER UM ARRANJO COM ELEMENTOS EM ORDEM ALEATORIA
-void aleatorio(int *array, int n) {
-    int i, pos;
-    crescente(array, n);
-    srand(time(NULL));
-    for (i = 0; i < n; i++) {
-        pos = rand() % n;
-        swap(&array[i], &array[pos]);
-    }
-}
+void aleatorio(int *array, int n);
 //=============================================================================
-// PROCEDIMENTO PARA EXIBIR OS DADOS PRESENTES NO ARRANJO
-void mostrar(int *array, int n) {
-    int i;
-    printf("[ ");
-    for (i = 0; i < n; i++) {
-        printf("%d ", array[i]);
-    }
-    printf("] \n");
-}
+void mostrar(int *array, int n);
 //=============================================================================
-// PROCEDIMENTO PARA VERIFICAR SE O ARRANJO ESTA ORDENADO
-bool isOrdenado(int *array, int n){
-    int i;
-    for(int i = 1; i < n; i++){
-        if(array[i-1] > array[i]){
-            return false;
-        }
-    }
-    return true;
-}
+bool isOrdenado(int *array, int n);
 //=============================================================================
 #endif
diff --git a/fonte/U4 - Ordenação em memória principal/c/heapsort.c b/fonte/U4 - Ordenação em memória principal/c/heapsort.c
new file mode 100644
index 0000000..cc9a9f4
--- /dev/null
+++ b/fonte/U4 - Ordenação em memória principal/c/heapsort.c	
@@ -0,0 +1,57 @@
+#include "heapsort.h"
+#include "geracao.h"
+//=============================================================================
+void constroi(int *array, int tamHeap){
+    for(int i = tamHeap; i > 1 && array[i] > array[i/2]; i /= 2){
+        swap(array + i, array + i/2);
+    }
+}
+//=============================================================================
+int getMaiorFilho(int *array, int i, int tamHeap){
+    int filho;
+    if (2*i == tamHeap || array[2*i] > array[2*i+1]){
+        filho = 2*i;
+    } else {
+        filho = 2*i + 1;
+    }
+    return filho;
+}
+//=============================================================================
+void reconstroi(int *array, int tamHeap){
+    int i = 1;
+    while(i <= (tamHeap/2)){
+        int filho = getMaiorFilho(array, i, tamHeap);
+        if(array[i] < array[filho]){
+            swap(array + i, array + filho);
+            i = filho;
+        }else{
+            i = tamHeap;
+        }
+    }
+}
+//=============================================================================
+void heapsort(int *array, int n) {
+    //Alterar o vetor ignorando a posicao zero
+    int arrayTmp[n+1];
+    for(int i = 0; i < n; i++){
+        arrayTmp[i+1] = array[i];
+    }
+
+    //Contrucao do heap
+    for(int tamHeap = 2; tamHeap <= n; tamHeap++){
+        constroi(arrayTmp, tamHeap);
+    }
+
+    //Ordenacao propriamente dita
+    int tamHeap = n;
+    while(tamHeap > 1){
+        swap(arrayTmp + 1, arrayTmp + tamHeap--);
+        reconstroi(arrayTmp, tamHeap);
+    }
+
+    //Alterar o vetor para voltar a posicao zero
+    for(int i = 0; i < n; i++){
+        array[i] = arrayTmp[i+1];
+    }
+}
+//=============================================================================
diff --git a/fonte/U4 - Ordenação em memória principal/c/heapsort.h b/fonte/U4 - Ordenação em memória principal/c/heapsort.h
index 52a9126..7ba67c8 100644
--- a/fonte/U4 - Ordenação em memória principal/c/heapsort.h	
+++ b/fonte/U4 - Ordenação em memória principal/c/heapsort.h	
@@ -1,60 +1,12 @@
 #ifndef HEAPSORT_H
 #define HEAPSORT_H
 //=============================================================================
-#include "geracao.h"
+void constroi(int *array, int tamHeap);
 //=============================================================================
-void constroi(int *array, int tamHeap){
-    for(int i = tamHeap; i > 1 && array[i] > array[i/2]; i /= 2){
-        swap(array + i, array + i/2);
-    }
-}
+int getMaiorFilho(int *array, int i, int tamHeap);
 //=============================================================================
-int getMaiorFilho(int *array, int i, int tamHeap){
-    int filho;
-    if (2*i == tamHeap || array[2*i] > array[2*i+1]){
-        filho = 2*i;
-    } else {
-        filho = 2*i + 1;
-    }
-    return filho;
-}
+void reconstroi(int *array, int tamHeap);
 //=============================================================================
-void reconstroi(int *array, int tamHeap){
-    int i = 1;
-    while(i <= (tamHeap/2)){
-        int filho = getMaiorFilho(array, i, tamHeap);
-        if(array[i] < array[filho]){
-            swap(array + i, array + filho);
-            i = filho;
-        }else{
-            i = tamHeap;
-        }
-    }
-}
+void heapsort(int *array, int n);
 //=============================================================================
-void heapsort(int *array, int n) {
-    //Alterar o vetor ignorando a posicao zero
-    int arrayTmp[n+1];
-    for(int i = 0; i < n; i++){
-        arrayTmp[i+1] = array[i];
-    }
-
-    //Contrucao do heap
-    for(int tamHeap = 2; tamHeap <= n; tamHeap++){
-        constroi(arrayTmp, tamHeap);
-    }
-
-    //Ordenacao propriamente dita
-    int tamHeap = n;
-    while(tamHeap > 1){
-        swap(arrayTmp + 1, arrayTmp + tamHeap--);
-        reconstroi(arrayTmp, tamHeap);
-    }
-
-    //Alterar o vetor para voltar a posicao zero
-    for(int i = 0; i < n; i++){
-        array[i] = arrayTmp[i+1];
-    }
-}
-//=============================================================================
-#endif
\ No newline at end of file
+#endif
diff --git a/fonte/U4 - Ordenação em memória principal/c/insercao.c b/fonte/U4 - Ordenação em memória principal/c/insercao.c
new file mode 100644
index 0000000..aed2972
--- /dev/null
+++ b/fonte/U4 - Ordenação em memória principal/c/insercao.c	
@@ -0,0 +1,15 @@
+#include "insercao.h"
+//=============================================================================
+void insercao(int *array, int n){
+    for (int i = 1; i < n; i++) {
+      int tmp = array[i];
+      int j = i - 1;
+
+      while ((j >= 0) && (array[j] > tmp)) {
+         array[j + 1] = array[j];
+         j--;
+      }
+      array[j+1] = tmp;
+   }
+}
+//=============================================================================
diff --git a/fonte/U4 - Ordenação em memória principal/c/insercao.h b/fonte/U4 - Ordenação em memória principal/c/insercao.h
index 2535121..431e1bb 100644
--- a/fonte/U4 - Ordenação em memória principal/c/insercao.h	
+++ b/fonte/U4 - Ordenação em memória principal/c/insercao.h	
@@ -3,18 +3,6 @@
 //=============================================================================
 #include "geracao.h"
 //=============================================================================
-void insercao(int *array, int n){
-    int i, j, tmp;
-    for (int i = 1; i < n; i++) {
-      tmp = array[i];
-      int j = i - 1;
-
-      while ((j >= 0) && (array[j] > tmp)) {
-         array[j + 1] = array[j];
-         j--;
-      }
-      array[j+1] = tmp;
-   }
-}
+void insercao(int *array, int n);
 //=============================================================================
-#endif
\ No newline at end of file
+#endif
diff --git a/fonte/U4 - Ordenação em memória principal/c/makefile b/fonte/U4 - Ordenação em memória principal/c/makefile
new file mode 100644
index 0000000..66fb756
--- /dev/null
+++ b/fonte/U4 - Ordenação em memória principal/c/makefile	
@@ -0,0 +1,40 @@
+all: exec
+ 
+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 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
+ 
+bolha.o: bolha.c 
+	gcc -o bolha.o bolha.c -c -W -Wall -pedantic
+
+countingsort.o: countingsort.c 
+	gcc -o countingsort.o countingsort.c -c -W -Wall -pedantic
+
+geracao.o: geracao.c 
+	gcc -o geracao.o geracao.c -c -W -Wall -pedantic
+
+heapsort.o: heapsort.c 
+	gcc -o heapsort.o heapsort.c -c -W -Wall -pedantic
+
+insercao.o: insercao.c 
+	gcc -o insercao.o insercao.c -c -W -Wall -pedantic
+
+mergesort.o: mergesort.c 
+	gcc -o mergesort.o mergesort.c -c -W -Wall -pedantic
+
+quicksort.o: quicksort.c 
+	gcc -o quicksort.o quicksort.c -c -W -Wall -pedantic
+
+selecao.o: selecao.c 
+	gcc -o selecao.o selecao.c -c -W -Wall -pedantic
+
+shellsort.o: shellsort.c 
+	gcc -o shellsort.o shellsort.c -c -W -Wall -pedantic
+
+clean:
+	rm -rf *.o *~ exec
+
+limpa: 
+	rm -rf *.o  
diff --git a/fonte/U4 - Ordenação em memória principal/c/mergesort.c b/fonte/U4 - Ordenação em memória principal/c/mergesort.c
new file mode 100644
index 0000000..1f6f2b3
--- /dev/null
+++ b/fonte/U4 - Ordenação em memória principal/c/mergesort.c	
@@ -0,0 +1,6 @@
+#include "mergesort.h"
+//=============================================================================
+void mergesort(int *array, int n) {
+ array[0] = n;
+}
+//=============================================================================
diff --git a/fonte/U4 - Ordenação em memória principal/c/mergesort.h b/fonte/U4 - Ordenação em memória principal/c/mergesort.h
index a3e3d1a..8fa5c20 100644
--- a/fonte/U4 - Ordenação em memória principal/c/mergesort.h	
+++ b/fonte/U4 - Ordenação em memória principal/c/mergesort.h	
@@ -3,4 +3,6 @@
 //=============================================================================
 #include "geracao.h"
 //=============================================================================
-#endif
\ No newline at end of file
+void mergesort(int *array, int n);
+//=============================================================================
+#endif
diff --git a/fonte/U4 - Ordenação em memória principal/c/principal.c b/fonte/U4 - Ordenação em memória principal/c/principal.c
index 05fab2e..ac00c3e 100644
--- a/fonte/U4 - Ordenação em memória principal/c/principal.c	
+++ b/fonte/U4 - Ordenação em memória principal/c/principal.c	
@@ -6,6 +6,11 @@
 #include "quicksort.h"
 #include "selecao.h"
 #include "shellsort.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <stdlib.h>
 //=============================================================================
 int main(int argc, char **argv) {
 
diff --git a/fonte/U4 - Ordenação em memória principal/c/quicksort.c b/fonte/U4 - Ordenação em memória principal/c/quicksort.c
new file mode 100644
index 0000000..883588a
--- /dev/null
+++ b/fonte/U4 - Ordenação em memória principal/c/quicksort.c	
@@ -0,0 +1,22 @@
+#include "quicksort.h"
+//=============================================================================
+void quicksortRec(int *array, int esq, int dir) {
+    int i = esq, j = dir;
+    int pivo = array[(dir+esq)/2];
+    while (i <= j) {
+        while (array[i] < pivo) i++;
+        while (array[j] > pivo) j--;
+        if (i <= j) {
+            swap(array + i, array + j);
+            i++;
+            j--;
+        }
+    }
+    if (esq < j)  quicksortRec(array, esq, j);
+    if (i < dir)  quicksortRec(array, i, dir);
+}
+//=============================================================================
+void quicksort(int *array, int n) {
+    quicksortRec(array, 0, n-1);
+}
+//=============================================================================
diff --git a/fonte/U4 - Ordenação em memória principal/c/quicksort.h b/fonte/U4 - Ordenação em memória principal/c/quicksort.h
index 0aba351..abacfcd 100644
--- a/fonte/U4 - Ordenação em memória principal/c/quicksort.h	
+++ b/fonte/U4 - Ordenação em memória principal/c/quicksort.h	
@@ -3,24 +3,8 @@
 //=============================================================================
 #include "geracao.h"
 //=============================================================================
-void quicksortRec(int *array, int esq, int dir) {
-    int i = esq, j = dir;
-    int pivo = array[(dir+esq)/2];
-    while (i <= j) {
-        while (array[i] < pivo) i++;
-        while (array[j] > pivo) j--;
-        if (i <= j) {
-            swap(array + i, array + j);
-            i++;
-            j--;
-        }
-    }
-    if (esq < j)  quicksortRec(array, esq, j);
-    if (i < dir)  quicksortRec(array, i, dir);
-}
+void quicksortRec(int *array, int esq, int dir);
 //=============================================================================
-void quicksort(int *array, int n) {
-    quicksortRec(array, 0, n-1);
-}
+void quicksort(int *array, int n);
 //=============================================================================
-#endif
\ No newline at end of file
+#endif
diff --git a/fonte/U4 - Ordenação em memória principal/c/selecao.c b/fonte/U4 - Ordenação em memória principal/c/selecao.c
new file mode 100644
index 0000000..c2823d5
--- /dev/null
+++ b/fonte/U4 - Ordenação em memória principal/c/selecao.c	
@@ -0,0 +1,14 @@
+#include "selecao.h"
+//=============================================================================
+void selecao(int *array, int n){
+    for (int i = 0; i < (n - 1); i++) {
+      int menor = i;
+      for (int j = (i + 1); j < n; j++){
+         if (array[menor] > array[j]){
+            menor = j;
+         }
+      }
+      swap(&array[menor], &array[i]);
+   }
+}
+//=============================================================================
diff --git a/fonte/U4 - Ordenação em memória principal/c/selecao.h b/fonte/U4 - Ordenação em memória principal/c/selecao.h
index 9383f7e..9a19155 100644
--- a/fonte/U4 - Ordenação em memória principal/c/selecao.h	
+++ b/fonte/U4 - Ordenação em memória principal/c/selecao.h	
@@ -3,16 +3,6 @@
 //=============================================================================
 #include "geracao.h"
 //=============================================================================
-void selecao(int *array, int n){
-    for (int i = 0; i < (n - 1); i++) {
-      int menor = i;
-      for (int j = (i + 1); j < n; j++){
-         if (array[menor] > array[j]){
-            menor = j;
-         }
-      }
-      swap(&array[menor], &array[i]);
-   }
-}
+void selecao(int *array, int n);
 //=============================================================================
 #endif
diff --git a/fonte/U4 - Ordenação em memória principal/c/shellsort.c b/fonte/U4 - Ordenação em memória principal/c/shellsort.c
new file mode 100644
index 0000000..8a97cf5
--- /dev/null
+++ b/fonte/U4 - Ordenação em memória principal/c/shellsort.c	
@@ -0,0 +1,27 @@
+#include "shellsort.h"
+//=============================================================================
+void insercaoPorCor(int *array, int n, int cor, int h){
+    for (int i = (h + cor); i < n; i+=h) {
+        int tmp = array[i];
+        int j = i - h;
+        while ((j >= 0) && (array[j] > tmp)) {
+            array[j + h] = array[j];
+            j-=h;
+        }
+        array[j + h] = tmp;
+    }
+}
+//=============================================================================
+void shellsort(int *array, int n) {
+    int h = 1;
+
+    do { h = (h * 3) + 1; } while (h < n);
+
+    do {
+        h /= 3;
+        for(int cor = 0; cor < h; cor++){
+            insercaoPorCor(array, n, cor, h);
+        }
+    } while (h != 1);
+}
+//=============================================================================
diff --git a/fonte/U4 - Ordenação em memória principal/c/shellsort.h b/fonte/U4 - Ordenação em memória principal/c/shellsort.h
index e9c2dea..3e019c4 100644
--- a/fonte/U4 - Ordenação em memória principal/c/shellsort.h	
+++ b/fonte/U4 - Ordenação em memória principal/c/shellsort.h	
@@ -3,29 +3,8 @@
 //=============================================================================
 #include "geracao.h"
 //=============================================================================
-void insercaoPorCor(int *array, int n, int cor, int h){
-    for (int i = (h + cor); i < n; i+=h) {
-        int tmp = array[i];
-        int j = i - h;
-        while ((j >= 0) && (array[j] > tmp)) {
-            array[j + h] = array[j];
-            j-=h;
-        }
-        array[j + h] = tmp;
-    }
-}
+void insercaoPorCor(int *array, int n, int cor, int h);
 //=============================================================================
-void shellsort(int *array, int n) {
-    int h = 1;
-
-    do { h = (h * 3) + 1; } while (h < n);
-
-    do {
-        h /= 3;
-        for(int cor = 0; cor < h; cor++){
-            insercaoPorCor(array, n, cor, h);
-        }
-    } while (h != 1);
-}
+void shellsort(int *array, int n);
 //=============================================================================
-#endif
\ No newline at end of file
+#endif
diff --git a/fonte/U4 - Ordenação em memória principal/java/Bolha.class b/fonte/U4 - Ordenação em memória principal/java/Bolha.class
new file mode 100644
index 0000000000000000000000000000000000000000..ba2338d6e22ed1fe6311094117b816254a0c83b1
GIT binary patch
literal 474
zcmZ9J&q@MO6vn?Zf1Di0OiTMSqm>cZ1V*b`Sc`%}s5VBMHeGd~DRX4hqE#E8qeTR+
zgGgx61GMb{dXJFo%n&VtxxahvcRtSjF7y8V`UYSFIUO330a8&!Fd1M<XQVY`G)xmB
zCAaBzwh3}!<%FQ@dUc18IB=WJQTM9q_{XB!U_~jE!+zWIJA`<pBWjn2qV?O=D_+;H
zIeTtk)pxwcxhP(UYhhpv(Ex^l8O$1(gK5A*mY{|%g0}DYq9!~7HF=e}BYa=n5~Nc;
zDD4~3Vy#f-`?0{$HGUZ&gM!&iollFr6Yr`$06lR*h%t3YOaltytZ)iuV9&E2bRxDn
zfb`#=hKdY3<A3Atc!JFSP5T+LQZJeJSd+Ib^8tBQ6ss6gIV(OQW?PnW_5!shQGfK=
zqfvkK5!@h!iE?559M|(m@pG0q`YPA!$no!5#yC5ZP>0ZH2$iy5Q2FC9iEzZk4++sm
AcmMzZ

literal 0
HcmV?d00001

diff --git a/fonte/U4 - Ordenação em memória principal/java/Bolha.java b/fonte/U4 - Ordenação em memória principal/java/Bolha.java
index 6bcad68..1fc0868 100644
--- a/fonte/U4 - Ordenação em memória principal/java/Bolha.java	
+++ b/fonte/U4 - Ordenação em memória principal/java/Bolha.java	
@@ -1,7 +1,7 @@
 /**
  * Metodo de ordenacao da bolha
  * @author Max do Val Machado
- * @version 2 01/2015
+ * @version 3 08/2020
  */
 class Bolha extends Geracao {
 
@@ -25,7 +25,8 @@ class Bolha extends Geracao {
 	/**
 	 * Algoritmo de ordenacao Bolha.
 	 */
-	public static void bolha() {
+   @Override
+   public void sort() {
 		for (int i = (n - 1); i > 0; i--) {
 			for (int j = 0; j < i; j++) {
 				if (array[j] > array[j + 1]) {
@@ -34,18 +35,4 @@ class Bolha extends Geracao {
 			}
 		}
    }
-
-
-	public static void main(String[] args) {
-      Bolha bolha = new Bolha(100);
-		bolha.aleatorio();
-		bolha.mostrar();
-		
-		long comeco = now();
-		bolha.bolha();
-		long fim = now();
-		
-		bolha.mostrar();
-		System.out.println("Tempo para ordenar: " + (fim-comeco)/1000.0 + " s.");
-	}
 }
diff --git a/fonte/U4 - Ordenação em memória principal/java/Countingsort.class b/fonte/U4 - Ordenação em memória principal/java/Countingsort.class
new file mode 100644
index 0000000000000000000000000000000000000000..ccd7c4f527fbf0cbb2267191ad970c31585d62f3
GIT binary patch
literal 744
zcmZ8eO=}ZT6g@BVlIct*rj2ddCK*49kT_EZU5PXeLP04sc2TJdyXZ6-!uXMqF%jGs
z|AY%An{M0)VnIrOfPcZQ8=*UQr8b^76RXI~oICH{bHC2}diLcAz-?SMp<_nDtce^-
z24POYyp9DOWr18H?1lZNfL6c0B_LO$P9RWN4|~Cb!Smf9e(3K$qes@)lK9Ig?hE8M
z`+oar%YTtXbyNf<x<S9?hf$oAS`#ogqe0vb?u9CSdNmsK`eCoD^1UbiE8oHd3<Z{j
zDNI|a!nSZpm9qXN3+VTQ*l+uhK;|*)iXK1OtRKhzYh2+rI+q0`I0X!%$<tL@L7R0B
zAU^U(V3KGeL(G$WfgW}zD*7V*Dw1<52gv--FCmLLGV_1Ri!9qp^4~k3p~;;?bKUs_
zd1$t@rtKaLk#}uvV^0(Nqo4Gs*buWWZPxa-J-L&{e#n$P<J#MvYs-!|4jiit*=gEu
zQCk|Pd9st{Z~U#(VV%+b=-YXZVnSK6y|lrx+9Z=~zQ}DsxeQ7(g=^fnh9(?5!VSE^
zO}xV`Y67@0&rsA+;44m0IEA2DNKNS!Ii70c6D8r@jV0_t;{!Nq1kGz`D^<0{5ao*U
zRJ|e0^rx|xp)lVoAI^s>Q%>LxZ*rOS8mM4}11_VEyU9?K(0;)XV*Z3TAy7;bFa8G8
C3xa|G

literal 0
HcmV?d00001

diff --git a/fonte/U4 - Ordenação em memória principal/java/Countingsort.java b/fonte/U4 - Ordenação em memória principal/java/Countingsort.java
index a742981..949700f 100644
--- a/fonte/U4 - Ordenação em memória principal/java/Countingsort.java	
+++ b/fonte/U4 - Ordenação em memória principal/java/Countingsort.java	
@@ -1,7 +1,7 @@
 /**
  * Metodo de ordenacao por contagem
  * @author Max do Val Machado
- * @version 2 01/2015
+ * @version 3 08/2020
  */
 
 class Countingsort extends Geracao {
@@ -23,26 +23,11 @@ class Countingsort extends Geracao {
    }
 
 
-	/**
-	 * Retorna o maior elemento do array.
-    * @return maior elemento
-	 */
-	public static int getMaior() {
-	   int maior = array[0];
-
-		for (int i = 0; i < n; i++) {
-         if(maior < array[i]){
-            maior = array[i];
-         }
-		}
-	   return maior;	
-	}
-
-
 	/**
 	 * Algoritmo de ordenacao Countingsort.
 	 */
-	public static void countingsort() {
+   @Override
+   public void sort() {
       //Array para contar o numero de ocorrencias de cada elemento
       int[] count = new int[getMaior() + 1];
       int[] ordenado = new int[n];
@@ -64,16 +49,18 @@ class Countingsort extends Geracao {
    }
 
 
-	public static void main(String[] args) {
-      Countingsort countingsort = new Countingsort(100);
-		countingsort.aleatorio();
-		countingsort.mostrar();
-		
-		long comeco = now();
-		countingsort.countingsort();
-		long fim = now();
-		
-		countingsort.mostrar();
-		System.out.println("Tempo para ordenar: " + (fim-comeco)/1000.0 + " s.");
+	/**
+	 * Retorna o maior elemento do array.
+    * @return maior elemento
+	 */
+	public int getMaior() {
+	   int maior = array[0];
+
+		for (int i = 0; i < n; i++) {
+         if(maior < array[i]){
+            maior = array[i];
+         }
+		}
+	   return maior;	
 	}
 }
diff --git a/fonte/U4 - Ordenação em memória principal/java/ExercicioDuvidaAND.java b/fonte/U4 - Ordenação em memória principal/java/ExercicioDuvidaAND.java
deleted file mode 100644
index 1156981..0000000
--- a/fonte/U4 - Ordenação em memória principal/java/ExercicioDuvidaAND.java	
+++ /dev/null
@@ -1,17 +0,0 @@
-class ExercicioDuvidaAND {
-   public static boolean m1(){
-      System.out.println("m1");
-      return false;
-   }
-   public static boolean m2(){
-      System.out.println("m2");
-      return true;
-   }
-   public static void main (String[] args) {
-      System.out.println("inicio");
-      boolean and = m1() && m2();
-      System.out.println("============");
-      boolean or = m2() || m1();
-      System.out.println("fim: and(" + and + ") or (" + or + ")");
-   }
-}
diff --git a/fonte/U4 - Ordenação em memória principal/java/Geracao.class b/fonte/U4 - Ordenação em memória principal/java/Geracao.class
new file mode 100644
index 0000000000000000000000000000000000000000..ee6c1c938dc0ebfa0962f3fa08dc1841c6fa6fe3
GIT binary patch
literal 2444
zcmaJ?&vO(-7=5$5$z&%32^$hH8^|IFCL7#E@CT3tl<+H%urY}s1eDIskW8{WlbV?T
z(W4wit@2{&Ef>owJ!nawz~bV~|G|@1;lc6`phSJ$v)L>pa!B`f_xHW`z1Lq)e);GA
zLjZ4J&Oj^nC9xH+$YH;Z0|pY<Cx=%JyoT2eMjcGz5Dqt>-@pI{Q_Os;0mtNGC<P5C
zbeuHMEVG(%ssX2U4C^?fp-%X|Ske%i8rGn>{Nr3d;J8kBL_@r%_q>M0kZ0K%nnoPg
zKDSt&w*5&lUE)rnXIP#mi@qHcZ8zlBrioA#=SRgtC8W`^Yfh7*WQ)-A9gmSr@P#GD
zgyjpa^~#zx^-L*Tz3c@H@ktci5DW5PSRKS&?}jRl0t_c8_?GPoix{l;l8pBJkS7z~
zqF=O6I<i#rl<kY6@N#qFx-ij>w23xsGqD{nXlRzZ`NhyF<;R6<d1Vu4F`{GC#5ojn
zjG1^_uE$MGU{bo3(eaLn^SHp|W1bhvLKjBuaMrVerh2^FfQu$BVT!R=GA1tLLIbYI
zo%b|sUSm5hLfgdq$ZE)r{`^hoSzbnD0^83x<%N=6rY97ZaYc{`7N?6P5d?OSqgfR>
ztEHEOJCiR=&)G!^*IoN&IPCHl{or**d@5vAgtOch(?N85JWY%)4HuZ?+rm;wkr^s{
zVkrpiG84Q-qP32w!W}O^<~wdU5i+IRuc2jwZC=)b3}RMKlokPo+??s}J#XMD1kKSh
z8n%_iyglT(MG;<b!dd<bLg9uiv6T(BKAXiV>=N6xu1D*Y7;UmOHVmDy!%3%X>zJ1I
zU(?W~%2nk!?sae8&Ql4iiYhoMifqs&9rUSw#PjAC*?8u#>)QTMWWR<lY9&=LqPsuM
z?kU+pSCrVlzMz_&rxGWZ7VHher)uJ(>+P>qS%DZ5rP72G+Wk5l4c+VXZB(0vozIU$
zhF_ajen?{c(D147S3<rP&YSo};S1u}!PQ|#Xq?-!ccEpQt)GlLh-I@sBKGhO;@|T`
z!w!xq<^x+ereLCl*jp9O&I-;U;=~xys&LZJhe;Er1C0dU3JK6zE$1xa3TAtJAk8A;
z%V?Ihq|=34n)da-f60PkH3fCUz#f*>O^H1e4I~l!o1OVs)win(JWfhkUuP9~n*x?3
z2`g<y_>Z2&&l7(ijmxvn{ZHdd2Vbn>Tf~nOKl=cQi+52s5+Ce{1hh+@j=mMt--Es-
z{>MV$R*X`9U!!V69WxK2fwz%DKX!BO#h{`y5qkndM}mr^RlBQ<*D6-^W$&SZcO@?^
zu6(abOiAiAk0W(|u2Ht5o|MO-;{@G1MbOje;+(~qHI*&oY$InE?Txy{UR9axlkHJM
zxvExCcJy`RB9-eXM@f8+|HcaJ!7-{SQ0e#@WvW8CM~RgUI!Bq(*!&Mjri>Ld(%AGe
z+PPH5=I*l}!F}cGBN?@61)HChdWr5{MiZ`(>oQyBDsm8OyasvYh3=`^>sA`(K$Um3
zBh%cG%^6FRyD8$9&H3B^anF)_jyF3`C+BFf%U1H9=I$i-OYGpt=A-16&#l68M3F^m
z3u@X?kosz0=1pGZ65r(q^z}oY^pYn6+s(e$7~S{)&FsuAD@c7;O|Dl*A93u%-bzBb
za>;uW1BumZ-4(H`F=6GFVen^sFg~DM|26$B5u<mxlZ5~ub9I{+^9kSTr+g-#QTlC`
z^tqDVi1-tBwAT5Uov-2Ls_EU8T9eYsmdZ6oG7TO9U((92*bh0ymxs;SAVd)}u=sg9
P!u4iG9_8MfYCQfQyMp9z

literal 0
HcmV?d00001

diff --git a/fonte/U4 - Ordenação em memória principal/java/Geracao.java b/fonte/U4 - Ordenação em memória principal/java/Geracao.java
index 6a970eb..79be4d3 100644
--- a/fonte/U4 - Ordenação em memória principal/java/Geracao.java	
+++ b/fonte/U4 - Ordenação em memória principal/java/Geracao.java	
@@ -1,14 +1,14 @@
 /**
  * Geracao de elementos de um array
  * @author Max do Val Machado
- * @version 2 01/2015
+ * @version 3 08/2020
  */
 
 import java.util.*;
 
 class Geracao {
-   protected static int[] array;
-   protected static int n;
+   protected int[] array;
+   protected int n;
 
 
 	/**
@@ -33,30 +33,31 @@ class Geracao {
 	/**
 	 * Produz um array ordenado de modo crescente.
 	 */
-	public static void crescente() {
+	public void crescente() {
 		for (int i = 0; i < n; i++) {
 			array[i] = i;
 		}
 	}
 
+
 	/**
 	 * Produz um array ordenado de modo decrescente.
 	 */
-	public static void decrescente() {
-		
+	public void decrescente() {
 		for (int i = 0; i < n; i++) {
 			array[i] = n - 1 - i;
 		}
 	}
 
+
 	/**
-	 * Produz um array de numeros aleatorios.
+	 * Produz um array com numeros aleatorios.
 	 */
-	public static void aleatorio() {
-		Random gerador = new Random();
-		
+	public void aleatorio() {
+		Random rand = new Random();
+	   crescente();	
 		for (int i = 0; i < n; i++) {
-			array[i] = Math.abs(gerador.nextInt()) % 1000; // 0 a 999
+         swap(i, Math.abs(rand.nextInt()) % n);
 		}
 	}
 
@@ -64,7 +65,7 @@ class Geracao {
 	/**
 	 * Efetua a leitura dos elementos via entrada padrao.
 	 */
-	public static void entradaPadrao() {
+	public void entradaPadrao() {
       n = MyIO.readInt();
       array = new int[n];
 
@@ -73,7 +74,10 @@ class Geracao {
 		}
 	}
 
-   public static void entrada(int[] vet){
+	/**
+	 * Recebe um Efetua a leitura dos elementos via entrada padrao.
+	 */
+   public void entrada(int[] vet){
       n = vet.length;
       array = new int[n];
       for(int i = 0; i < n; i++){
@@ -83,31 +87,31 @@ class Geracao {
 
 
 	/**
-	 * Mostra os array de um array.
+	 * Mostra os k primeiros elementos do array.
 	 * @param int k indica a quantidade de elementos do array a serem mostrados.
 	 */
-	public static void mostrar(int k) {
-		System.out.print("[ ");
+	public void mostrar(int k) {
+		System.out.print("[");
 		
 		for (int i = 0; i < k; i++) {
-			System.out.print(array[i] + " ");
+         System.out.print(" ("+i+")" + array[i]);
 		}
 		
-		System.out.println("] ");
+		System.out.println("]");
 	}
 
 
 	/**
-	 * Mostra os array de um array.
+	 * Mostra os elementos do array.
 	 */
-   public static void mostrar() {
-      System.out.print("[ ");
+   public void mostrar() {
+      System.out.print("[");
 
       for (int i = 0; i < n; i++) {
-         System.out.print("("+i+")" + array[i] + " ");
+         System.out.print(" ("+i+")" + array[i]);
       }
 
-      System.out.println("] ");
+      System.out.println("]");
    }
 
 
@@ -116,7 +120,7 @@ class Geracao {
     * @param i int primeira posicao
     * @param j int segunda posicao
     */
-   public static void swap(int i, int j) {
+   public void swap(int i, int j) {
       int temp = array[i];
       array[i] = array[j];
       array[j] = temp;
@@ -127,7 +131,7 @@ class Geracao {
     * Retorna o timestamp atual
     * @return timestamp atual
     */
-   public static long now(){
+   public long now(){
       return new Date().getTime();
    }
 
@@ -136,7 +140,7 @@ class Geracao {
     * Retorna verdadeiro/falso indicando se o array esta ordenado
     * @return boolean indicando se o array esta ordenado
     */
-   public static boolean isOrdenado(){
+   public boolean isOrdenado(){
       boolean resp = true;
       for(int i = 1; i < n; i++){
          if(array[i] < array[i-1]){
diff --git a/fonte/U4 - Ordenação em memória principal/java/Heapsort.class b/fonte/U4 - Ordenação em memória principal/java/Heapsort.class
new file mode 100644
index 0000000000000000000000000000000000000000..a8512d29016aab55c40ef492a9e3462ed60455c4
GIT binary patch
literal 1045
zcmZ8f+fEZv6kTUJ)638TR&Lre+{&e$YBlltK<fhvlz;{yB!*}h>O`uwB}37e=#%`1
z36S)~7ZZiV5I?{V@X-%2G4a_{>pDY86Vr6<ea_xzuXWa$uYW&(0dNCp6DH0nI3Ga-
z2?f$5SPBLe3@I26VI+i6f#6iBQmW+z0;%+>fIeM)><V-(lq&Aso#z{_x8iJ+xud5F
zeto;@)dXV8HK+J&(b@8=AtVLD#cE}{=2c4qrsuX7u_tbA(J58EnNoSPDqy4vg>->U
z%hesP=yI3SV{@*vrAB9;Ixn0kIuKRR6~!3FqnJQ4inD4tiBuFlD(gibNl(uSgl1jO
zDLQ1();L~N_-8a6&vRZ;|Mp8~tHr*GVOn6)Fdzt_*oZN%Mi>R7VIM(!U?R{-G@%h=
z(796WT}0JB%6(M{+KD4*|M&O7KtDUXPsa;`J39M!?T-lP>&NCoASYG6hn|eo*O}@v
zdv8}0_2v&d^9j0fQr}0XEe~P%m0#*aPU;8fv30qtH4iC()lj|pQ%zW~Rl~8#<AJ=T
za*kI8D`V;F93N2Qm0Hce-8|yVl_euIc@%?;WBjG*_7$XXlQEAAn8roSA&Vtk!UI+w
z;VL$94IZxJ4dYvOp5de+g#Vx;gt+*Pfd+yM@dk9!+d#M4q9uIGmW69HB)~(dgny%?
z(kZh(8s+Q(;<l7VnKvZn>do(M*>T^>DbCAL{1ipr^64Yc8qi2IMhbo^Euz<?QQlwH
zb24F+_mQ?`;t=6{o6*YdDW5H}S-Col1PQ;j2`A_f=z@mZ%<k}AXL#3HjMEhx^K@u|
z&Mf*OI-x5O4NOvq(5QjmYfH&P>QG8DMq*RG!+;XN)W0+%pXdN4lYAW!f1S79v;E|;
ePHw#fiTg-mg^#rA6NV9x!3GTV{r3Ca1OEV&1g2&H

literal 0
HcmV?d00001

diff --git a/fonte/U4 - Ordenação em memória principal/java/Heapsort.java b/fonte/U4 - Ordenação em memória principal/java/Heapsort.java
index 293162c..3ace99f 100644
--- a/fonte/U4 - Ordenação em memória principal/java/Heapsort.java	
+++ b/fonte/U4 - Ordenação em memória principal/java/Heapsort.java	
@@ -1,61 +1,33 @@
 /**
  * Algoritmo de ordenacao Heapsort
  * @author Max do Val Machado
- * @version 2 01/2015
+ * @version 3 08/2020
  */
 
 class Heapsort extends Geracao {
 
-	/**
-	 * Construtor.
-	 */
+   /**
+    * Construtor.
+    */
    public Heapsort(){
       super();
    }
 
 
-	/**
-	 * Construtor.
-	 * @param int tamanho do array de numeros inteiros.
-	 */
+   /**
+    * Construtor.
+    * @param int tamanho do array de numeros inteiros.
+    */
    public Heapsort(int tamanho){
       super(tamanho);
    }
 
 
-   public static void constroi(int tamHeap){
-      for(int i = tamHeap; i > 1 && array[i] > array[i/2]; i /= 2){
-         swap(i, i/2);
-      }
-   }
-
-  public static void reconstroi(int tamHeap){
-      int i = 1;
-      while(i <= (tamHeap/2)){
-         int filho = getMaiorFilho(i, tamHeap);
-         if(array[i] < array[filho]){
-            swap(i, filho);
-            i = filho;
-         }else{
-            i = tamHeap;
-         }
-      }
-   }
-
-   public static int getMaiorFilho(int i, int tamHeap){
-      int filho;
-      if (2*i == tamHeap || array[2*i] > array[2*i+1]){
-         filho = 2*i;
-      } else {
-         filho = 2*i + 1;
-      }
-      return filho;
-   }
-
-	/**
-	 * Algoritmo de ordenacao Heapsort.
-	 */
-	public static void heapsort() {
+   /**
+    * Algoritmo de ordenacao Heapsort.
+    */
+   @Override
+   public void sort() {
       //Alterar o vetor ignorando a posicao zero
       int[] tmp = new int[n+1];
       for(int i = 0; i < n; i++){
@@ -84,17 +56,33 @@ class Heapsort extends Geracao {
    }
 
 
-	public static void main(String[] args) {
-      Heapsort heapsort = new Heapsort(200);
-		heapsort.aleatorio();
-		heapsort.mostrar();
-		
-		long comeco = now();
-		heapsort.heapsort();
-		long fim = now();
-		
-		//heapsort.mostrar();
-      System.out.println("Ordenado: " + heapsort.isOrdenado());
-		System.out.println("Tempo para ordenar: " + (fim-comeco)/1000.0 + " s.");
-	}
+   public void constroi(int tamHeap){
+      for(int i = tamHeap; i > 1 && array[i] > array[i/2]; i /= 2){
+         swap(i, i/2);
+      }
+   }
+
+
+   public void reconstroi(int tamHeap){
+      int i = 1;
+      while(i <= (tamHeap/2)){
+         int filho = getMaiorFilho(i, tamHeap);
+         if(array[i] < array[filho]){
+            swap(i, filho);
+            i = filho;
+         }else{
+            i = tamHeap;
+         }
+      }
+   }
+
+   public int getMaiorFilho(int i, int tamHeap){
+      int filho;
+      if (2*i == tamHeap || array[2*i] > array[2*i+1]){
+         filho = 2*i;
+      } else {
+         filho = 2*i + 1;
+      }
+      return filho;
+   }
 }
diff --git a/fonte/U4 - Ordenação em memória principal/java/Insercao.class b/fonte/U4 - Ordenação em memória principal/java/Insercao.class
new file mode 100644
index 0000000000000000000000000000000000000000..b1eaf605bf7ded7d4382c7f82421cdb3dc664950
GIT binary patch
literal 476
zcmZ8eyG{a85IwVddAfk0fC@zL2^1t&Hi#xBkWEwyjE#*K*kXMwW&sm>KEck;m{6OT
zkXUH%U-%amD$cHGVQ%i3xo1vh=H$M9Jv{^1#6l2WOgj(_z=N0rGd|4v5GQ!cre*dj
z1T|kcB8c5i+aN^tOv^avUo;K-P&Ut*5qaIMcRO~E5Nh;f>ug_MPO8C1r*F56s_95W
zy45x8mh6;H<(1UngWrKE4GAPQ%weA3|J4wDHN%#yCXmHfCwQc7%WHyitRu_Idf5h`
zg0=872KbfZNE|)I5$J&vLXa^Cg)szyFf%-q(UC7P?^L|S)CkIdeS(K1S*iWCzu^vo
z^)*pW6(6DAVVi?Um9|o%UCG=c=R7l|^gWVpCQg2c`am5I$8QrZT^|q)$1l!6#a(dC
tU1yQ=ETZfpj%7Y8*uW}()jD>th$;$f0f<0+K%q~>h;r|)qp;g3@(o^|NWK67

literal 0
HcmV?d00001

diff --git a/fonte/U4 - Ordenação em memória principal/java/Insercao.java b/fonte/U4 - Ordenação em memória principal/java/Insercao.java
index 753761e..a98de08 100644
--- a/fonte/U4 - Ordenação em memória principal/java/Insercao.java	
+++ b/fonte/U4 - Ordenação em memória principal/java/Insercao.java	
@@ -1,7 +1,7 @@
 /**
  * Algoritmo de ordenacao por insercao
  * @author Max do Val Machado
- * @version 2 01/2015
+ * @version 3 01/2020
  */
 
 class Insercao extends Geracao {
@@ -26,7 +26,8 @@ class Insercao extends Geracao {
 	/**
 	 * Algoritmo de ordenacao por insercao.
 	 */
-	public static void insercao() {
+   @Override
+   public void sort() {
 		for (int i = 1; i < n; i++) {
 			int tmp = array[i];
          int j = i - 1;
@@ -38,18 +39,4 @@ class Insercao extends Geracao {
          array[j + 1] = tmp;
       }
 	}
-
-
-	public static void main(String[] args) {
-		Insercao insercao = new Insercao(1000000);
-		insercao.aleatorio();
-		//insercao.mostrar();
-
-		long comeco = now();
-		insercao.insercao();
-		long fim = now();
-
-		//insercao.mostrar();
-		System.out.println("Tempo para ordenar: " + (fim-comeco)/1000.0 + " s.");
-	}
 }
diff --git a/fonte/U4 - Ordenação em memória principal/java/Mergesort.class b/fonte/U4 - Ordenação em memória principal/java/Mergesort.class
new file mode 100644
index 0000000000000000000000000000000000000000..59221240092e7c3c58c6ad4905950bf99b9c0bf1
GIT binary patch
literal 357
zcmZvWPfJ2U6vfYdfA!^`G89CJY7s9NZrengAQ8%q;(oLtUZf8u?R&WrTKEC{P|~?d
z65%Y)y>riR&YjKndkx?Y=LrH-RZe4^#i$9Q`)roY9|V4SI}!ws`KuLFpR<|mFQ#Mb
zhGzW1Ns#t-{%7vyg5uP=H@ok{w70X8LB4Pk`;;kOdHDr8@8-*t5F%13^6kMA#9iym
z#N@by&tK^YAPQ4s-mX}MHEgdSOE!W6HGxMh5iWDWSgPXJoU0SHTPt|~`8vr4$>b2<
dB&+d%qIENH!I%>+*vBg7AH!}4lxcXV`~X(+EgS#<

literal 0
HcmV?d00001

diff --git a/fonte/U4 - Ordenação em memória principal/java/Mergesort.java b/fonte/U4 - Ordenação em memória principal/java/Mergesort.java
new file mode 100644
index 0000000..2662cbb
--- /dev/null
+++ b/fonte/U4 - Ordenação em memória principal/java/Mergesort.java	
@@ -0,0 +1,39 @@
+/**
+ * Algoritmo de ordenacao Mergesort
+ * @author Max do Val Machado
+ * @version 3 08/2020
+ */
+class Mergesort extends Geracao {
+
+	/**
+	 * Construtor.
+	 */
+   public Mergesort(){
+      super();
+   }
+
+
+	/**
+	 * Construtor.
+	 * @param int tamanho do array de numeros inteiros.
+	 */
+   public Mergesort(int tamanho){
+      super(tamanho);
+   }
+
+
+	/**
+	 * Algoritmo de ordenacao Mergesort.
+	 */
+   @Override
+   public void sort() {
+   }
+
+	/**
+	 * Algoritmo de ordenacao Mergesort.
+    * @param int esq inicio do array a ser ordenado
+    * @param int dir fim do array a ser ordenado
+	 */
+    private void mergesort(int esq, int dir) {
+    }
+}
diff --git a/fonte/U4 - Ordenação em memória principal/java/Principal.class b/fonte/U4 - Ordenação em memória principal/java/Principal.class
new file mode 100644
index 0000000000000000000000000000000000000000..2977650c2d524ac9a827e80becb7ef73b927e27a
GIT binary patch
literal 1258
zcmaJ>%Tg0T6g{1gOfn9y@K(U6fJuO$_&^9C5?;aZutI5xt0w6R1C#00%z(u&xN)g#
zH?DO77FO{Aeu-aUc{`y@C{oT;ci*{vPoI0bZ_lqk=NAB`@JdG;ZtA#&ehmXU{20`6
z8&TEWQQh4z?qMjn@Nt3Sfe5vjjyMu(ax?;laScfg6AZyw(>A?%27fI6nxQEz3xc6F
zYuaM-sI(`X9lmFgr>VqEo1r`QE_=X_`Gm#o;zZ7KOuLv;z~-FC^M@O}d>OCj<dKsX
zE2aXsY*Sp`EORTVzy{h8(eS{)LrgMgIbn%Bm&*M}!(#(a5Hau+QwE-?z-a?BNHMf6
zO6j?t!^<1O+m{8mHHg^|<_yf^xrPM;FR*AJjinHlm2-t5{EwROwamBn4n*E#Xs@|4
zwkL|hVF;DE;|ls@=!!K^o1xu^Wt3=bRXCh7CmL=E?n%ca+i%PFmHk|&Kvz1nP91aZ
z#Pvjp=H-zhsIG6y36-Zu8!C7yrDGLq481#|RF+XnhexGT5H@#aqAcnr8G1_mP^6`u
z=iVFB+b7HQxb3+r<)!%bq!~IYO0N=;g0iBu=wus8C5^i2ZdJGoN?I(wOJ`kkQ9cT~
z+kjF-MxDV1!%%ILP5W3Lip#>O=D))8v~edIwx}AjQXU?a8H|i=3ny)H*A*n{bNxA7
zu2HRlHEtIy;SN=Ssq4z?JXe4_CuPwfyuQ4vMUtx5cDY2FTUO5WL`uUp!|*kIjdEic
z{C^yxXr+s-9v?NjBXm(a$Qq!L(HKaafqf%`p_BSx#Ti5xUFarTg?>T+8jU-Ni>5CK
zxBGv8ML6M~`~lzGPx#;VpP?x`dWrzG;D>eUwTd+z_>NF-AYSZ5Sf1ksa0-K5G}(NP
zmddAM_Enfih!YglLA?F+8;W8WBlIS4pRV*6mN1SSlIWqR0DQ(WRStS9@IGW|)G6I{
TY~m&Q2nr(b5u6cR^<#elJ^3;t

literal 0
HcmV?d00001

diff --git a/fonte/U4 - Ordenação em memória principal/java/Principal.java b/fonte/U4 - Ordenação em memória principal/java/Principal.java
index 2ffcd73..0de9c4c 100644
--- a/fonte/U4 - Ordenação em memória principal/java/Principal.java	
+++ b/fonte/U4 - Ordenação em memória principal/java/Principal.java	
@@ -1,10 +1,10 @@
 /**
  * Classe Principal
  * @author Max do Val Machado
- * @version 3 02/2020
+ * @version 3 08/2020
  */
 class Principal {
-	public static void main(String[] args) throws Exception {
+	public static void main(String[] args) {
 
       //Delcaracao de variaveis
       Geracao algoritmo;
diff --git a/fonte/U4 - Ordenação em memória principal/java/Quicksort.class b/fonte/U4 - Ordenação em memória principal/java/Quicksort.class
new file mode 100644
index 0000000000000000000000000000000000000000..0f06cdc52e9b500578a471cdae2875c0baaabd60
GIT binary patch
literal 624
zcmZ8d!D`e{6g@Y2Z{oyEJENvmleE^2Y19#_RFF~x!7`$vRNP3RuhW3Bb*82>ihIAL
z3SA4*f(t=#<=P+759oMa9J^@XoqON8=iK{leja`O2H-a4e4N5L3t=4|rhLM*&Cc8G
zf`^M9B0+7b=oN!yft$`h7pQyv&0H|~u;}HFhp#vC@|oG#CZp0$Rp0HG13~@Gu;_06
z%XQkRN{!Wl>25tTJ7b5x+8>tP{C;8W6Hose+ON!86QB;?LL)$oB)}w^0cJ28;1Zhb
ze=HYxD|u<UrZ12lPe-6lS(^6(=LIin_nq0H%j2f@Q=lC_@icF9jKZk1L&#?)f`I75
zAqEsT$nY6NE5A(MR%%&v2<N0egvJz=6UXh-Y8*RdZuSMP+B|?d>6&5ZS$5@$<0;?a
zqQ)sjv>Y!g8g(44>+SZUPD1q&OO{F6q25FNgDd-^Kb8m;nNMWYXn*wE3P-;(h6B_n
zs@NY<sP^Dz417lt)1M{r_(@K+_(FwOxJZf?<}r<o*;U-ZHQdE@te}ktxPd2Fz#4Ai
ZC2mm%uIwG5B_g`n3IqFh&yaO+_Ak)VUhn__

literal 0
HcmV?d00001

diff --git a/fonte/U4 - Ordenação em memória principal/java/Quicksort.java b/fonte/U4 - Ordenação em memória principal/java/Quicksort.java
index 24d4e15..7aa9fcd 100644
--- a/fonte/U4 - Ordenação em memória principal/java/Quicksort.java	
+++ b/fonte/U4 - Ordenação em memória principal/java/Quicksort.java	
@@ -1,7 +1,7 @@
 /**
  * Algoritmo de ordenacao Quicksort
  * @author Max do Val Machado
- * @version 2 01/2015
+ * @version 3 08/2020
  */
 class Quicksort extends Geracao {
 
@@ -25,7 +25,8 @@ class Quicksort extends Geracao {
 	/**
 	 * Algoritmo de ordenacao Quicksort.
 	 */
-	public static void quicksort() {
+   @Override
+   public void sort() {
       quicksort(0, n-1);
    }
 
@@ -34,7 +35,7 @@ class Quicksort extends Geracao {
     * @param int esq inicio do array a ser ordenado
     * @param int dir fim do array a ser ordenado
 	 */
-    private static void quicksort(int esq, int dir) {
+    private void quicksort(int esq, int dir) {
         int i = esq, j = dir;
         int pivo = array[(dir+esq)/2];
         while (i <= j) {
@@ -49,18 +50,4 @@ class Quicksort extends Geracao {
         if (esq < j)  quicksort(esq, j);
         if (i < dir)  quicksort(i, dir);
     }
- 
-
-	public static void main(String[] args) throws Exception {
-      Quicksort quicksort = new Quicksort(10000000);
-		quicksort.aleatorio();
-		//quicksort.mostrar();
-		
-		long comeco = now();
-		quicksort.quicksort();
-		long fim = now();
-
-		//quicksort.mostrar();
-		System.out.println("Tempo para ordenar: " + (fim-comeco)/1000.0 + " s.");
-	}
 }
diff --git a/fonte/U4 - Ordenação em memória principal/java/Selecao.class b/fonte/U4 - Ordenação em memória principal/java/Selecao.class
new file mode 100644
index 0000000000000000000000000000000000000000..70c5da2fcb497cf2d715a10646964d41a2834608
GIT binary patch
literal 493
zcmZ8eIZFdU7=7O!SzR|C@y;fmAe$8ef?#9P2ueV0A~rUT$rkZQ!X_&A*8T_)tOZf9
zuoi!Ze?swk6M}`syzhGR=FQCO_tP_g6->EsFr*>Xiv)%>jJSkR2V)M#1&P&Kz1A)Y
z%pkWbu+|#YNHDNjt4G_XCkIiyqYjSQv4T=(-fF~cL9*Odm7^`y>`vWs<20^B>oraF
z%F%IDQH}heI#V8c(5u1oFo8)AY4{#8$O@b;kJ&~PEA9|TovS3URUE4efw9NJYMrYl
zdqIgFFhlzeZwHtVtxj}V%`yt39X>+tm<alaE(~H47W&zt52B{ev9BkI(0_#SpFaj0
z<76iP<ga*~MSjs-^}~CZR`nXoe!;i)i&<S?Bh6rC@*1=G8`#;xr75>RZ(+uNfPE><
zU-UUf$JYXtfob}gp|e@O%N%l;$0GA3Eb#NDQ9!^Mkb?aQL%uK|GVuZXoeKP<j@IBW
Dy-P_c

literal 0
HcmV?d00001

diff --git a/fonte/U4 - Ordenação em memória principal/java/Selecao.java b/fonte/U4 - Ordenação em memória principal/java/Selecao.java
index d72dbe9..5eb0117 100644
--- a/fonte/U4 - Ordenação em memória principal/java/Selecao.java	
+++ b/fonte/U4 - Ordenação em memória principal/java/Selecao.java	
@@ -1,7 +1,7 @@
 /**
  * Algoritmo de ordenacao por selecao
  * @author Max do Val Machado
- * @version 3 02/2020
+ * @version 3 08/2020
  */
 
 class Selecao extends Geracao {
diff --git a/fonte/U4 - Ordenação em memória principal/java/Shellsort.class b/fonte/U4 - Ordenação em memória principal/java/Shellsort.class
new file mode 100644
index 0000000000000000000000000000000000000000..33055f755bff8e2f2c4ad17a76e3cf31aeff9db6
GIT binary patch
literal 659
zcmZ8fO>fgc5PjpUZDO3Hg}9}x4YZ=gu^<ONf`E`qBv7Q%B8B$SOWf2_4IxHug2bJF
z!37FZ&LBi34*UTA0l$Dd5)wiMGiyqbDr?`&&OE<;<Mrp?A3p)Ojx!caoK#RP!hmBj
z%&2VE#3>VV1fv-b<57!H@N4S?(N4A^LS;D~Ml0jTn^F28+#GO4_?^7JlcXa;sXGe$
zkM4y}4!Y%dxD%!QFu9+k?Ib1WekbQ!-DI5hqdT$ED0jD`!9Xe0ABImu8^=&oVB0ti
zX`_NE8!kLT@sLR{??!3J(gYgv>acj2rr|S!w$Z^k9>(NZ0Rd8ij27?aITA-b*aN-g
zgm9eEg2q^4a+xc9G^3&~a9wqbK<+_1%AbLbS!R|F<;N)S16&eKX>5yLQwHx*c$IyZ
z#-Lfa?aEzL0#|;3c&^bT`zFQ9?5mR1avKYLG;o%8^O(YURIvz&CEhLK0(@LVjSYgA
z*oQ`?edzR)nS3)jD$B2V2!rFgD|;<Z9lwiZ4!T!w2+!SW=#KsZzN$ES-4So#{>|Oq
zL2cF16>XAz`PXp7s^|7vlkDApuS+~MaG5{V74~@*bGU{84cz4atBo62;ocf<<$f#5
Uub^M364icSnhj6$%NkDn0W<n%h5!Hn

literal 0
HcmV?d00001

diff --git a/fonte/U4 - Ordenação em memória principal/java/Shellsort.java b/fonte/U4 - Ordenação em memória principal/java/Shellsort.java
index 77353d9..dd86c77 100644
--- a/fonte/U4 - Ordenação em memória principal/java/Shellsort.java	
+++ b/fonte/U4 - Ordenação em memória principal/java/Shellsort.java	
@@ -1,7 +1,7 @@
 /**
  * Algoritmo de ordenacao Shellsort
  * @author Max do Val Machado
- * @version 2 01/2015
+ * @version 3 08/2020
  */
 
 class Shellsort extends Geracao {
@@ -26,7 +26,8 @@ class Shellsort extends Geracao {
    /**
     * Algoritmo de ordenacao Shellsort.
     */
-   public static void shellsort() {
+   @Override
+   public void sort() {
       int h = 1;
 
       do { h = (h * 3) + 1; } while (h < n);
@@ -45,7 +46,7 @@ class Shellsort extends Geracao {
     * @param int cor cor do pseudo array.
     * @param int h passo do shelsort
     */
-   public static void insercaoPorCor(int cor, int h){
+   public void insercaoPorCor(int cor, int h){
       for (int i = (h + cor); i < n; i+=h) {
          int tmp = array[i];
          int j = i - h;
@@ -56,18 +57,4 @@ class Shellsort extends Geracao {
          array[j + h] = tmp;
       }
    }
-
-
-   public static void main(String[] args) {
-      Shellsort shellsort = new Shellsort(100000000);
-      shellsort.aleatorio();
-      //shellsort.mostrar();
-
-      long comeco = now();
-      shellsort.shellsort();
-      long fim = now();
-
-      //shellsort.mostrar();
-      System.out.println("Tempo para ordenar: " + (fim-comeco)/1000.0 + " s.");
-   }
 }
diff --git a/fonte/U6 - Árvores binárias/c/arvoreBinariaC/no.o b/fonte/U6 - Árvores binárias/c/arvoreBinariaC/no.o
deleted file mode 100644
index fe1bf71522f46a5b28f130345f46e87bd06c3f0e..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1592
zcmbtTL2J}d5T0ymyJ}ZgQ4lH;5T%NJZ1ti&NZK{KL6#P@3tl8-*J!~_vShQ;D&j#A
zmtOoE-uwp&9>kk}Lh!H`@v?|eXOcJVOUzz$U@|k`n{VFa&3iAbR->e8z@ouTIEWYp
zn3N8DGjUC*z&!jse(qP>9(}W4j*Zdt@rN_G_MO)4ku|Y*t;ueCJgSmoe>Tg>Lh4u9
z|MCf%_4<mj*zOF2cxc=Z*F<e;xi(C~tCv!MvPou8iFydNx!wkB>my-0D#@wTfcEqb
zXxmk7VScXs7Juk0;-n<E=wltLzAn`(v(GSr;weIBF#|vLik9`llcHX@n=DIDy3b-1
z=`i~@nBa3$@Zyg3<W#a0s(e!EGx>MKDyYc_vgvSs3JyUiy7+k#u7}_>TN`VuEoY<A
zxNB`Xo2zRr%K_i*^}?>KcUoGS%~90fd#M-_r|YC#DF89p@ng4xHjYxe#a`s~ToHTQ
zF^C6l?1JbF1|Yhj?|T7aK^S`i@50g`cDs*d{3sZTeiZh-DBb~)RPeT(hmq@hvV;FK
z2GZ$n<R@n$M#ATuMrkhlWEW8BY)n*D?#V-;cSLdomG<F@Gk#Ix`J46%@gkubs$9W<
zYW^#K8M#!mhN=qhe?bM&=l$8PD43f1P7M^Fc?{h~hh9hK4q^OWCK%GP;q&9TgAUcq
z^S{c3>zpWUo_`<lqWSd;=0{xS^ZbhTrmf2IM-6G|?Hn%P6PBMHLa-?Jzf6H5vfMs$
R0=**s8_DnOXQob`{|ECsbrS#p

diff --git a/fonte/U6 - Árvores binárias/c/arvoreBinariaCC/arvorebinaria.cc b/fonte/U6 - Árvores binárias/cc/arvoreBinariaCC/arvorebinaria.cc
similarity index 100%
rename from fonte/U6 - Árvores binárias/c/arvoreBinariaCC/arvorebinaria.cc
rename to fonte/U6 - Árvores binárias/cc/arvoreBinariaCC/arvorebinaria.cc
diff --git a/fonte/U6 - Árvores binárias/c/arvoreBinariaCC/arvorebinaria.h b/fonte/U6 - Árvores binárias/cc/arvoreBinariaCC/arvorebinaria.h
similarity index 100%
rename from fonte/U6 - Árvores binárias/c/arvoreBinariaCC/arvorebinaria.h
rename to fonte/U6 - Árvores binárias/cc/arvoreBinariaCC/arvorebinaria.h
diff --git a/fonte/U6 - Árvores binárias/c/arvoreBinariaCC/makefile b/fonte/U6 - Árvores binárias/cc/arvoreBinariaCC/makefile
similarity index 100%
rename from fonte/U6 - Árvores binárias/c/arvoreBinariaCC/makefile
rename to fonte/U6 - Árvores binárias/cc/arvoreBinariaCC/makefile
diff --git a/fonte/U6 - Árvores binárias/c/arvoreBinariaCC/no.cc b/fonte/U6 - Árvores binárias/cc/arvoreBinariaCC/no.cc
similarity index 100%
rename from fonte/U6 - Árvores binárias/c/arvoreBinariaCC/no.cc
rename to fonte/U6 - Árvores binárias/cc/arvoreBinariaCC/no.cc
diff --git a/fonte/U6 - Árvores binárias/c/arvoreBinariaCC/no.h b/fonte/U6 - Árvores binárias/cc/arvoreBinariaCC/no.h
similarity index 100%
rename from fonte/U6 - Árvores binárias/c/arvoreBinariaCC/no.h
rename to fonte/U6 - Árvores binárias/cc/arvoreBinariaCC/no.h
diff --git a/fonte/U6 - Árvores binárias/c/arvoreBinariaCC/principal.cc b/fonte/U6 - Árvores binárias/cc/arvoreBinariaCC/principal.cc
similarity index 100%
rename from fonte/U6 - Árvores binárias/c/arvoreBinariaCC/principal.cc
rename to fonte/U6 - Árvores binárias/cc/arvoreBinariaCC/principal.cc