silva
/
aeds2
mirror of https://github.com/viniciusfdasilva/aeds2.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #6 from icei-pucminas/ordenacao-header-c 

Atualização nos algoritmos de ordenação
This commit is contained in:
Max do Val Machado 2020-08-23 20:53:54 -03:00 committed by GitHub
parent 124e3db849 d2b47cd023
commit ff7968080e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
50 changed files with 478 additions and 481 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
fonte/U4 - Ordenação em memória principal/c/bolha.c Normal file
View File

@ -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]);
}
}
}
}
//=============================================================================

13
fonte/U4 - Ordenação em memória principal/c/bolha.h
View File

@ -1,17 +1,6 @@
#ifndef BOLHA_H
#define BOLHA_H
//=============================================================================
#include "geracao.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]);
}
}
}
}
void bolha(int *array, int n);
//=============================================================================
#endif

BIN
fonte/U4 - Ordenação em memória principal/c/bolha.o Normal file
View File

Binary file not shown.

64
fonte/U4 - Ordenação em memória principal/c/bolha_teste.c
View File

@ -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;
}

36
fonte/U4 - Ordenação em memória principal/c/countingsort.c Normal file
View File

@ -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++);
}
//=============================================================================

35
fonte/U4 - Ordenação em memória principal/c/countingsort.h
View File

@ -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) {
//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++);
}
void countingsort(int *array, int n);
//=============================================================================
#endif

70
fonte/U4 - Ordenação em memória principal/c/geracao.c Normal file
View File

@ -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;
}
//=============================================================================

59
fonte/U4 - Ordenação em memória principal/c/geracao.h
View File

@ -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

57
fonte/U4 - Ordenação em memória principal/c/heapsort.c Normal file
View File

@ -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];
}
}
//=============================================================================

56
fonte/U4 - Ordenação em memória principal/c/heapsort.h
View File

@ -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) {
//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];
}
}
void heapsort(int *array, int n);
//=============================================================================
#endif

15
fonte/U4 - Ordenação em memória principal/c/insercao.c Normal file
View File

@ -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;
}
}
//=============================================================================

14
fonte/U4 - Ordenação em memória principal/c/insercao.h
View File

@ -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

40
fonte/U4 - Ordenação em memória principal/c/makefile Normal file
View File

@ -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

6
fonte/U4 - Ordenação em memória principal/c/mergesort.c Normal file
View File

@ -0,0 +1,6 @@
#include "mergesort.h"
//=============================================================================
void mergesort(int *array, int n) {
array[0] = n;
}
//=============================================================================

2
fonte/U4 - Ordenação em memória principal/c/mergesort.h
View File

@ -3,4 +3,6 @@
//=============================================================================
#include "geracao.h"
//=============================================================================
void mergesort(int *array, int n);
//=============================================================================
#endif

5
fonte/U4 - Ordenação em memória principal/c/principal.c
View File

@ -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) {

22
fonte/U4 - Ordenação em memória principal/c/quicksort.c Normal file
View File

@ -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);
}
//=============================================================================

20
fonte/U4 - Ordenação em memória principal/c/quicksort.h
View File

@ -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

14
fonte/U4 - Ordenação em memória principal/c/selecao.c Normal file
View File

@ -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]);
}
}
//=============================================================================

12
fonte/U4 - Ordenação em memória principal/c/selecao.h
View File

@ -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

27
fonte/U4 - Ordenação em memória principal/c/shellsort.c Normal file
View File

@ -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);
}
//=============================================================================

25
fonte/U4 - Ordenação em memória principal/c/shellsort.h
View File

@ -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

BIN
fonte/U4 - Ordenação em memória principal/java/Bolha.class Normal file
View File

Binary file not shown.

19
fonte/U4 - Ordenação em memória principal/java/Bolha.java
View File

@ -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.");
}
}

BIN
fonte/U4 - Ordenação em memória principal/java/Countingsort.class Normal file
View File

Binary file not shown.

43
fonte/U4 - Ordenação em memória principal/java/Countingsort.java
View File

@ -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();
/**
* Retorna o maior elemento do array.
* @return maior elemento
*/
public int getMaior() {
int maior = array[0];
long comeco = now();
countingsort.countingsort();
long fim = now();
countingsort.mostrar();
System.out.println("Tempo para ordenar: " + (fim-comeco)/1000.0 + " s.");
for (int i = 0; i < n; i++) {
if(maior < array[i]){
maior = array[i];
}
}
return maior;
}
}

17
fonte/U4 - Ordenação em memória principal/java/ExercicioDuvidaAND.java
View File

@ -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 + ")");
}
}

BIN
fonte/U4 - Ordenação em memória principal/java/Geracao.class Normal file
View File

Binary file not shown.

50
fonte/U4 - Ordenação em memória principal/java/Geracao.java
View File

@ -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.
*/
public static void aleatorio() {
Random gerador = new Random();
/**
* Produz um array com numeros aleatorios.
*/
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,14 +87,14 @@ 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) {
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("]");
@ -98,13 +102,13 @@ class Geracao {
/**
* Mostra os array de um array.
* Mostra os elementos do array.
*/
public static void mostrar() {
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("]");
@ -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]){

BIN
fonte/U4 - Ordenação em memória principal/java/Heapsort.class Normal file
View File

Binary file not shown.

74
fonte/U4 - Ordenação em memória principal/java/Heapsort.java
View File

@ -1,7 +1,7 @@
/**
* Algoritmo de ordenacao Heapsort
* @author Max do Val Machado
* @version 2 01/2015
* @version 3 08/2020
*/
class Heapsort extends Geracao {
@ -23,39 +23,11 @@ class Heapsort extends Geracao {
}
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() {
@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;
}
}

BIN
fonte/U4 - Ordenação em memória principal/java/Insercao.class Normal file
View File

Binary file not shown.

19
fonte/U4 - Ordenação em memória principal/java/Insercao.java
View File

@ -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.");
}
}

BIN
fonte/U4 - Ordenação em memória principal/java/Mergesort.class Normal file
View File

Binary file not shown.

39
fonte/U4 - Ordenação em memória principal/java/Mergesort.java Normal file
View File

@ -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) {
}
}

BIN
fonte/U4 - Ordenação em memória principal/java/Principal.class Normal file
View File

Binary file not shown.

4
fonte/U4 - Ordenação em memória principal/java/Principal.java
View File

@ -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;

BIN
fonte/U4 - Ordenação em memória principal/java/Quicksort.class Normal file
View File

Binary file not shown.

21
fonte/U4 - Ordenação em memória principal/java/Quicksort.java
View File

@ -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.");
}
}

BIN
fonte/U4 - Ordenação em memória principal/java/Selecao.class Normal file
View File

Binary file not shown.

2
fonte/U4 - Ordenação em memória principal/java/Selecao.java
View File

@ -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 {

BIN
fonte/U4 - Ordenação em memória principal/java/Shellsort.class Normal file
View File

Binary file not shown.

21
fonte/U4 - Ordenação em memória principal/java/Shellsort.java
View File

@ -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.");
}
}

BIN
fonte/U6 - Árvores binárias/c/arvoreBinariaC/no.o
View File

Binary file not shown.

0
fonte/U6 - Árvores binárias/c/arvoreBinariaCC/arvorebinaria.cc → fonte/U6 - Árvores binárias/cc/arvoreBinariaCC/arvorebinaria.cc
View File

0
fonte/U6 - Árvores binárias/c/arvoreBinariaCC/arvorebinaria.h → fonte/U6 - Árvores binárias/cc/arvoreBinariaCC/arvorebinaria.h
View File

0
fonte/U6 - Árvores binárias/c/arvoreBinariaCC/makefile → fonte/U6 - Árvores binárias/cc/arvoreBinariaCC/makefile
View File

0
fonte/U6 - Árvores binárias/c/arvoreBinariaCC/no.cc → fonte/U6 - Árvores binárias/cc/arvoreBinariaCC/no.cc
View File

0
fonte/U6 - Árvores binárias/c/arvoreBinariaCC/no.h → fonte/U6 - Árvores binárias/cc/arvoreBinariaCC/no.h
View File

0
fonte/U6 - Árvores binárias/c/arvoreBinariaCC/principal.cc → fonte/U6 - Árvores binárias/cc/arvoreBinariaCC/principal.cc
View File