From 8bc6d23df7218806f90e22b1f2662572a22ee304 Mon Sep 17 00:00:00 2001 From: bigheadbh Date: Tue, 11 Aug 2020 17:12:21 -0300 Subject: [PATCH] novos arquivos adicionados!! --- .../java/argumentoMain/ArgumentoMain.java | 6 + .../java/arquivo/ExemploArq01Escrita.java | 21 ++ .../java/arquivo/ExemploArq02Leitura.java | 28 ++ .../java/arquivo/ExemploArq02bLeitura.java | 28 ++ .../java/arquivo/ExemploArq03Exercicio.java | 16 + .../java/arquivo/ExemploRAF01Escrita.java | 16 + .../java/arquivo/ExemploRAF02Leitura.java | 22 ++ .../java/arquivo/ExemploRAF03Cabecote.java | 29 ++ .../java/classeObjeto/Principal.java | 44 +++ .../java/classeObjeto/Retangulo.java | 102 +++++ .../entradaSaida/ExemploBufferedReader.java | 43 +++ .../java/entradaSaida/ExemploMyIO.java | 13 + .../java/entradaSaida/ExemploScanner.java | 28 ++ .../java/entradaSaida/entrada.txt | 5 + .../java/ponteiro/Ponteiro01Array.java | 14 + .../Ponteiro02PassagemTipoPrimitivo.java | 19 + .../ponteiro/Ponteiro03PassagemArray.java | 31 ++ .../java/ponteiro/Ponteiro04Objeto.java | 55 +++ .../ponteiro/Ponteiro05PassagemObjeto.java | 96 +++++ .../Ponteiro06PassagemObjetoClone.java | 99 +++++ .../java/ponteiro/Ponteiro07ObjetoClone.java | 58 +++ .../java/recursividade/ChamandoMetodo.java | 20 + .../java/recursividade/ContarMaiuscula.java | 40 ++ .../java/recursividade/FatorialRecursivo.java | 20 + .../recursividade/FibonacciRecursivo.java | 18 + .../java/recursividade/Multiplicacao.java | 31 ++ .../java/recursividade/PrintRecursivo.java | 18 + .../TratamentoExcecao01.java | 12 + .../TratamentoExcecao02.java | 19 + .../TratamentoExcecao03.java | 22 ++ .../TratamentoExcecao04.java | 37 ++ .../TratamentoExcecao05.java | 22 ++ .../java/AND_OR.java | 19 + .../java/Log.java | 17 + .../java/Pesquisa.java | 61 +++ .../java/Bolha.java | 51 +++ .../java/Countingsort.java | 79 ++++ .../java/ExercicioDuvidaAND.java | 17 + .../java/Geracao.java | 149 ++++++++ .../java/Heapsort.java | 100 +++++ .../java/Insercao.java | 55 +++ .../java/Quicksort.java | 66 ++++ .../java/Selecao.java | 54 +++ .../java/Shellsort.java | 73 ++++ .../c/coletalixo/coletalixo.c | 38 ++ .../c/fila/fila.c | 135 +++++++ .../c/linear/fila.c | 143 +++++++ .../c/linear/lista.c | 215 +++++++++++ .../c/listadupla/listadupla.c | 267 +++++++++++++ .../c/listasimples/lista.c | 248 +++++++++++++ .../c/matriz/entrada.in | 37 ++ .../c/pilha/pilha.c | 103 ++++++ .../java/coletalixo/Celula.java | 26 ++ .../java/coletalixo/ColetaLixo.java | 24 ++ .../java/fila/Celula.java | 26 ++ .../java/fila/Fila.java | 61 +++ .../java/fila/PrincipalFila.java | 63 ++++ .../java/linear/Fila.java | 100 +++++ .../java/linear/Fila2Pilha.java | 56 +++ .../java/linear/Lista.java | 183 +++++++++ .../java/linear/ListaOrdenada.java | 156 ++++++++ .../java/linear/PrincipalFila.java | 63 ++++ .../java/linear/PrincipalLista.java | 29 ++ .../java/linear/PrincipalListaOrdenada.java | 21 ++ .../java/listadupla/CelulaDupla.java | 27 ++ .../java/listadupla/ListaDupla.java | 204 ++++++++++ .../java/listadupla/PrincipalListaDupla.java | 40 ++ .../java/listasimples/Celula.java | 26 ++ .../java/listasimples/Lista.java | 188 ++++++++++ .../java/listasimples/PrincipalLista.java | 41 ++ .../java/matriz/Celula.java | 20 + .../java/matriz/Matriz.java | 53 +++ .../java/matriz/Principal.java | 30 ++ .../java/matriz/entrada.in | 37 ++ .../java/pilha/Celula.java | 26 ++ .../java/pilha/Pilha.java | 90 +++++ .../java/pilha/PrincipalPilha.java | 35 ++ .../c/arvoreBinariaC/arvorebinaria.c | 201 ++++++++++ .../c/arvoreBinariaC/arvorebinaria.h | 25 ++ .../c/arvoreBinariaC/makefile | 19 + .../c/arvoreBinariaC/no.c | 18 + .../c/arvoreBinariaC/no.h | 15 + .../c/arvoreBinariaC/no.o | Bin 0 -> 1592 bytes .../c/arvoreBinariaC/principal.c | 60 +++ .../c/arvoreBinariaCC/arvorebinaria.cc | 200 ++++++++++ .../c/arvoreBinariaCC/arvorebinaria.h | 27 ++ .../c/arvoreBinariaCC/makefile | 16 + .../c/arvoreBinariaCC/no.cc | 16 + .../c/arvoreBinariaCC/no.h | 14 + .../c/arvoreBinariaCC/principal.cc | 60 +++ .../java/arvoreArvore/ArvoreArvore.java | 67 ++++ .../java/arvoreArvore/No.java | 35 ++ .../java/arvoreArvore/No2.java | 26 ++ .../java/arvoreBinariaDeLista/Agenda.java | 98 +++++ .../java/arvoreBinariaDeLista/Celula.java | 18 + .../java/arvoreBinariaDeLista/Contato.java | 6 + .../java/arvoreBinariaDeLista/No.java | 12 + .../java/arvoreBinariaJava/ArvoreBinaria.java | 350 ++++++++++++++++++ .../java/arvoreBinariaJava/No.java | 28 ++ .../java/arvoreBinariaJava/Principal.java | 30 ++ .../java/arvoreBinariaJava/Principal2.java | 33 ++ .../java/alvinegra/Alvinegra.java | 295 +++++++++++++++ .../java/alvinegra/NoAN.java | 24 ++ .../java/alvinegra/Principal.java | 77 ++++ .../java/avl/AVL.java | 276 ++++++++++++++ .../java/avl/No.java | 45 +++ .../java/avl/Principal.java | 76 ++++ .../java/doidona/DoidonaComTADsProntas.java | 117 ++++++ .../java/doidona/DoidonaSemTADsProntas.java | 159 ++++++++ .../java/hashDiretoRehash/Hash.java | 76 ++++ .../java/hashDiretoReserva/Hash.java | 73 ++++ .../java/hashIndiretoLista/Hash.java | 43 +++ .../java/hashIndiretoLista/Lista.java | 206 +++++++++++ fonte/U9 - Árvores TRIE/java/patricia/No.java | 31 ++ .../java/patricia/Patricia.java | 114 ++++++ .../java/patricia/Principal.java | 47 +++ .../java/trie/ArvoreTrie.java | 91 +++++ fonte/U9 - Árvores TRIE/java/trie/No.java | 21 ++ .../U9 - Árvores TRIE/java/trie/Patricia.java | 104 ++++++ .../java/trie/Principal.java | 37 ++ .../java/trieVariacoes/trieAB/ArvoreTrie.java | 71 ++++ .../java/trieVariacoes/trieAB/No.java | 103 ++++++ .../java/trieVariacoes/trieAB/NoAB.java | 27 ++ .../java/trieVariacoes/trieAB/Principal.java | 34 ++ .../java/trieVariacoes/trieAB/oi | 84 +++++ .../trieHashAceitandoPrexixo/ArvoreTrie.java | 72 ++++ .../trieHashAceitandoPrexixo/No.java | 21 ++ .../trieHashAceitandoPrexixo/Principal.java | 36 ++ .../trieListaFlexivel/ArvoreTrie.java | 71 ++++ .../trieListaFlexivel/Celula.java | 30 ++ .../trieVariacoes/trieListaFlexivel/No.java | 63 ++++ .../trieListaFlexivel/Principal.java | 34 ++ .../java/trieVariacoes/trieListaFlexivel/oi | 84 +++++ 133 files changed, 8600 insertions(+) create mode 100644 fonte/U0 - Nivelamento/java/argumentoMain/ArgumentoMain.java create mode 100644 fonte/U0 - Nivelamento/java/arquivo/ExemploArq01Escrita.java create mode 100644 fonte/U0 - Nivelamento/java/arquivo/ExemploArq02Leitura.java create mode 100644 fonte/U0 - Nivelamento/java/arquivo/ExemploArq02bLeitura.java create mode 100644 fonte/U0 - Nivelamento/java/arquivo/ExemploArq03Exercicio.java create mode 100644 fonte/U0 - Nivelamento/java/arquivo/ExemploRAF01Escrita.java create mode 100644 fonte/U0 - Nivelamento/java/arquivo/ExemploRAF02Leitura.java create mode 100644 fonte/U0 - Nivelamento/java/arquivo/ExemploRAF03Cabecote.java create mode 100644 fonte/U0 - Nivelamento/java/classeObjeto/Principal.java create mode 100644 fonte/U0 - Nivelamento/java/classeObjeto/Retangulo.java create mode 100644 fonte/U0 - Nivelamento/java/entradaSaida/ExemploBufferedReader.java create mode 100644 fonte/U0 - Nivelamento/java/entradaSaida/ExemploMyIO.java create mode 100644 fonte/U0 - Nivelamento/java/entradaSaida/ExemploScanner.java create mode 100644 fonte/U0 - Nivelamento/java/entradaSaida/entrada.txt create mode 100644 fonte/U0 - Nivelamento/java/ponteiro/Ponteiro01Array.java create mode 100644 fonte/U0 - Nivelamento/java/ponteiro/Ponteiro02PassagemTipoPrimitivo.java create mode 100644 fonte/U0 - Nivelamento/java/ponteiro/Ponteiro03PassagemArray.java create mode 100644 fonte/U0 - Nivelamento/java/ponteiro/Ponteiro04Objeto.java create mode 100644 fonte/U0 - Nivelamento/java/ponteiro/Ponteiro05PassagemObjeto.java create mode 100644 fonte/U0 - Nivelamento/java/ponteiro/Ponteiro06PassagemObjetoClone.java create mode 100644 fonte/U0 - Nivelamento/java/ponteiro/Ponteiro07ObjetoClone.java create mode 100644 fonte/U0 - Nivelamento/java/recursividade/ChamandoMetodo.java create mode 100644 fonte/U0 - Nivelamento/java/recursividade/ContarMaiuscula.java create mode 100644 fonte/U0 - Nivelamento/java/recursividade/FatorialRecursivo.java create mode 100644 fonte/U0 - Nivelamento/java/recursividade/FibonacciRecursivo.java create mode 100644 fonte/U0 - Nivelamento/java/recursividade/Multiplicacao.java create mode 100644 fonte/U0 - Nivelamento/java/recursividade/PrintRecursivo.java create mode 100644 fonte/U0 - Nivelamento/java/tratamentoExcecao/TratamentoExcecao01.java create mode 100644 fonte/U0 - Nivelamento/java/tratamentoExcecao/TratamentoExcecao02.java create mode 100644 fonte/U0 - Nivelamento/java/tratamentoExcecao/TratamentoExcecao03.java create mode 100644 fonte/U0 - Nivelamento/java/tratamentoExcecao/TratamentoExcecao04.java create mode 100644 fonte/U0 - Nivelamento/java/tratamentoExcecao/TratamentoExcecao05.java create mode 100644 fonte/U3 - Fundamentos de análise de algoritmos/java/AND_OR.java create mode 100644 fonte/U3 - Fundamentos de análise de algoritmos/java/Log.java create mode 100644 fonte/U3 - Fundamentos de análise de algoritmos/java/Pesquisa.java create mode 100644 fonte/U4 - Ordenação em memória principal/java/Bolha.java create mode 100644 fonte/U4 - Ordenação em memória principal/java/Countingsort.java create 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.java create mode 100644 fonte/U4 - Ordenação em memória principal/java/Heapsort.java create mode 100644 fonte/U4 - Ordenação em memória principal/java/Insercao.java create mode 100644 fonte/U4 - Ordenação em memória principal/java/Quicksort.java create mode 100644 fonte/U4 - Ordenação em memória principal/java/Selecao.java create mode 100644 fonte/U4 - Ordenação em memória principal/java/Shellsort.java create mode 100644 fonte/U5 - Estruturas de dados lineares e flexíveis/c/coletalixo/coletalixo.c create mode 100644 fonte/U5 - Estruturas de dados lineares e flexíveis/c/fila/fila.c create mode 100644 fonte/U5 - Estruturas de dados lineares e flexíveis/c/linear/fila.c create mode 100644 fonte/U5 - Estruturas de dados lineares e flexíveis/c/linear/lista.c create mode 100644 fonte/U5 - Estruturas de dados lineares e flexíveis/c/listadupla/listadupla.c create mode 100644 fonte/U5 - Estruturas de dados lineares e flexíveis/c/listasimples/lista.c create mode 100644 fonte/U5 - Estruturas de dados lineares e flexíveis/c/matriz/entrada.in create mode 100644 fonte/U5 - Estruturas de dados lineares e flexíveis/c/pilha/pilha.c create mode 100644 fonte/U5 - Estruturas de dados lineares e flexíveis/java/coletalixo/Celula.java create mode 100644 fonte/U5 - Estruturas de dados lineares e flexíveis/java/coletalixo/ColetaLixo.java create mode 100644 fonte/U5 - Estruturas de dados lineares e flexíveis/java/fila/Celula.java create mode 100644 fonte/U5 - Estruturas de dados lineares e flexíveis/java/fila/Fila.java create mode 100644 fonte/U5 - Estruturas de dados lineares e flexíveis/java/fila/PrincipalFila.java create mode 100644 fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/Fila.java create mode 100644 fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/Fila2Pilha.java create mode 100644 fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/Lista.java create mode 100644 fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/ListaOrdenada.java create mode 100644 fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/PrincipalFila.java create mode 100644 fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/PrincipalLista.java create mode 100644 fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/PrincipalListaOrdenada.java create mode 100644 fonte/U5 - Estruturas de dados lineares e flexíveis/java/listadupla/CelulaDupla.java create mode 100644 fonte/U5 - Estruturas de dados lineares e flexíveis/java/listadupla/ListaDupla.java create mode 100644 fonte/U5 - Estruturas de dados lineares e flexíveis/java/listadupla/PrincipalListaDupla.java create mode 100644 fonte/U5 - Estruturas de dados lineares e flexíveis/java/listasimples/Celula.java create mode 100644 fonte/U5 - Estruturas de dados lineares e flexíveis/java/listasimples/Lista.java create mode 100644 fonte/U5 - Estruturas de dados lineares e flexíveis/java/listasimples/PrincipalLista.java create mode 100644 fonte/U5 - Estruturas de dados lineares e flexíveis/java/matriz/Celula.java create mode 100644 fonte/U5 - Estruturas de dados lineares e flexíveis/java/matriz/Matriz.java create mode 100644 fonte/U5 - Estruturas de dados lineares e flexíveis/java/matriz/Principal.java create mode 100644 fonte/U5 - Estruturas de dados lineares e flexíveis/java/matriz/entrada.in create mode 100644 fonte/U5 - Estruturas de dados lineares e flexíveis/java/pilha/Celula.java create mode 100644 fonte/U5 - Estruturas de dados lineares e flexíveis/java/pilha/Pilha.java create mode 100644 fonte/U5 - Estruturas de dados lineares e flexíveis/java/pilha/PrincipalPilha.java create mode 100644 fonte/U6 - Árvores binárias/c/arvoreBinariaC/arvorebinaria.c create mode 100644 fonte/U6 - Árvores binárias/c/arvoreBinariaC/arvorebinaria.h create mode 100644 fonte/U6 - Árvores binárias/c/arvoreBinariaC/makefile create mode 100644 fonte/U6 - Árvores binárias/c/arvoreBinariaC/no.c create mode 100644 fonte/U6 - Árvores binárias/c/arvoreBinariaC/no.h create mode 100644 fonte/U6 - Árvores binárias/c/arvoreBinariaC/no.o create mode 100644 fonte/U6 - Árvores binárias/c/arvoreBinariaC/principal.c create mode 100644 fonte/U6 - Árvores binárias/c/arvoreBinariaCC/arvorebinaria.cc create mode 100644 fonte/U6 - Árvores binárias/c/arvoreBinariaCC/arvorebinaria.h create mode 100644 fonte/U6 - Árvores binárias/c/arvoreBinariaCC/makefile create mode 100644 fonte/U6 - Árvores binárias/c/arvoreBinariaCC/no.cc create mode 100644 fonte/U6 - Árvores binárias/c/arvoreBinariaCC/no.h create mode 100644 fonte/U6 - Árvores binárias/c/arvoreBinariaCC/principal.cc create mode 100644 fonte/U6 - Árvores binárias/java/arvoreArvore/ArvoreArvore.java create mode 100644 fonte/U6 - Árvores binárias/java/arvoreArvore/No.java create mode 100644 fonte/U6 - Árvores binárias/java/arvoreArvore/No2.java create mode 100644 fonte/U6 - Árvores binárias/java/arvoreBinariaDeLista/Agenda.java create mode 100644 fonte/U6 - Árvores binárias/java/arvoreBinariaDeLista/Celula.java create mode 100644 fonte/U6 - Árvores binárias/java/arvoreBinariaDeLista/Contato.java create mode 100644 fonte/U6 - Árvores binárias/java/arvoreBinariaDeLista/No.java create mode 100644 fonte/U6 - Árvores binárias/java/arvoreBinariaJava/ArvoreBinaria.java create mode 100644 fonte/U6 - Árvores binárias/java/arvoreBinariaJava/No.java create mode 100644 fonte/U6 - Árvores binárias/java/arvoreBinariaJava/Principal.java create mode 100644 fonte/U6 - Árvores binárias/java/arvoreBinariaJava/Principal2.java create mode 100644 fonte/U7 - Balanceamento de árvores/java/alvinegra/Alvinegra.java create mode 100644 fonte/U7 - Balanceamento de árvores/java/alvinegra/NoAN.java create mode 100644 fonte/U7 - Balanceamento de árvores/java/alvinegra/Principal.java create mode 100644 fonte/U7 - Balanceamento de árvores/java/avl/AVL.java create mode 100644 fonte/U7 - Balanceamento de árvores/java/avl/No.java create mode 100644 fonte/U7 - Balanceamento de árvores/java/avl/Principal.java create mode 100644 fonte/U8 - Tabelas e dicionários/java/doidona/DoidonaComTADsProntas.java create mode 100644 fonte/U8 - Tabelas e dicionários/java/doidona/DoidonaSemTADsProntas.java create mode 100644 fonte/U8 - Tabelas e dicionários/java/hashDiretoRehash/Hash.java create mode 100644 fonte/U8 - Tabelas e dicionários/java/hashDiretoReserva/Hash.java create mode 100644 fonte/U8 - Tabelas e dicionários/java/hashIndiretoLista/Hash.java create mode 100644 fonte/U8 - Tabelas e dicionários/java/hashIndiretoLista/Lista.java create mode 100644 fonte/U9 - Árvores TRIE/java/patricia/No.java create mode 100644 fonte/U9 - Árvores TRIE/java/patricia/Patricia.java create mode 100644 fonte/U9 - Árvores TRIE/java/patricia/Principal.java create mode 100644 fonte/U9 - Árvores TRIE/java/trie/ArvoreTrie.java create mode 100644 fonte/U9 - Árvores TRIE/java/trie/No.java create mode 100644 fonte/U9 - Árvores TRIE/java/trie/Patricia.java create mode 100644 fonte/U9 - Árvores TRIE/java/trie/Principal.java create mode 100644 fonte/U9 - Árvores TRIE/java/trieVariacoes/trieAB/ArvoreTrie.java create mode 100644 fonte/U9 - Árvores TRIE/java/trieVariacoes/trieAB/No.java create mode 100644 fonte/U9 - Árvores TRIE/java/trieVariacoes/trieAB/NoAB.java create mode 100644 fonte/U9 - Árvores TRIE/java/trieVariacoes/trieAB/Principal.java create mode 100644 fonte/U9 - Árvores TRIE/java/trieVariacoes/trieAB/oi create mode 100644 fonte/U9 - Árvores TRIE/java/trieVariacoes/trieHashAceitandoPrexixo/ArvoreTrie.java create mode 100644 fonte/U9 - Árvores TRIE/java/trieVariacoes/trieHashAceitandoPrexixo/No.java create mode 100644 fonte/U9 - Árvores TRIE/java/trieVariacoes/trieHashAceitandoPrexixo/Principal.java create mode 100644 fonte/U9 - Árvores TRIE/java/trieVariacoes/trieListaFlexivel/ArvoreTrie.java create mode 100644 fonte/U9 - Árvores TRIE/java/trieVariacoes/trieListaFlexivel/Celula.java create mode 100644 fonte/U9 - Árvores TRIE/java/trieVariacoes/trieListaFlexivel/No.java create mode 100644 fonte/U9 - Árvores TRIE/java/trieVariacoes/trieListaFlexivel/Principal.java create mode 100644 fonte/U9 - Árvores TRIE/java/trieVariacoes/trieListaFlexivel/oi diff --git a/fonte/U0 - Nivelamento/java/argumentoMain/ArgumentoMain.java b/fonte/U0 - Nivelamento/java/argumentoMain/ArgumentoMain.java new file mode 100644 index 0000000..aca4a51 --- /dev/null +++ b/fonte/U0 - Nivelamento/java/argumentoMain/ArgumentoMain.java @@ -0,0 +1,6 @@ +class ArgumentoMain { + public static void main (String[] args){ + System.out.println("Primeiro parametro: " + args[0]); + System.out.println("Numero de parametros: " + args.length); + } +} diff --git a/fonte/U0 - Nivelamento/java/arquivo/ExemploArq01Escrita.java b/fonte/U0 - Nivelamento/java/arquivo/ExemploArq01Escrita.java new file mode 100644 index 0000000..4e0fcd9 --- /dev/null +++ b/fonte/U0 - Nivelamento/java/arquivo/ExemploArq01Escrita.java @@ -0,0 +1,21 @@ +class ExemploArq01Escrita +{ + public static void main(String[] args) + { + //Abrir o arquivo texto + Arq.openWrite("exemplo.txt"); + + + //Escrever no arquivo texto + Arq.println(1); + Arq.println(5.3); + Arq.println('X'); + Arq.println(true); + Arq.println("Algoritmos"); + + + //Fechar o arquivo texto + Arq.close(); + + } // Fim main() +} // Fim class diff --git a/fonte/U0 - Nivelamento/java/arquivo/ExemploArq02Leitura.java b/fonte/U0 - Nivelamento/java/arquivo/ExemploArq02Leitura.java new file mode 100644 index 0000000..0b73f32 --- /dev/null +++ b/fonte/U0 - Nivelamento/java/arquivo/ExemploArq02Leitura.java @@ -0,0 +1,28 @@ +class ExemploArq02Leitura +{ + public static void main(String[] args) + { + //Abrir o arquivo texto + Arq.openRead("exemplo.txt"); + + + //Ler o arquivo texto + int inteiro = Arq.readInt(); + double real = Arq.readDouble(); + char caractere = Arq.readChar(); + boolean boleano = Arq.readBoolean(); + String str = Arq.readString(); + + + //Fechar o arquivo texto + Arq.close(); + + //Mostrar os valores lidos na tela + MyIO.println("inteiro: " + inteiro); + MyIO.println("real: " + real); + MyIO.println("caractere: " + caractere); + MyIO.println("boleano: " + boleano); + MyIO.println("str: " + str); + + } // Fim main() +} // Fim class diff --git a/fonte/U0 - Nivelamento/java/arquivo/ExemploArq02bLeitura.java b/fonte/U0 - Nivelamento/java/arquivo/ExemploArq02bLeitura.java new file mode 100644 index 0000000..33e3465 --- /dev/null +++ b/fonte/U0 - Nivelamento/java/arquivo/ExemploArq02bLeitura.java @@ -0,0 +1,28 @@ +class ExemploArq02bLeitura +{ + public static void main(String[] args) + { + //Abrir o arquivo texto + Arq.openRead("exemplo.txt"); + + + //Ler o arquivo texto + int inteiro = Integer.parseInt(Arq.readLine()); + double real = Double.parseDouble(Arq.readLine().replace(",",".")); + char caractere = Arq.readLine().charAt(0); + boolean boleano = Boolean.parseBoolean(Arq.readLine()); + String str = Arq.readLine(); + + + //Fechar o arquivo texto + Arq.close(); + + //Mostrar os valores lidos na tela + MyIO.println("inteiro: " + inteiro); + MyIO.println("real: " + real); + MyIO.println("caractere: " + caractere); + MyIO.println("boleano: " + boleano); + MyIO.println("str: " + str); + + } // Fim main() +} // Fim class diff --git a/fonte/U0 - Nivelamento/java/arquivo/ExemploArq03Exercicio.java b/fonte/U0 - Nivelamento/java/arquivo/ExemploArq03Exercicio.java new file mode 100644 index 0000000..71ad469 --- /dev/null +++ b/fonte/U0 - Nivelamento/java/arquivo/ExemploArq03Exercicio.java @@ -0,0 +1,16 @@ +class ExemploArq03Exercicio { + public static void main (String[] args){ + Arq.openRead("exemplo.txt"); + + String str = ""; + while (Arq.hasNext() == true){ + str += Arq.readChar(); + } + + Arq.close(); + + Arq.openWrite("copia.txt"); + Arq.print(str); + Arq.close(); + } +} diff --git a/fonte/U0 - Nivelamento/java/arquivo/ExemploRAF01Escrita.java b/fonte/U0 - Nivelamento/java/arquivo/ExemploRAF01Escrita.java new file mode 100644 index 0000000..123cc8e --- /dev/null +++ b/fonte/U0 - Nivelamento/java/arquivo/ExemploRAF01Escrita.java @@ -0,0 +1,16 @@ +import java.io.*; + +public class ExemploRAF01Escrita { + public static void main(String args[]) throws Exception { + + RandomAccessFile raf = new RandomAccessFile("exemplo.txt","rw"); + + raf.writeInt(1); + raf.writeDouble(5.3); + raf.writeChar('X'); + raf.writeBoolean(true); + raf.writeBytes("Algoritmos"); + + raf.close(); + } +} diff --git a/fonte/U0 - Nivelamento/java/arquivo/ExemploRAF02Leitura.java b/fonte/U0 - Nivelamento/java/arquivo/ExemploRAF02Leitura.java new file mode 100644 index 0000000..a81535f --- /dev/null +++ b/fonte/U0 - Nivelamento/java/arquivo/ExemploRAF02Leitura.java @@ -0,0 +1,22 @@ +import java.io.*; + +class ExemploRAF02Leitura { + public static void main (String[] args) throws Exception{ + RandomAccessFile raf = new RandomAccessFile("exemplo.txt", "rw"); + + int inteiro = raf.readInt(); + double real = raf.readDouble(); + char caractere = raf.readChar(); + boolean boleano = raf.readBoolean(); + String str = raf.readLine(); + + raf.close(); + + System.out.println("inteiro: " + inteiro); + System.out.println("real: " + real); + System.out.println("caractere: " + caractere); + System.out.println("boleano: " + boleano); + System.out.println("str: " + str); + } +} + diff --git a/fonte/U0 - Nivelamento/java/arquivo/ExemploRAF03Cabecote.java b/fonte/U0 - Nivelamento/java/arquivo/ExemploRAF03Cabecote.java new file mode 100644 index 0000000..364f16e --- /dev/null +++ b/fonte/U0 - Nivelamento/java/arquivo/ExemploRAF03Cabecote.java @@ -0,0 +1,29 @@ +import java.io.*; + +public class ExemploRAF03Cabecote { + public static void main(String args[]) throws Exception { + + RandomAccessFile raf = new RandomAccessFile("exemplo.txt","rw"); + + raf.writeInt(1); + raf.writeDouble(5.3); + raf.writeChar('X'); + raf.writeBoolean(true); + raf.writeBytes("Algoritmos"); + + raf.seek(0); //Retornando o cabecote para a posicao 0 + System.out.println(raf.readInt()); //imprimindo o inteiro + + raf.seek(12); //Setando o cabecote na posicao 12 (do caractere, + //12 = 4 do int + 8 do double) + System.out.println(raf.readChar()); + + raf.seek(12); //Setando o cabecote novamente na posicao 12 + raf.writeChar('@'); //Substituindo o caractere + + raf.seek(12); + System.out.println(raf.readChar()); + + raf.close(); + } +} diff --git a/fonte/U0 - Nivelamento/java/classeObjeto/Principal.java b/fonte/U0 - Nivelamento/java/classeObjeto/Principal.java new file mode 100644 index 0000000..14633eb --- /dev/null +++ b/fonte/U0 - Nivelamento/java/classeObjeto/Principal.java @@ -0,0 +1,44 @@ +/** + * Introducao a programacao orientada por objetos + * @author Max do Val Machado + * @version 2 01/2015 + */ +class Principal +{ + public static void main(String[] args) + { + Retangulo r1 = new Retangulo(); + Retangulo r2 = new Retangulo(); + + r1.lerTudo(); + r1.escreverTudo(); + + r2.lerTudo(); + r2.escreverTudo(); + + if (r1.comparar(r2.getB(), r2.getH()) == true){ + System.out.println("Os retangulos " + r1.getNome() + " e " + r2.getNome() + "sao iguais!"); + }else{ + System.out.println("Os retangulos " + r1.getNome() + " e " + r2.getNome() + "sao diferentes!"); + } + + if (r1.comparar(r2) == true){ + System.out.println("Os retangulos " + r1.getNome() + " e " + r2.getNome() + "sao iguais!"); + }else{ + System.out.println("Os retangulos " + r1.getNome() + " e " + r2.getNome() + "sao diferentes!"); + } + + if (r1.comparar(r1) == true){ + System.out.println("Os retangulos " + r1.getNome() + " e " + r1.getNome() + "sao iguais!"); + }else{ + System.out.println("Os retangulos " + r1.getNome() + " e " + r1.getNome() + "sao diferentes!"); + } + + if (r2.comparar(r1) == true){ + System.out.println("Os retangulos " + r2.getNome() + " e " + r1.getNome() + "sao iguais!"); + }else{ + System.out.println("Os retangulos " + r2.getNome() + " e " + r1.getNome() + "sao diferentes!"); + } + } +} + diff --git a/fonte/U0 - Nivelamento/java/classeObjeto/Retangulo.java b/fonte/U0 - Nivelamento/java/classeObjeto/Retangulo.java new file mode 100644 index 0000000..8f29e44 --- /dev/null +++ b/fonte/U0 - Nivelamento/java/classeObjeto/Retangulo.java @@ -0,0 +1,102 @@ +/** + * Introducao a programacao orientada por objetos + * @author Max do Val Machado + * @version 2 01/2015 + */ +class Retangulo{ + //Declaracao de variaveis + private double b, h; + private String nome; + + //Construtor vazio + public Retangulo(){ + this.b = this.h = 0; + this.nome = ""; + } + + //Construtor que recebe parametros + public Retangulo(double b, double h, String nome){ + this.b = b; + this.h = h; + this.nome = nome; + } + + public double getB(){ + return this.b; + } + + public void setB(double b){ + this.b = b; + } + + public double getH(){ + return this.h; + } + + public void setH(double h){ + this.h = h; + } + + public String getNome(){ + return this.nome; + } + + public void setNome(String nome){ + this.nome = nome; + } + + public void lerTudo(){ + b = MyIO.readDouble("Entre com a base: "); + h = MyIO.readDouble("Entre com a altura: "); + nome = MyIO.readString("Entre com o nome: "); + } + + public void escreverTudo(){ + System.out.println("NOME: " + nome); + System.out.println("Base: " + b); + System.out.println("Altura: " + h); + System.out.println("Area: " + getArea()); + System.out.println("Diagonal: " + getDiagonal()); + System.out.println("Perimetro: " + getPerimetro()); + } + + + //Retornar a area + public double getArea(){ + return (b * h); + } + + //Retornar o perimetro + public double getPerimetro(){ + return ((b + h) * 2); + } + + //Retornar a diagonal + public double getDiagonal(){ + return Math.sqrt(b * b + h * h); + } + + + //Comparar + public boolean comparar(double outraB, double outraH){ + boolean resp; + + if (this.b == outraB && this.h == outraH){ + resp = true; + }else{ + resp = false; + } + + return resp; + } + + //Comparar + //public boolean comparar(double outraB, double outraH){ + // return (this.b == outraB && this.h == outraH); + //} + + //Comparar + public boolean comparar(Retangulo x){ + return (this.b == x.b && this.h == x.h); + } +} diff --git a/fonte/U0 - Nivelamento/java/entradaSaida/ExemploBufferedReader.java b/fonte/U0 - Nivelamento/java/entradaSaida/ExemploBufferedReader.java new file mode 100644 index 0000000..73e7aa7 --- /dev/null +++ b/fonte/U0 - Nivelamento/java/entradaSaida/ExemploBufferedReader.java @@ -0,0 +1,43 @@ +import java.io.*; +import java.nio.charset.*; + +class ExemploBufferedReader { + + //Declaracao da classe BufferedReader + private static BufferedReader in = new BufferedReader(new InputStreamReader(System.in, Charset.forName("ISO-8859-1"))); + + public static String readString(){ + String s = ""; + char tmp; + try{ + do{ + tmp = (char)in.read(); + if(tmp != '\n' && tmp != ' ' && tmp != 13){ + s += tmp; + } + }while(tmp != '\n' && tmp != ' '); + }catch(IOException ioe){} + return s; + } + + public static void main(String [] args) throws Exception { + + System.out.printf("Entre com uma palavra: "); + String str = readString(); + + System.out.printf("Entre com um numero inteiro: "); + int inteiro = Integer.parseInt(readString().trim()); + + System.out.printf("Entre com um numero real: "); + double real = Double.parseDouble(readString().trim().replace(",",".")); + + System.out.printf("Entre com um caractere: "); + char caractere = (char)in.read(); + + System.out.println("Sua str: " + str); + System.out.println("Seu inteiro: " + inteiro); + System.out.println("Seu real: " + real); + System.out.println("Seu caractere: " + caractere); + } // fim main () +} // fim class + diff --git a/fonte/U0 - Nivelamento/java/entradaSaida/ExemploMyIO.java b/fonte/U0 - Nivelamento/java/entradaSaida/ExemploMyIO.java new file mode 100644 index 0000000..1a68fdb --- /dev/null +++ b/fonte/U0 - Nivelamento/java/entradaSaida/ExemploMyIO.java @@ -0,0 +1,13 @@ +class ExemploMyIO { + public static void main (String[] args){ + String str = MyIO.readString("Entre com uma palavra: "); + int inteiro = MyIO.readInt("Entre com um inteiro: "); + double real = MyIO.readDouble("Entre com um real: "); + char caractere = MyIO.readChar("Entre com um caractere: "); + + MyIO.println("Sua string: " + str); + MyIO.println("Seu inteiro: " + inteiro); + MyIO.println("Seu real: " + real); + MyIO.println("Seu caractere: " + caractere); + } +} diff --git a/fonte/U0 - Nivelamento/java/entradaSaida/ExemploScanner.java b/fonte/U0 - Nivelamento/java/entradaSaida/ExemploScanner.java new file mode 100644 index 0000000..de65592 --- /dev/null +++ b/fonte/U0 - Nivelamento/java/entradaSaida/ExemploScanner.java @@ -0,0 +1,28 @@ +import java.util.*; + +class ExemploScanner { + public static void main(String [] args){ + + //Declaracao da classe scanner + Scanner scanner = new Scanner (System.in); + + System.out.printf("Entre com uma palavra: "); + String str = scanner.nextLine(); + + System.out.printf("Entre com um caractere: "); + char caractere = scanner.nextLine().charAt(0); + + System.out.printf("Entre com um numero inteiro: "); + int inteiro = scanner.nextInt(); + + System.out.printf("Entre com um numero real: "); + double real = scanner.nextDouble(); + + System.out.println("Sua str: " + str); + System.out.println("Seu inteiro: " + inteiro); + System.out.println("Seu real: " + real); + System.out.println("Seu caractere: " + caractere); + + } // fim main () +} // fim class + diff --git a/fonte/U0 - Nivelamento/java/entradaSaida/entrada.txt b/fonte/U0 - Nivelamento/java/entradaSaida/entrada.txt new file mode 100644 index 0000000..600d616 --- /dev/null +++ b/fonte/U0 - Nivelamento/java/entradaSaida/entrada.txt @@ -0,0 +1,5 @@ +hoje +3000000 +12.3 +a + diff --git a/fonte/U0 - Nivelamento/java/ponteiro/Ponteiro01Array.java b/fonte/U0 - Nivelamento/java/ponteiro/Ponteiro01Array.java new file mode 100644 index 0000000..7d4ec5d --- /dev/null +++ b/fonte/U0 - Nivelamento/java/ponteiro/Ponteiro01Array.java @@ -0,0 +1,14 @@ +/** + * Ponteiro + * @author Max do Val Machado + * @version 2 01/2015 + */ +class Ponteiro01Array { + public static void main (String[] args) { + int[] vet = new int [10]; + System.out.println(vet); + + vet = new int [10]; + System.out.println(vet); + } +} diff --git a/fonte/U0 - Nivelamento/java/ponteiro/Ponteiro02PassagemTipoPrimitivo.java b/fonte/U0 - Nivelamento/java/ponteiro/Ponteiro02PassagemTipoPrimitivo.java new file mode 100644 index 0000000..afa9135 --- /dev/null +++ b/fonte/U0 - Nivelamento/java/ponteiro/Ponteiro02PassagemTipoPrimitivo.java @@ -0,0 +1,19 @@ +/** + * Ponteiro + * @author Max do Val Machado + * @version 2 01/2015 + */ +class Ponteiro02PassagemTipoPrimitivo { + public static void passagemDeTipoPrimitivo(int a){ + System.out.println("a: " + a); + a = 10; + System.out.println("a: " + a); + } + public static void main(String[] args) { + int x = 5; + System.out.println("x: " + x); + passagemDeTipoPrimitivo(x); + System.out.println("x: " + x); + } +} + diff --git a/fonte/U0 - Nivelamento/java/ponteiro/Ponteiro03PassagemArray.java b/fonte/U0 - Nivelamento/java/ponteiro/Ponteiro03PassagemArray.java new file mode 100644 index 0000000..2cf9747 --- /dev/null +++ b/fonte/U0 - Nivelamento/java/ponteiro/Ponteiro03PassagemArray.java @@ -0,0 +1,31 @@ +/** + * Ponteiro + * @author Max do Val Machado + * @version 2 01/2015 + */ +class Ponteiro03PassagemArray { + public static void passangemDeArray(int[] b){ + for(int i = 0; i < 5; i++){ + b[i] *= 5; + System.out.println("b[" + i + "]: " + b[i]); + } + b = new int[5]; + for(int i = 0; i < 5; i++){ + b[i] = i; + System.out.println("b[" + i + "]: " + b[i]); + } + } + public static void main(String[] args) { + int[] y = new int [5]; + + for(int i = 0; i < 5; i++){ + y[i] = i; + System.out.println("y[" + i + "]: " + y[i]); + } + passangemDeArray(y); + for(int i = 0; i < 5; i++){ + System.out.println("y[" + i + "]: " + y[i]); + } + } +} + diff --git a/fonte/U0 - Nivelamento/java/ponteiro/Ponteiro04Objeto.java b/fonte/U0 - Nivelamento/java/ponteiro/Ponteiro04Objeto.java new file mode 100644 index 0000000..2989c20 --- /dev/null +++ b/fonte/U0 - Nivelamento/java/ponteiro/Ponteiro04Objeto.java @@ -0,0 +1,55 @@ +/** + * Ponteiro + * @author Max do Val Machado + * @version 3 01/2016 + */ +class Cliente{ + private int codigo; + private String nome; + public Cliente(){ + this(0, ""); + } + public Cliente(int codigo){ + this(codigo, ""); + } + public Cliente(int codigo, String nome){ + this.codigo = codigo; + this.nome = nome; + } + public int getCodigo(){ + return codigo; + } + public void setCodigo(int codigo){ + this.codigo = codigo; + } + public String getNome(){ + return nome; + } + public void setNome(String nome){ + this.nome = nome; + } +} + +class Ponteiro04Objeto { + + public static void main (String[] args){ + + //Declarando tres ponteiros + Cliente c1 = null, c2 = null, c3 = null; + System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")"); + + //Alocando areas de memoria (ou inicializando objetos) e apontando os ponteiros para tais areas + c1 = new Cliente(1, "aa"); + c2 = c1; + c3 = new Cliente(2, "bb"); + System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")"); + + //Setando o codigo apontado por c1 e c2 + c2.setCodigo(3); + System.out.println("ATRIBUTOs:"); + System.out.println("c1(" + c1.getCodigo() + " / " + c1.getNome()+")"); + System.out.println("c2(" + c2.getCodigo() + " / " + c2.getNome()+")"); + System.out.println("c3(" + c3.getCodigo() + " / " + c3.getNome()+")"); + + } +} diff --git a/fonte/U0 - Nivelamento/java/ponteiro/Ponteiro05PassagemObjeto.java b/fonte/U0 - Nivelamento/java/ponteiro/Ponteiro05PassagemObjeto.java new file mode 100644 index 0000000..19ff72d --- /dev/null +++ b/fonte/U0 - Nivelamento/java/ponteiro/Ponteiro05PassagemObjeto.java @@ -0,0 +1,96 @@ +/** + * Ponteiro + * @author Max do Val Machado + * @version 3 01/2016 + */ +class Cliente{ + private int codigo; + private String nome; + public Cliente(){ + this(0, ""); + } + public Cliente(int codigo){ + this(codigo, ""); + } + public Cliente(int codigo, String nome){ + this.codigo = codigo; + this.nome = nome; + } + public int getCodigo(){ + return codigo; + } + public void setCodigo(int codigo){ + this.codigo = codigo; + } + public String getNome(){ + return nome; + } + public void setNome(String nome){ + this.nome = nome; + } +} + +class Ponteiro05PassagemObjeto { + + /** + * Metodo que recebe um ponteiro contendo o endereco de um objeto. Em seguida, o metodo altera o + * conteudo do objeto apontado pelo ponteiro (o mesmo objeto apontado por c1 no metodo principal). + * Depois, o metodo retorna o conteudo do nosso ponteiro (endereco recebido como parametro). + */ + public static Cliente setar2(Cliente y){ + y.setCodigo(6); + y.setNome("ff"); + System.out.println("ADDRs: y(" + y + ")"); + System.out.println("ATRIBUTOs: y(" + y.getCodigo() + " / " + y.getNome()+")"); + + return y; + } + + /** + * Metodo que recebe um ponteiro contendo o endereco de um objeto. Em seguida, o metodo altera o + * conteudo do objeto apontado pelo ponteiro (o mesmo objeto apontado por c1 no metodo principal). + * Depois, o metodo faz com que o ponteiro corrente aponte para outro objeto (veja que c1 do metodo + * princial continua apontando para o primeiro objeto). No final, a coleta de lixo do java libera a + * area de memoria que continha o ponteiro e o objeto criados neste metodo. + */ + public static void setar1(Cliente x){ + x.setCodigo(4); + x.setNome("dd"); + System.out.println("ADDRs: x(" + x + ")"); + System.out.println("ATRIBUTOs: x(" + x.getCodigo() + " / " + x.getNome()+")"); + + x = new Cliente (5, "ee"); + System.out.println("ADDRs: x(" + x + ")"); + System.out.println("ATRIBUTOs: x(" + x.getCodigo() + " / " + x.getNome()+")"); + } + + + public static void main (String[] args){ + + //Declarando tres ponteiros + Cliente c1 = new Cliente(1, "aa"); + Cliente c2 = c1; + Cliente c3 = new Cliente(2, "bb"); + System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")"); + System.out.println("ATRIBUTOs:"); + System.out.println("c1(" + c1.getCodigo() + " / " + c1.getNome()+")"); + System.out.println("c2(" + c2.getCodigo() + " / " + c2.getNome()+")"); + System.out.println("c3(" + c3.getCodigo() + " / " + c3.getNome()+")"); + + //Chamando o metodo setar1 e passando POR VALOR O ADDR de c1 + setar1(c1); + System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")"); + System.out.println("ATRIBUTOs:"); + System.out.println("c1(" + c1.getCodigo() + " / " + c1.getNome()+")"); + System.out.println("c2(" + c2.getCodigo() + " / " + c2.getNome()+")"); + System.out.println("c3(" + c3.getCodigo() + " / " + c3.getNome()+")"); + + //Chamando o metodo setar2, passando POR VALOR O ADDR DE c2 e retornando um novo endereco para C3 + c3 = setar2(c2); + System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")"); + System.out.println("ATRIBUTOs:"); + System.out.println("c1(" + c1.getCodigo() + " / " + c1.getNome()+")"); + System.out.println("c2(" + c2.getCodigo() + " / " + c2.getNome()+")"); + System.out.println("c3(" + c3.getCodigo() + " / " + c3.getNome()+")"); + } +} diff --git a/fonte/U0 - Nivelamento/java/ponteiro/Ponteiro06PassagemObjetoClone.java b/fonte/U0 - Nivelamento/java/ponteiro/Ponteiro06PassagemObjetoClone.java new file mode 100644 index 0000000..a070e0a --- /dev/null +++ b/fonte/U0 - Nivelamento/java/ponteiro/Ponteiro06PassagemObjetoClone.java @@ -0,0 +1,99 @@ +/** + * Ponteiro + * @author Max do Val Machado + * @version 3 01/2016 + */ +class Cliente{ + private int codigo; + private String nome; + public Cliente(){ + this(0, ""); + } + public Cliente(int codigo){ + this(codigo, ""); + } + public Cliente(int codigo, String nome){ + this.codigo = codigo; + this.nome = nome; + } + public int getCodigo(){ + return codigo; + } + public void setCodigo(int codigo){ + this.codigo = codigo; + } + public String getNome(){ + return nome; + } + public void setNome(String nome){ + this.nome = nome; + } + public Cliente clone(){ + return new Cliente(this.codigo, this.nome); + } +} + +class Ponteiro06PassagemObjetoClone { + + /** + * Metodo que recebe um ponteiro contendo o endereco de um objeto. Em seguida, o metodo altera o + * conteudo do objeto apontado pelo ponteiro (o mesmo objeto apontado por c1 no metodo principal). + * Depois, o metodo retorna o conteudo do nosso ponteiro (endereco recebido como parametro). + */ + public static Cliente setar2(Cliente y){ + y.setCodigo(6); + y.setNome("ff"); + System.out.println("ADDRs: y(" + y + ")"); + System.out.println("ATRIBUTOs: y(" + y.getCodigo() + " / " + y.getNome()+")"); + + return y; + } + + /** + * Metodo que recebe um ponteiro contendo o endereco de um objeto. Em seguida, o metodo altera o + * conteudo do objeto apontado pelo ponteiro (o mesmo objeto apontado por c1 no metodo principal). + * Depois, o metodo faz com que o ponteiro corrente aponte para outro objeto (veja que c1 do metodo + * princial continua apontando para o primeiro objeto). No final, a coleta de lixo do java libera a + * area de memoria que continha o ponteiro e o objeto criados neste metodo. + */ + public static void setar1(Cliente x){ + x.setCodigo(4); + x.setNome("dd"); + System.out.println("ADDRs: x(" + x + ")"); + System.out.println("ATRIBUTOs: x(" + x.getCodigo() + " / " + x.getNome()+")"); + + x = new Cliente (5, "ee"); + System.out.println("ADDRs: x(" + x + ")"); + System.out.println("ATRIBUTOs: x(" + x.getCodigo() + " / " + x.getNome()+")"); + } + + + public static void main (String[] args){ + + //Declarando tres ponteiros + Cliente c1 = new Cliente(1, "aa"); + Cliente c2 = c1.clone(); + Cliente c3 = new Cliente(2, "bb"); + System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")"); + System.out.println("ATRIBUTOs:"); + System.out.println("c1(" + c1.getCodigo() + " / " + c1.getNome()+")"); + System.out.println("c2(" + c2.getCodigo() + " / " + c2.getNome()+")"); + System.out.println("c3(" + c3.getCodigo() + " / " + c3.getNome()+")"); + + //Chamando o metodo setar1 e passando POR VALOR O ADDR de c1 + setar1(c1); + System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")"); + System.out.println("ATRIBUTOs:"); + System.out.println("c1(" + c1.getCodigo() + " / " + c1.getNome()+")"); + System.out.println("c2(" + c2.getCodigo() + " / " + c2.getNome()+")"); + System.out.println("c3(" + c3.getCodigo() + " / " + c3.getNome()+")"); + + //Chamando o metodo setar2, passando POR VALOR O ADDR DE c2 e retornando um novo endereco para C3 + c3 = setar2(c2); + System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")"); + System.out.println("ATRIBUTOs:"); + System.out.println("c1(" + c1.getCodigo() + " / " + c1.getNome()+")"); + System.out.println("c2(" + c2.getCodigo() + " / " + c2.getNome()+")"); + System.out.println("c3(" + c3.getCodigo() + " / " + c3.getNome()+")"); + } +} diff --git a/fonte/U0 - Nivelamento/java/ponteiro/Ponteiro07ObjetoClone.java b/fonte/U0 - Nivelamento/java/ponteiro/Ponteiro07ObjetoClone.java new file mode 100644 index 0000000..2f668c8 --- /dev/null +++ b/fonte/U0 - Nivelamento/java/ponteiro/Ponteiro07ObjetoClone.java @@ -0,0 +1,58 @@ +/** + * Ponteiro + * @author Max do Val Machado + * @version 3 01/2016 + */ +class Cliente{ + private int codigo; + private String nome; + public Cliente(){ + this(0, ""); + } + public Cliente(int codigo){ + this(codigo, ""); + } + public Cliente(int codigo, String nome){ + this.codigo = codigo; + this.nome = nome; + } + public int getCodigo(){ + return codigo; + } + public void setCodigo(int codigo){ + this.codigo = codigo; + } + public String getNome(){ + return nome; + } + public void setNome(String nome){ + this.nome = nome; + } + public Cliente clone(){ + return new Cliente(this.codigo, this.nome); + } +} + +class Ponteiro07ObjetoClone { + + public static void main (String[] args){ + + //Declarando tres ponteiros + Cliente c1 = null, c2 = null, c3 = null; + System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")"); + + //Alocando areas de memoria (ou inicializando objetos) e apontando os ponteiros para tais areas + c1 = new Cliente(1, "aa"); + c2 = c1; + c3 = new Cliente(2, "bb"); + System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")"); + + //Setando o codigo apontado por c1 e c2 + c2.setCodigo(3); + System.out.println("ATRIBUTOs:"); + System.out.println("c1(" + c1.getCodigo() + " / " + c1.getNome()+")"); + System.out.println("c2(" + c2.getCodigo() + " / " + c2.getNome()+")"); + System.out.println("c3(" + c3.getCodigo() + " / " + c3.getNome()+")"); + + } +} diff --git a/fonte/U0 - Nivelamento/java/recursividade/ChamandoMetodo.java b/fonte/U0 - Nivelamento/java/recursividade/ChamandoMetodo.java new file mode 100644 index 0000000..266ba68 --- /dev/null +++ b/fonte/U0 - Nivelamento/java/recursividade/ChamandoMetodo.java @@ -0,0 +1,20 @@ +class ChamandoMetodo { + public static void primeiro(){ + System.out.println("1o - inicio"); + segundo(); + System.out.println("1o - fim"); + } + public static void segundo(){ + System.out.println("2o - inicio"); + terceiro(); + System.out.println("2o - fim"); + } + public static void terceiro(){ + System.out.println("3o - inicio e fim"); + } + public static void main (String[] args){ + System.out.println("main - inicio"); + primeiro(); + System.out.println("main - fim"); + } +} diff --git a/fonte/U0 - Nivelamento/java/recursividade/ContarMaiuscula.java b/fonte/U0 - Nivelamento/java/recursividade/ContarMaiuscula.java new file mode 100644 index 0000000..df268db --- /dev/null +++ b/fonte/U0 - Nivelamento/java/recursividade/ContarMaiuscula.java @@ -0,0 +1,40 @@ +/** + * Recursividade + * @author Max do Val Machado + * @version 2 01/2015 + */ +class ContarMaiuscula { + public static boolean isUpper(char x){ + return (x >= 'A' && x <= 'Z'); + } + + public static int contMaiusculo(String s){ + int cont = 0; + + for(int i = 0; i < s.length(); i++){ + if(isUpper(s.charAt(i)) == true){ + cont++; + } + } + return cont; + } + public static int contMaiusculo2(String s){ + return contMaiusculo2(s, 0); + } + public static int contMaiusculo2(String s, int i){ + int cont = 0; + + if(i < s.length()){ + if(isUpper(s.charAt(i)) == true){ + cont++; + } + cont += contMaiusculo2(s, i + 1); + } + return cont; + } + + public static void main (String[] args){ + System.out.println("AlGoritmos e Estruturas de Dados: " + contMaiusculo("AlGoritmos e Estruturas de Dados")); + System.out.println("AlGoritmos e Estruturas de Dados: " + contMaiusculo2("AlGoritmos e Estruturas de Dados")); + } +} diff --git a/fonte/U0 - Nivelamento/java/recursividade/FatorialRecursivo.java b/fonte/U0 - Nivelamento/java/recursividade/FatorialRecursivo.java new file mode 100644 index 0000000..03361f2 --- /dev/null +++ b/fonte/U0 - Nivelamento/java/recursividade/FatorialRecursivo.java @@ -0,0 +1,20 @@ +/** + * Recursividade + * @author Max do Val Machado + * @version 2 01/2015 + */ +class FatorialRecursivo{ + public static int fatorial(int n){ + int resp; + System.out.println("fat (" + n + ")"); + resp = (n == 1) ? 1 : n * fatorial(n-1); + System.out.println("fat n(" + n + "): " + resp); + return resp; + } + + public static void main(String[] args){ + int n = Integer.parseInt(args[0]); + System.out.println("FATORIAL RECURSIVO(" + n + "): " + fatorial(n)); + } +} + diff --git a/fonte/U0 - Nivelamento/java/recursividade/FibonacciRecursivo.java b/fonte/U0 - Nivelamento/java/recursividade/FibonacciRecursivo.java new file mode 100644 index 0000000..54a9e74 --- /dev/null +++ b/fonte/U0 - Nivelamento/java/recursividade/FibonacciRecursivo.java @@ -0,0 +1,18 @@ +/** + * Recursividade + * @author Max do Val Machado + * @version 2 01/2015 + */ +class FibonacciRecursivo { + public static int fibRec (int n){ + int resp; + System.out.println("fib (" + n + ")"); + resp = (n == 0 || n == 1) ? 1 : fibRec(n-1) + fibRec(n-2); + System.out.println("fib (" + n + "): " + resp); + return resp; + } + public static void main (String[] args){ + int n = Integer.parseInt(args[0]); + System.out.println("FIBONACCI RECURSIVO(" + n + "): " + fibRec(n)); + } +} diff --git a/fonte/U0 - Nivelamento/java/recursividade/Multiplicacao.java b/fonte/U0 - Nivelamento/java/recursividade/Multiplicacao.java new file mode 100644 index 0000000..1e8b339 --- /dev/null +++ b/fonte/U0 - Nivelamento/java/recursividade/Multiplicacao.java @@ -0,0 +1,31 @@ +class Multiplicacao { + public static int multiplicacao(int a, int b){ + return multiplicacao(a, b, 0); + } + + public static int multiplicacao(int a, int b, int i){ + int resp = 0; + + if(i < b){ + resp = a + multiplicacao(a, b, i+1); + } + + return resp; + } + + public static int multiplicacaoInt(int a, int b){ + int resp = 0; + for(int i = 0; i < b; i++){ + resp = a + resp; + } + return resp; + } + + public static void main (String[] args){ + int mult = multiplicacaoInt(4, 3); + System.out.println("RESPOSTA INT: " + mult); + + mult = multiplicacao(4, 3); + System.out.println("RESPOSTA REC: " + mult); + } +} diff --git a/fonte/U0 - Nivelamento/java/recursividade/PrintRecursivo.java b/fonte/U0 - Nivelamento/java/recursividade/PrintRecursivo.java new file mode 100644 index 0000000..fe93fcd --- /dev/null +++ b/fonte/U0 - Nivelamento/java/recursividade/PrintRecursivo.java @@ -0,0 +1,18 @@ +/** + * Recursividade + * @author Max do Val Machado + * @version 2 01/2015 + */ +class PrintRecursivo{ + public static void printRecursivo(int i){ + System.out.println("valor de i: " + i); + if(i > 0){ + printRecursivo(i-1); + } + System.out.println("valor de i: " + i); + } + public static void main(String[] args){ + int n = Integer.parseInt(args[0]); + printRecursivo(n); + } +} diff --git a/fonte/U0 - Nivelamento/java/tratamentoExcecao/TratamentoExcecao01.java b/fonte/U0 - Nivelamento/java/tratamentoExcecao/TratamentoExcecao01.java new file mode 100644 index 0000000..300b29c --- /dev/null +++ b/fonte/U0 - Nivelamento/java/tratamentoExcecao/TratamentoExcecao01.java @@ -0,0 +1,12 @@ +/** + * Tratamento de excecao + * @author Max do Val Machado + * @version 2 01/2015 + */ +public class TratamentoExcecao01 { + public static void main(String[] args) { + Integer i = new Integer(args[0]); + MyIO.println("A variavel i vale " + i); + MyIO.println("FIM DE PROGRAMA!!!"); + } +} diff --git a/fonte/U0 - Nivelamento/java/tratamentoExcecao/TratamentoExcecao02.java b/fonte/U0 - Nivelamento/java/tratamentoExcecao/TratamentoExcecao02.java new file mode 100644 index 0000000..9712c33 --- /dev/null +++ b/fonte/U0 - Nivelamento/java/tratamentoExcecao/TratamentoExcecao02.java @@ -0,0 +1,19 @@ +/** + * Tratamento de excecao + * @author Max do Val Machado + * @version 2 01/2015 + */ +public class TratamentoExcecao02 { + public static void main(String[] args) { + try { + Integer i = new Integer(args[0]); + MyIO.println("A variavel i vale " + i); + + } catch (ArrayIndexOutOfBoundsException e){ + MyIO.println("Erro na passagem de parametros!!!"); + + } finally { + MyIO.println("FIM DE PROGRAMA!!!"); + } + } +} diff --git a/fonte/U0 - Nivelamento/java/tratamentoExcecao/TratamentoExcecao03.java b/fonte/U0 - Nivelamento/java/tratamentoExcecao/TratamentoExcecao03.java new file mode 100644 index 0000000..aec366e --- /dev/null +++ b/fonte/U0 - Nivelamento/java/tratamentoExcecao/TratamentoExcecao03.java @@ -0,0 +1,22 @@ +/** + * Tratamento de excecao + * @author Max do Val Machado + * @version 2 01/2015 + */ +public class TratamentoExcecao03 { + public static void main(String[] args) { + try { + Integer i = new Integer(args[0]); + MyIO.println("A variavel i vale " + i); + + } catch (NumberFormatException e) { + MyIO.println("Erro de formatacao!!!"); + + } catch (ArrayIndexOutOfBoundsException e){ + MyIO.println("Erro na passagem de parametros!!!"); + + } finally { + MyIO.println("FIM DE PROGRAMA!!!"); + } + } +} diff --git a/fonte/U0 - Nivelamento/java/tratamentoExcecao/TratamentoExcecao04.java b/fonte/U0 - Nivelamento/java/tratamentoExcecao/TratamentoExcecao04.java new file mode 100644 index 0000000..3b99bb2 --- /dev/null +++ b/fonte/U0 - Nivelamento/java/tratamentoExcecao/TratamentoExcecao04.java @@ -0,0 +1,37 @@ +/** + * Tratamento de excecao + * @author Max do Val Machado + * @version 2 01/2015 + */ +public class TratamentoExcecao04 { + public static void metodo1(String s) throws NumberFormatException, ArrayIndexOutOfBoundsException { + Integer i = new Integer(s); + MyIO.println("A variavel i vale " + i); + } + + public static void metodo2(String s) throws NumberFormatException { + Integer i = new Integer(s); + MyIO.println("A variavel i vale " + i); + } + + public static void main(String[] args) { + try { + metodo1(args[0]); + } catch (NumberFormatException e) { + MyIO.println("Erro!!!"); + + } catch (ArrayIndexOutOfBoundsException e){ + MyIO.println("Erro!!!"); + } + + MyIO.println("-------------->>>>>>>> <<<<<<<<--------------"); + + try { + metodo2(args[0]); + } catch (NumberFormatException e) { + MyIO.println("Erro!!!"); + } + + MyIO.println("-------------->>>>>>>> <<<<<<<<--------------"); + } +} diff --git a/fonte/U0 - Nivelamento/java/tratamentoExcecao/TratamentoExcecao05.java b/fonte/U0 - Nivelamento/java/tratamentoExcecao/TratamentoExcecao05.java new file mode 100644 index 0000000..9070d5d --- /dev/null +++ b/fonte/U0 - Nivelamento/java/tratamentoExcecao/TratamentoExcecao05.java @@ -0,0 +1,22 @@ +/** + * Tratamento de excecao + * @author Max do Val Machado + * @version 2 01/2015 + */ +public class TratamentoExcecao05 { + public static void metodo(int i) throws Exception { + if(i % 2 == 1){ + throw new Exception ("Valor impar"); + } + } + + public static void main(String[] args) throws Exception { + + int i = 2; + MyIO.println("-------------->>>>>>>> <<<<<<<<--------------"); + metodo(i); + MyIO.println("-------------->>>>>>>> <<<<<<<<--------------"); + metodo(++i); + MyIO.println("-------------->>>>>>>> <<<<<<<<--------------"); + } +} diff --git a/fonte/U3 - Fundamentos de análise de algoritmos/java/AND_OR.java b/fonte/U3 - Fundamentos de análise de algoritmos/java/AND_OR.java new file mode 100644 index 0000000..4543931 --- /dev/null +++ b/fonte/U3 - Fundamentos de análise de algoritmos/java/AND_OR.java @@ -0,0 +1,19 @@ +class AND_OR { + public static boolean m1(){ + System.out.println("m1"); + return true; + } + public static boolean m2(){ + System.out.println("m2"); + return false; + } + public static void main (String[] args) { + System.out.println("====================="); + boolean or = m1() || m2(); + System.out.println("OR: " + or); + System.out.println("====================="); + boolean and = m2() && m1(); + System.out.println("AND: " + and); + System.out.println("====================="); + } +} diff --git a/fonte/U3 - Fundamentos de análise de algoritmos/java/Log.java b/fonte/U3 - Fundamentos de análise de algoritmos/java/Log.java new file mode 100644 index 0000000..839ea75 --- /dev/null +++ b/fonte/U3 - Fundamentos de análise de algoritmos/java/Log.java @@ -0,0 +1,17 @@ +class Log { + public static void main (String[] args) { + int[] n = {4,5,6,7,8,9,10,11,12,13,14,15,16,17,31,32,33,63,64,65}; + int cont; + + for(int k = 0; k < n.length; k++){ + System.out.print("\n[n = " + n[k] + "] => "); + cont = 0; + for(int i = n[k]; i > 0; i /= 2){ + System.out.print(" " + i); + cont++; + } + System.out.print(" (" + cont + " vezes)"); + } + System.out.print("\n"); + } +} diff --git a/fonte/U3 - Fundamentos de análise de algoritmos/java/Pesquisa.java b/fonte/U3 - Fundamentos de análise de algoritmos/java/Pesquisa.java new file mode 100644 index 0000000..e6e5170 --- /dev/null +++ b/fonte/U3 - Fundamentos de análise de algoritmos/java/Pesquisa.java @@ -0,0 +1,61 @@ +class Pesquisa { + public static boolean pesqSeq(int[] vet, int x){ + boolean resp = false; + int n = vet.length; + + for(int i = 0; i < n; i++){ + if(vet[i] == x){ + resp = true; + i = n; + } + } + return resp; + } + + public static boolean pesqBin(int[] vet, int x){ + boolean resp = false; + int dir = (vet.length - 1), esq = 0, meio; + + while (esq <= dir){ + meio = (esq + dir) / 2; + if(x == vet[meio]){ + resp = true; + esq = dir + 1; + } else if (x > vet[meio]) { + esq = meio + 1; + } else { + dir = meio - 1; + } + } + return resp; + } + + public static boolean pesqBinRec(int[] vet, int x){ + return pesqBinRec(vet, x, 0, (vet.length - 1)); + } + + public static boolean pesqBinRec(int[] vet, int x, int esq, int dir){ + boolean resp; + int meio = (esq + dir) / 2; + + if(esq > dir) { + resp = false; + } else if(x == vet[meio]){ + resp = true; + } else if (x > vet[meio]) { + resp = pesqBinRec(vet, x, meio + 1, dir); + } else { + resp = pesqBinRec(vet, x, esq, meio - 1); + } + return resp; + } + + public static void main (String[] args){ + int[] vet = {2, 3, 5, 7, 9, 11, 15, 17, 20, 21, 30, 43, 49, 70, 71, 82}; + int x = 35; + + System.out.println("Pesquisa Sequencial: " + pesqSeq(vet, x)); + System.out.println("Pesquisa Binária: " + pesqBin(vet, x)); + System.out.println("Pesquisa Binária Recursiva: " + pesqBinRec(vet, x)); + } +} 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 new file mode 100644 index 0000000..6bcad68 --- /dev/null +++ b/fonte/U4 - Ordenação em memória principal/java/Bolha.java @@ -0,0 +1,51 @@ +/** + * Metodo de ordenacao da bolha + * @author Max do Val Machado + * @version 2 01/2015 + */ +class Bolha extends Geracao { + + /** + * Construtor. + */ + public Bolha(){ + super(); + } + + + /** + * Construtor. + * @param int tamanho do array de numeros inteiros. + */ + public Bolha(int tamanho){ + super(tamanho); + } + + + /** + * Algoritmo de ordenacao Bolha. + */ + public static void bolha() { + for (int i = (n - 1); i > 0; i--) { + for (int j = 0; j < i; j++) { + if (array[j] > array[j + 1]) { + swap(j, j+1); + } + } + } + } + + + 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.java b/fonte/U4 - Ordenação em memória principal/java/Countingsort.java new file mode 100644 index 0000000..a742981 --- /dev/null +++ b/fonte/U4 - Ordenação em memória principal/java/Countingsort.java @@ -0,0 +1,79 @@ +/** + * Metodo de ordenacao por contagem + * @author Max do Val Machado + * @version 2 01/2015 + */ + +class Countingsort extends Geracao { + + /** + * Construtor. + */ + public Countingsort(){ + super(); + } + + + /** + * Construtor. + * @param int tamanho do array de numeros inteiros. + */ + public Countingsort(int tamanho){ + super(tamanho); + } + + + /** + * 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() { + //Array para contar o numero de ocorrencias de cada elemento + int[] count = new int[getMaior() + 1]; + int[] ordenado = new int[n]; + + //Inicializar cada posicao do array de contagem + for (int i = 0; i < count.length; 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 < count.length; 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++); + } + + + 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."); + } +} 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 new file mode 100644 index 0000000..1156981 --- /dev/null +++ b/fonte/U4 - Ordenação em memória principal/java/ExercicioDuvidaAND.java @@ -0,0 +1,17 @@ +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.java b/fonte/U4 - Ordenação em memória principal/java/Geracao.java new file mode 100644 index 0000000..819b202 --- /dev/null +++ b/fonte/U4 - Ordenação em memória principal/java/Geracao.java @@ -0,0 +1,149 @@ +/** + * Geracao de elementos de um array + * @author Max do Val Machado + * @version 2 01/2015 + */ + +import java.util.*; + +class Geracao { + protected static int[] array; + protected static int n; + + + /** + * Construtor. + */ + public Geracao(){ + array = new int[100]; + n = array.length; + } + + + /** + * Construtor. + * @param int tamanho do array de numeros inteiros. + */ + public Geracao(int tamanho){ + array = new int[tamanho]; + n = array.length; + } + + + /** + * Produz um array ordenado de modo crescente. + */ + public static void crescente() { + for (int i = 0; i < n; i++) { + array[i] = i; + } + } + + /** + * Produz um array ordenado de modo decrescente. + */ + public static 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(); + + for (int i = 0; i < n; i++) { + array[i] = Math.abs(gerador.nextInt()) % 1000; // 0 a 999 + } + } + + + /** + * Efetua a leitura dos elementos via entrada padrao. + */ + public static void entradaPadrao() { + n = MyIO.readInt(); + array = new int[n]; + + for (int i = 0; i < n; i++) { + array[i] = MyIO.readInt(); + } + } + + public static void entrada(int[] vet){ + n = vet.length; + array = new int[n]; + for(int i = 0; i < n; i++){ + array[i] = vet[i]; + } + } + + + /** + * Mostra os array de um array. + * @param int k indica a quantidade de elementos do array a serem mostrados. + */ + public static void mostrar(int k) { + System.out.print("[ "); + + for (int i = 0; i < k; i++) { + System.out.print(array[i] + " "); + } + + System.out.println("] "); + } + + + /** + * Mostra os array de um array. + */ + public static void mostrar() { + System.out.print("[ "); + + for (int i = 0; i < n; i++) { + System.out.print("("+i+")" + array[i] + " "); + } + + System.out.println("] "); + } + + + /** + * Troca o conteudo de duas posicoes do array + * @param i int primeira posicao + * @param j int segunda posicao + */ + public static void swap(int i, int j) { + int temp = array[i]; + array[i] = array[j]; + array[j] = temp; + } + + + /** + * Retorna o timestamp atual + * @return timestamp atual + */ + public static long now(){ + return new Date().getTime(); + } + + + /** + * Retorna verdadeiro/falso indicando se o array esta ordenado + * @return boolean indicando se o array esta ordenado + */ + public static boolean isOrdenado(){ + boolean resp = true; + for(int i = 1; i < n; i++){ + if(array[i] < array[i-1]){ + i = n; + resp = false; + } + } + return resp; + } +} 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 new file mode 100644 index 0000000..293162c --- /dev/null +++ b/fonte/U4 - Ordenação em memória principal/java/Heapsort.java @@ -0,0 +1,100 @@ +/** + * Algoritmo de ordenacao Heapsort + * @author Max do Val Machado + * @version 2 01/2015 + */ + +class Heapsort extends Geracao { + + /** + * Construtor. + */ + public Heapsort(){ + super(); + } + + + /** + * 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() { + //Alterar o vetor ignorando a posicao zero + int[] tmp = new int[n+1]; + for(int i = 0; i < n; i++){ + tmp[i+1] = array[i]; + } + array = tmp; + + //Contrucao do heap + for(int tamHeap = 2; tamHeap <= n; tamHeap++){ + constroi(tamHeap); + } + + //Ordenacao propriamente dita + int tamHeap = n; + while(tamHeap > 1){ + swap(1, tamHeap--); + reconstroi(tamHeap); + } + + //Alterar o vetor para voltar a posicao zero + tmp = array; + array = new int[n]; + for(int i = 0; i < n; i++){ + array[i] = tmp[i+1]; + } + } + + + 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."); + } +} 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 new file mode 100644 index 0000000..753761e --- /dev/null +++ b/fonte/U4 - Ordenação em memória principal/java/Insercao.java @@ -0,0 +1,55 @@ +/** + * Algoritmo de ordenacao por insercao + * @author Max do Val Machado + * @version 2 01/2015 + */ + +class Insercao extends Geracao { + + /** + * Construtor. + */ + public Insercao(){ + super(); + } + + + /** + * Construtor. + * @param int tamanho do array de numeros inteiros. + */ + public Insercao(int tamanho){ + super(tamanho); + } + + + /** + * Algoritmo de ordenacao por insercao. + */ + public static void insercao() { + 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; + } + } + + + 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/Quicksort.java b/fonte/U4 - Ordenação em memória principal/java/Quicksort.java new file mode 100644 index 0000000..24d4e15 --- /dev/null +++ b/fonte/U4 - Ordenação em memória principal/java/Quicksort.java @@ -0,0 +1,66 @@ +/** + * Algoritmo de ordenacao Quicksort + * @author Max do Val Machado + * @version 2 01/2015 + */ +class Quicksort extends Geracao { + + /** + * Construtor. + */ + public Quicksort(){ + super(); + } + + + /** + * Construtor. + * @param int tamanho do array de numeros inteiros. + */ + public Quicksort(int tamanho){ + super(tamanho); + } + + + /** + * Algoritmo de ordenacao Quicksort. + */ + public static void quicksort() { + quicksort(0, n-1); + } + + /** + * Algoritmo de ordenacao Quicksort. + * @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) { + 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(i, j); + i++; + j--; + } + } + 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.java b/fonte/U4 - Ordenação em memória principal/java/Selecao.java new file mode 100644 index 0000000..dde0012 --- /dev/null +++ b/fonte/U4 - Ordenação em memória principal/java/Selecao.java @@ -0,0 +1,54 @@ +/** + * Algoritmo de ordenacao por selecao + * @author Max do Val Machado + * @version 2 01/2015 + */ + +class Selecao extends Geracao { + + /** + * Construtor. + */ + public Selecao(){ + super(); + } + + + /** + * Construtor. + * @param int tamanho do array de numeros inteiros. + */ + public Selecao(int tamanho){ + super(tamanho); + } + + + /** + * Algoritmo de ordenacao por selecao. + */ + public static void selecao() { + 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(menor, i); + } + } + + + public static void main(String[] args) { + Selecao selecao = new Selecao(100); + selecao.aleatorio(); + selecao.mostrar(); + + long comeco = now(); + selecao.selecao(); + long fim = now(); + + selecao.mostrar(); + System.out.println("Tempo para ordenar: " + (fim-comeco)/1000.0 + " s."); + } +} 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 new file mode 100644 index 0000000..77353d9 --- /dev/null +++ b/fonte/U4 - Ordenação em memória principal/java/Shellsort.java @@ -0,0 +1,73 @@ +/** + * Algoritmo de ordenacao Shellsort + * @author Max do Val Machado + * @version 2 01/2015 + */ + +class Shellsort extends Geracao { + + /** + * Construtor. + */ + public Shellsort(){ + super(); + } + + + /** + * Construtor. + * @param int tamanho do array de numeros inteiros. + */ + public Shellsort(int tamanho){ + super(tamanho); + } + + + /** + * Algoritmo de ordenacao Shellsort. + */ + public static void shellsort() { + int h = 1; + + do { h = (h * 3) + 1; } while (h < n); + + do { + h /= 3; + for(int cor = 0; cor < h; cor++){ + insercaoPorCor(cor, h); + } + } while (h != 1); + } + + + /** + * Metodo que efetua a insercao nos pseudo-arrays do Shellsort. + * @param int cor cor do pseudo array. + * @param int h passo do shelsort + */ + public static void insercaoPorCor(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; + } + } + + + 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/U5 - Estruturas de dados lineares e flexíveis/c/coletalixo/coletalixo.c b/fonte/U5 - Estruturas de dados lineares e flexíveis/c/coletalixo/coletalixo.c new file mode 100644 index 0000000..22269b8 --- /dev/null +++ b/fonte/U5 - Estruturas de dados lineares e flexíveis/c/coletalixo/coletalixo.c @@ -0,0 +1,38 @@ +#include +#include +#define true 1 + +typedef struct Celula { + int elemento; // Elemento inserido na celula. + struct Celula* prox; // Aponta a celula prox. +} Celula; + +Celula* novaCelula(int elemento) { + Celula* nova = (Celula*) malloc(sizeof(Celula)); + nova->elemento = elemento; + nova->prox = NULL; + return nova; +} + +Celula* primeiro; + +void start () { + primeiro = novaCelula(-1); +} + +void inserir(int x) { + primeiro->prox = novaCelula(x); + Celula* tmp = primeiro; + primeiro = primeiro->prox; + free(tmp); +} + +int main(int argc, char** argv) { + start(); + while(true){ + inserir(0); + } + return 0; +} + + diff --git a/fonte/U5 - Estruturas de dados lineares e flexíveis/c/fila/fila.c b/fonte/U5 - Estruturas de dados lineares e flexíveis/c/fila/fila.c new file mode 100644 index 0000000..9a79805 --- /dev/null +++ b/fonte/U5 - Estruturas de dados lineares e flexíveis/c/fila/fila.c @@ -0,0 +1,135 @@ +/** + * Fila dinamica + * @author Max do Val Machado + * @version 2 01/2015 + */ +#include +#include +#include + +//TIPO CELULA =================================================================== +typedef struct Celula { + int elemento; // Elemento inserido na celula. + struct Celula* prox; // Aponta a celula prox. +} Celula; + +Celula* novaCelula(int elemento) { + Celula* nova = (Celula*) malloc(sizeof(Celula)); + nova->elemento = elemento; + nova->prox = NULL; + return nova; +} + +//FILA PROPRIAMENTE DITA ======================================================== +Celula* primeiro; +Celula* ultimo; + + +/** + * Cria uma fila sem elementos (somente no cabeca). + */ +void start () { + primeiro = novaCelula(-1); + ultimo = primeiro; +} + + +/** + * Insere elemento na fila (politica FIFO). + * @param x int Elemento a inserir. + */ +void inserir(int x) { + ultimo->prox = novaCelula(x); + ultimo = ultimo->prox; +} + + +/** + * Remove elemento da fila (politica FIFO). + * @return Elemento removido. + */ +int remover() { + if (primeiro == ultimo) { + errx(1, "Erro ao remover!"); + } + Celula* tmp = primeiro; + primeiro = primeiro->prox; + int resp = primeiro->elemento; + tmp->prox = NULL; + free(tmp); + tmp = NULL; + return resp; +} + + +/** + * Mostra os elementos separados por espacos. + */ +void mostrar() { + Celula* i; + printf("[ "); + for (i = primeiro->prox; i != NULL; i = i->prox) { + printf("%d ", i->elemento); + } + printf("] \n"); +} + + +//METODO PRINCIPAL ============================================================== +int main(int argc, char** argv){ + int x1, x2, x3; + printf("\n==== FILA DINAMICA ===="); + + start(); + + inserir(5); + inserir(7); + inserir(8); + inserir(9); + + printf("\nApos insercoes(5, 7, 8, 9): "); + mostrar(); + + x1 = remover(); + x2 = remover(); + + printf("\nApos remocoes (%d, %d):", x1, x2); + mostrar(); + + inserir(3); + inserir(4); + + + printf("\nApos insercoes(3, 4): "); + mostrar(); + + x1 = remover(); + x2 = remover(); + x3 = remover(); + + printf("\nApos remocoes (%d, %d, %d):", x1, x2, x3); + mostrar(); + + inserir(4); + inserir(5); + + printf("\nApos insercoes(4, 5): "); + mostrar(); + + x1 = remover(); + x2 = remover(); + + printf("\nApos remocoes (%d, %d):", x1, x2); + mostrar(); + + inserir(6); + inserir(7); + + printf("\nApos insercoes(6, 7): "); + mostrar(); + + x1 = remover(); + + printf("\nApos remocao (%d):", x1); + mostrar(); +} diff --git a/fonte/U5 - Estruturas de dados lineares e flexíveis/c/linear/fila.c b/fonte/U5 - Estruturas de dados lineares e flexíveis/c/linear/fila.c new file mode 100644 index 0000000..2c4c530 --- /dev/null +++ b/fonte/U5 - Estruturas de dados lineares e flexíveis/c/linear/fila.c @@ -0,0 +1,143 @@ +/** + * Lista estatica + * @author Max do Val Machado + * @version 2 01/2015 + */ +#include +#include + +#define MAXTAM 6 +#define bool short +#define true 1 +#define false 0 + +int array[MAXTAM+1]; // Elementos da pilha +int primeiro; // Remove do indice "primeiro". +int ultimo; // Insere no indice "ultimo". + + +/** + * Inicializacoes + */ +void start(){ + primeiro = ultimo = 0; +} + + +/** + * Insere um elemento na ultima posicao da + * @param x int elemento a ser inserido. + * @Se a fila estiver cheia. + */ +void inserir(int x) { + + //validar insercao + if (((ultimo + 1) % MAXTAM) == primeiro) { + printf("Erro ao inserir!"); + exit(1); + } + + array[ultimo] = x; + ultimo = (ultimo + 1) % MAXTAM; +} + + +/** + * Remove um elemento da primeira posicao da fila e movimenta + * os demais elementos para o primeiro da mesma. + * @return resp int elemento a ser removido. + * @Se a fila estiver vazia. + */ +int remover() { + + //validar remocao + if (primeiro == ultimo) { + printf("Erro ao remover!"); + exit(1); + } + + int resp = array[primeiro]; + primeiro = (primeiro + 1) % MAXTAM; + return resp; +} + + +/** + * Mostra os array separados por espacos. + */ +void mostrar (){ + int i; + printf("\n["); + + for(i = primeiro; i != ultimo; i = ((i + 1) % MAXTAM)) { + printf(" %d", array[i]); + } + + printf(" ]"); +} + + +/** + * Retorna um bool indicando se a fila esta vazia + * @return bool indicando se a fila esta vazia + */ +bool isVazia() { + return (primeiro == ultimo); +} + + +int main(int argc, char** argv){ + int x1, x2, x3; + printf("\n==== FILA ESTATICA ===="); + + inserir(5); + inserir(7); + inserir(8); + inserir(9); + + printf("\nApos insercoes(5, 7, 8, 9): "); + mostrar(); + + x1 = remover(); + x2 = remover(); + + printf("\nApos remocoes (%d, %d):", x1, x2); + mostrar(); + + inserir(3); + inserir(4); + + + printf("\nApos insercoes(3, 4): "); + mostrar(); + + x1 = remover(); + x2 = remover(); + x3 = remover(); + + printf("\nApos remocoes (%d, %d, %d):", x1, x2, x3); + mostrar(); + + inserir(4); + inserir(5); + + printf("\nApos insercoes(4, 5): "); + mostrar(); + + x1 = remover(); + x2 = remover(); + + printf("\nApos remocoes (%d, %d):", x1, x2); + mostrar(); + + inserir(6); + inserir(7); + + printf("\nApos insercoes(6, 7): "); + mostrar(); + + x1 = remover(); + + printf("\nApos remocao (%d):", x1); + mostrar(); +} diff --git a/fonte/U5 - Estruturas de dados lineares e flexíveis/c/linear/lista.c b/fonte/U5 - Estruturas de dados lineares e flexíveis/c/linear/lista.c new file mode 100644 index 0000000..fa56475 --- /dev/null +++ b/fonte/U5 - Estruturas de dados lineares e flexíveis/c/linear/lista.c @@ -0,0 +1,215 @@ +/** + * Lista estatica + * @author Max do Val Machado + * @version 2 01/2015 + */ +#include +#include + +#define MAXTAM 6 +#define bool short +#define true 1 +#define false 0 + +int array[MAXTAM]; // Elementos da pilha +int n; // Quantidade de array. + + +/** + * Inicializacoes + */ +void start(){ + n = 0; +} + + +/** + * Insere um elemento na primeira posicao da lista e move os demais + * elementos para o fim da + * @param x int elemento a ser inserido. + */ +void inserirInicio(int x) { + int i; + + //validar insercao + if(n >= MAXTAM){ + printf("Erro ao inserir!"); + exit(1); + } + + //levar elementos para o fim do array + for(i = n; i > 0; i--){ + array[i] = array[i-1]; + } + + array[0] = x; + n++; +} + + +/** + * Insere um elemento na ultima posicao da + * @param x int elemento a ser inserido. + */ +void inserirFim(int x) { + + //validar insercao + if(n >= MAXTAM){ + printf("Erro ao inserir!"); + exit(1); + } + + array[n] = x; + n++; +} + + +/** + * Insere um elemento em uma posicao especifica e move os demais + * elementos para o fim da + * @param x int elemento a ser inserido. + * @param pos Posicao de insercao. + */ +void inserir(int x, int pos) { + int i; + + //validar insercao + if(n >= MAXTAM || pos < 0 || pos > n){ + printf("Erro ao inserir!"); + exit(1); + } + + //levar elementos para o fim do array + for(i = n; i > pos; i--){ + array[i] = array[i-1]; + } + + array[pos] = x; + n++; +} + + +/** + * Remove um elemento da primeira posicao da lista e movimenta + * os demais elementos para o inicio da mesma. + * @return resp int elemento a ser removido. + */ +int removerInicio() { + int i, resp; + + //validar remocao + if (n == 0) { + printf("Erro ao remover!"); + exit(1); + } + + resp = array[0]; + n--; + + for(i = 0; i < n; i++){ + array[i] = array[i+1]; + } + + return resp; +} + + +/** + * Remove um elemento da ultima posicao da + * @return resp int elemento a ser removido. + */ +int removerFim() { + + //validar remocao + if (n == 0) { + printf("Erro ao remover!"); + exit(1); + } + + return array[--n]; +} + + +/** + * Remove um elemento de uma posicao especifica da lista e + * movimenta os demais elementos para o inicio da mesma. + * @param pos Posicao de remocao. + * @return resp int elemento a ser removido. + */ +int remover(int pos) { + int i, resp; + + //validar remocao + if (n == 0 || pos < 0 || pos >= n) { + printf("Erro ao remover!"); + exit(1); + } + + resp = array[pos]; + n--; + + for(i = pos; i < n; i++){ + array[i] = array[i+1]; + } + + return resp; +} + + +/** + * Mostra os array separados por espacos. + */ +void mostrar (){ + int i; + + printf("[ "); + + for(i = 0; i < n; i++){ + printf("%d ", array[i]); + } + + printf("]\n"); +} + + +/** + * Procura um array e retorna se ele existe. + * @param x int elemento a ser pesquisado. + * @return true se o array existir, + * false em caso contrario. + */ +bool pesquisar(int x) { + bool retorno = false; + int i; + + for (i = 0; i < n && retorno == false; i++) { + retorno = (array[i] == x); + } + return retorno; +} + + +int main(int argc, char** argv){ + int x1, x2, x3; + + printf("==== LISTA ESTATICA ====\n"); + + start(); + + inserirInicio(1); + inserirInicio(0); + inserirFim(2); + inserirFim(3); + inserir(4, 3); + inserir(5, 2); + + printf("Apos insercoes: "); + mostrar(); + + x1 = removerInicio(); + x2 = removerFim(); + x3 = remover(2); + + printf("Apos remocoes (%d, %d, %d): ", x1, x2, x3); + mostrar(); +} diff --git a/fonte/U5 - Estruturas de dados lineares e flexíveis/c/listadupla/listadupla.c b/fonte/U5 - Estruturas de dados lineares e flexíveis/c/listadupla/listadupla.c new file mode 100644 index 0000000..63c450f --- /dev/null +++ b/fonte/U5 - Estruturas de dados lineares e flexíveis/c/listadupla/listadupla.c @@ -0,0 +1,267 @@ +/** + * Lista dupla dinamica + * @author Max do Val Machado + * @version 2 01/2015 + */ +#include +#include +#include + +#define bool short +#define true 1 +#define false 0 + +//TIPO CELULA =================================================================== +typedef struct CelulaDupla { + int elemento; // Elemento inserido na celula. + struct CelulaDupla* prox; // Aponta a celula prox. + struct CelulaDupla* ant; // Aponta a celula anterior. +} CelulaDupla; + +CelulaDupla* novaCelulaDupla(int elemento) { + CelulaDupla* nova = (CelulaDupla*) malloc(sizeof(CelulaDupla)); + nova->elemento = elemento; + nova->ant = nova->prox = NULL; + return nova; +} + +//LISTA PROPRIAMENTE DITA ======================================================= +CelulaDupla* primeiro; +CelulaDupla* ultimo; + + +/** + * Cria uma lista dupla sem elementos (somente no cabeca). + */ +void start () { + primeiro = novaCelulaDupla(-1); + ultimo = primeiro; +} + + +/** + * Insere um elemento na primeira posicao da lista. + * @param x int elemento a ser inserido. + */ +void inserirInicio(int x) { + CelulaDupla* tmp = novaCelulaDupla(x); + + tmp->ant = primeiro; + tmp->prox = primeiro->prox; + primeiro->prox = tmp; + if (primeiro == ultimo) { + ultimo = tmp; + } else { + tmp->prox->ant = tmp; + } + tmp = NULL; +} + + +/** + * Insere um elemento na ultima posicao da lista. + * @param x int elemento a ser inserido. + */ +void inserirFim(int x) { + ultimo->prox = novaCelulaDupla(x); + ultimo->prox->ant = ultimo; + ultimo = ultimo->prox; +} + + +/** + * Remove um elemento da primeira posicao da lista. + * @return resp int elemento a ser removido. + */ +int removerInicio() { + if (primeiro == ultimo) { + errx(1, "Erro ao remover (vazia)!"); + } + + CelulaDupla* tmp = primeiro; + primeiro = primeiro->prox; + int resp = primeiro->elemento; + tmp->prox = primeiro->ant = NULL; + free(tmp); + tmp = NULL; + return resp; +} + + +/** + * Remove um elemento da ultima posicao da lista. + * @return resp int elemento a ser removido. + */ +int removerFim() { + if (primeiro == ultimo) { + errx(1, "Erro ao remover (vazia)!"); + } + int resp = ultimo->elemento; + ultimo = ultimo->ant; + ultimo->prox->ant = NULL; + free(ultimo->prox); + ultimo->prox = NULL; + return resp; +} + + +/** + * Calcula e retorna o tamanho, em numero de elementos, da lista. + * @return resp int tamanho + */ +int tamanho() { + int tamanho = 0; + CelulaDupla* i; + for(i = primeiro; i != ultimo; i = i->prox, tamanho++); + return tamanho; +} + + +/** + * Insere um elemento em uma posicao especifica considerando que o + * primeiro elemento valido esta na posicao 0. + * @param x int elemento a ser inserido. + * @param pos int posicao da insercao. + * @throws Exception Se posicao invalida. + */ +void inserir(int x, int pos) { + + int tam = tamanho(); + + if(pos < 0 || pos > tam){ + errx(1, "Erro ao remover (posicao %d/%d invalida!", pos, tam); + } else if (pos == 0){ + inserirInicio(x); + } else if (pos == tam){ + inserirFim(x); + } else { + // Caminhar ate a posicao anterior a insercao + CelulaDupla* i = primeiro; + int j; + for(j = 0; j < pos; j++, i = i->prox); + + CelulaDupla* tmp = novaCelulaDupla(x); + tmp->ant = i; + tmp->prox = i->prox; + tmp->ant->prox = tmp->prox->ant = tmp; + tmp = i = NULL; + } +} + + +/** + * Remove um elemento de uma posicao especifica da lista + * considerando que o primeiro elemento valido esta na posicao 0. + * @param posicao Meio da remocao. + * @return resp int elemento a ser removido. + * @throws Exception Se posicao invalida. + */ +int remover(int pos) { + int resp; + int tam = tamanho(); + + if (primeiro == ultimo){ + errx(1, "Erro ao remover (vazia)!"); + } else if(pos < 0 || pos >= tam){ + errx(1, "Erro ao remover (posicao %d/%d invalida!", pos, tam); + } else if (pos == 0){ + resp = removerInicio(); + } else if (pos == tam - 1){ + resp = removerFim(); + } else { + // Caminhar ate a posicao anterior a insercao + CelulaDupla* i = primeiro->prox; + int j; + for(j = 0; j < pos; j++, i = i->prox); + + i->ant->prox = i->prox; + i->prox->ant = i->ant; + resp = i->elemento; + i->prox = i->ant = NULL; + free(i); + i = NULL; + } + + return resp; +} + + +/** + * Mostra os elementos da lista separados por espacos. + */ +void mostrar() { + CelulaDupla* i; + printf("[ "); + for (i = primeiro->prox; i != NULL; i = i->prox) { + printf("%d ", i->elemento); + } + printf("] \n"); +} + + +/** + * Mostra os elementos da lista de forma invertida + * e separados por espacos. + */ +void mostrarInverso() { + printf("[ "); + CelulaDupla* i; + for (i = ultimo; i != primeiro; i = i->ant){ + printf("%d ", i->elemento); + } + printf("] \n"); // Termina de mostrar. +} + + +/** + * Procura um elemento e retorna se ele existe. + * @param x Elemento a pesquisar. + * @return true se o elemento existir, + * false em caso contrario. + */ +bool pesquisar(int x) { + bool resp = false; + CelulaDupla* i; + + for (i = primeiro->prox; i != NULL; i = i->prox) { + if(i->elemento == x){ + resp = true; + i = ultimo; + } + } + return resp; +} + + +int main(int argc, char** argv) { + start(); + + printf("LISTA DINAMICA DUPLAMENTE ENCADEADA\n\n"); + + inserirInicio(2); + inserirInicio(1); + inserirFim(5); + inserirFim(6); + inserir(3, 2); + inserir(4, 3); + inserir(7, 6); + inserir(0, 0); + inserirFim(8); + inserirFim(9); + + printf("Apos insercoes: "); + mostrar(); + mostrarInverso(); + + remover(3); + remover(2); + removerFim(); + removerInicio(); + remover(0); + remover(4); + + printf("Apos remocoes: "); + mostrar(); + mostrarInverso(); + return 0; +} diff --git a/fonte/U5 - Estruturas de dados lineares e flexíveis/c/listasimples/lista.c b/fonte/U5 - Estruturas de dados lineares e flexíveis/c/listasimples/lista.c new file mode 100644 index 0000000..a5d0e25 --- /dev/null +++ b/fonte/U5 - Estruturas de dados lineares e flexíveis/c/listasimples/lista.c @@ -0,0 +1,248 @@ +/** + * Lista simples dinamica + * @author Max do Val Machado + * @version 2 01/2015 + */ +#include +#include +#include +#define bool short +#define true 1 +#define false 0 + +//TIPO CELULA =================================================================== +typedef struct Celula { + int elemento; // Elemento inserido na celula. + struct Celula* prox; // Aponta a celula prox. +} Celula; + +Celula* novaCelula(int elemento) { + Celula* nova = (Celula*) malloc(sizeof(Celula)); + nova->elemento = elemento; + nova->prox = NULL; + return nova; +} + +//LISTA PROPRIAMENTE DITA ======================================================= +Celula* primeiro; +Celula* ultimo; + + +/** + * Cria uma lista sem elementos (somente no cabeca). + */ +void start () { + primeiro = novaCelula(-1); + ultimo = primeiro; +} + + +/** + * Insere um elemento na primeira posicao da lista. + * @param x int elemento a ser inserido. + */ +void inserirInicio(int x) { + Celula* tmp = novaCelula(x); + tmp->prox = primeiro->prox; + primeiro->prox = tmp; + if (primeiro == ultimo) { + ultimo = tmp; + } + tmp = NULL; +} + +/** + * Insere um elemento na ultima posicao da lista. + * @param x int elemento a ser inserido. + */ +void inserirFim(int x) { + ultimo->prox = novaCelula(x); + ultimo = ultimo->prox; +} + + +/** + * Remove um elemento da primeira posicao da lista. + * @return resp int elemento a ser removido. + * @throws Exception Se a lista nao contiver elementos. + */ +int removerInicio() { + if (primeiro == ultimo) { + errx(1, "Erro ao remover!"); + } + + Celula* tmp = primeiro; + primeiro = primeiro->prox; + int resp = primeiro->elemento; + tmp->prox = NULL; + free(tmp); + tmp = NULL; + return resp; +} + + +/** + * Remove um elemento da ultima posicao da lista. + * @return resp int elemento a ser removido. + */ +int removerFim() { + if (primeiro == ultimo) { + errx(1, "Erro ao remover!"); + } + + // Caminhar ate a penultima celula: + Celula* i; + for(i = primeiro; i->prox != ultimo; i = i->prox); + + int resp = ultimo->elemento; + ultimo = i; + free(ultimo->prox); + i = ultimo->prox = NULL; + + return resp; +} + + +/** + * Calcula e retorna o tamanho, em numero de elementos, da lista. + * @return resp int tamanho + */ +int tamanho() { + int tamanho = 0; + Celula* i; + for(i = primeiro; i != ultimo; i = i->prox, tamanho++); + return tamanho; +} + + +/** + * Insere um elemento em uma posicao especifica considerando que o + * primeiro elemento valido esta na posicao 0. + * @param x int elemento a ser inserido. + * @param pos int posicao da insercao. + * @throws Exception Se posicao invalida. + */ +void inserir(int x, int pos) { + + int tam = tamanho(); + + if(pos < 0 || pos > tam){ + errx(1, "Erro ao inserir posicao (%d/ tamanho = %d) invalida!", pos, tam); + } else if (pos == 0){ + inserirInicio(x); + } else if (pos == tam){ + inserirFim(x); + } else { + // Caminhar ate a posicao anterior a insercao + int j; + Celula* i = primeiro; + for(j = 0; j < pos; j++, i = i->prox); + + Celula* tmp = novaCelula(x); + tmp->prox = i->prox; + i->prox = tmp; + tmp = i = NULL; + } +} + + +/** + * Remove um elemento de uma posicao especifica da lista + * considerando que o primeiro elemento valido esta na posicao 0. + * @param posicao Meio da remocao. + * @return resp int elemento a ser removido. + * @throws Exception Se posicao invalida. + */ +int remover(int pos) { + int resp; + int tam = tamanho(); + + if (primeiro == ultimo){ + errx(1, "Erro ao remover (vazia)!"); + } else if(pos < 0 || pos >= tam){ + errx(1, "Erro ao remover posicao (%d/ tamanho = %d) invalida!", pos, tam); + } else if (pos == 0){ + resp = removerInicio(); + } else if (pos == tam - 1){ + resp = removerFim(); + } else { + // Caminhar ate a posicao anterior a insercao + Celula* i = primeiro; + int j; + for(j = 0; j < pos; j++, i = i->prox); + + Celula* tmp = i->prox; + resp = tmp->elemento; + i->prox = tmp->prox; + tmp->prox = NULL; + free(tmp); + i = tmp = NULL; + } + return resp; +} + + +/** + * Mostra os elementos da lista separados por espacos. + */ +void mostrar() { + printf("[ "); + Celula* i; + for (i = primeiro->prox; i != NULL; i = i->prox) { + printf("%d ", i->elemento); + } + printf("] \n"); +} + + +/** + * Procura um elemento e retorna se ele existe. + * @param x Elemento a pesquisar. + * @return true se o elemento existir, + * false em caso contrario. + */ +bool pesquisar(int x) { + bool retorno = false; + Celula* i; + + for (i = primeiro->prox; i != NULL; i = i->prox) { + if(i->elemento == x){ + retorno = true; + i = ultimo; + } + } + return retorno; +} + + +int main(int argc, char** argv) { + int x1, x2, x3, x4, x5, x6; + printf("=== LISTA DINAMICA SIMPLESMENTE ENCADEADA === \n\n"); + + start(); + + inserirInicio(1); + inserirInicio(0); + inserirFim(4); + inserirFim(5); + inserir(2, 2); + inserir(3, 3); + inserir(6, 6); + inserir(-1, 0); + inserirFim(7); + inserirFim(8); + + printf("Apos insercoes: "); + mostrar(); + + x1 = remover(3); + x2 = remover(2); + x3 = removerFim(); + x4 = removerInicio(); + x5 = remover(0); + x6 = remover(4); + + printf("Apos remocoes (%d, %d, %d, %d, %d, %d): ", x1, x2, x3, x4, x5, x6); + mostrar(); + return 0; +} diff --git a/fonte/U5 - Estruturas de dados lineares e flexíveis/c/matriz/entrada.in b/fonte/U5 - Estruturas de dados lineares e flexíveis/c/matriz/entrada.in new file mode 100644 index 0000000..bf6e3cf --- /dev/null +++ b/fonte/U5 - Estruturas de dados lineares e flexíveis/c/matriz/entrada.in @@ -0,0 +1,37 @@ +quantidade de testes (por exemplo, 3) +linhas da primeira matriz do primeiro teste +colunas da primeira matriz do primeiro teste +x x x x x ... x +x x x x x ... x +... +x x x x x ... x +linhas da segunda matriz do primeiro teste +colunas da segunda matriz do primeiro teste +x x x x x ... x +x x x x x ... x +... +x x x x x ... x +linhas da primeira matriz do segundo teste +colunas da primeira matriz do segundo teste +x x x x x ... x +x x x x x ... x +... +x x x x x ... x +linhas da segunda matriz do segundo teste +colunas da segunda matriz do segundo teste +x x x x x ... x +x x x x x ... x +... +x x x x x ... x +linhas da primeira matriz do terceiro teste +colunas da primeira matriz do terceiro teste +x x x x x ... x +x x x x x ... x +... +x x x x x ... x +linhas da segunda matriz do terceiro teste +colunas da segunda matriz do terceiro teste +x x x x x ... x +x x x x x ... x +... +x x x x x ... x diff --git a/fonte/U5 - Estruturas de dados lineares e flexíveis/c/pilha/pilha.c b/fonte/U5 - Estruturas de dados lineares e flexíveis/c/pilha/pilha.c new file mode 100644 index 0000000..a8af26b --- /dev/null +++ b/fonte/U5 - Estruturas de dados lineares e flexíveis/c/pilha/pilha.c @@ -0,0 +1,103 @@ +/** + * Pilha dinamica + * @author Max do Val Machado + * @version 2 01/2015 + */ +#include +#include +#include + +//TIPO CELULA =================================================================== +typedef struct Celula { + int elemento; // Elemento inserido na celula. + struct Celula* prox; // Aponta a celula prox. +} Celula; + +Celula* novaCelula(int elemento) { + Celula* nova = (Celula*) malloc(sizeof(Celula)); + nova->elemento = elemento; + nova->prox = NULL; + return nova; +} + +//PILHA PROPRIAMENTE DITA ======================================================= +Celula* topo; // Sem celula cabeca. + + +/** + * Cria uma fila sem elementos. + */ +void start () { + topo = NULL; +} + + +/** + * Insere elemento na pilha (politica FILO). + * @param x int elemento a inserir. + */ +void inserir(int x) { + Celula* tmp = novaCelula(x); + tmp->prox = topo; + topo = tmp; + tmp = NULL; +} + +/** + * Remove elemento da pilha (politica FILO). + * @return Elemento removido. + */ +int remover() { + if (topo == NULL) { + errx(1, "Erro ao remover!"); + } + + int resp = topo->elemento; + Celula* tmp = topo; + topo = topo->prox; + tmp->prox = NULL; + free(tmp); + tmp = NULL; + return resp; +} + + +/** + * Mostra os elementos separados por espacos, comecando do topo. + */ +void mostrar() { + Celula* i; + printf("["); + for(i = topo; i != NULL; i = i->prox) { + printf("%d ,", i->elemento); + } + + printf("] \n"); +} + + +//METODO PRINCIPAL ============================================================== +int main(int argc, char** argv){ + int x1, x2, x3; + + printf("==== PILHA FLEXIVEL ====\n"); + + start(); + + inserir(0); + inserir(1); + inserir(2); + inserir(3); + inserir(4); + inserir(5); + + printf("Apos insercoes: \n"); + mostrar(); + + x1 = remover(); + x2 = remover(); + x3 = remover(); + + printf("Apos as remocoes (%d, %d, %d) \n ", x1, x2, x3); + mostrar(); +} diff --git a/fonte/U5 - Estruturas de dados lineares e flexíveis/java/coletalixo/Celula.java b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/coletalixo/Celula.java new file mode 100644 index 0000000..4a92aef --- /dev/null +++ b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/coletalixo/Celula.java @@ -0,0 +1,26 @@ +/** + * Celula (pilha, lista e fila dinamica) + * @author Max do Val Machado + * @version 2 01/2015 + */ +class Celula { + public int elemento; // Elemento inserido na celula. + public Celula prox; // Aponta a celula prox. + + + /** + * Construtor da classe. + */ + public Celula() { + this(0); + } + + /** + * Construtor da classe. + * @param elemento int inserido na celula. + */ + public Celula(int elemento) { + this.elemento = elemento; + this.prox = null; + } +} diff --git a/fonte/U5 - Estruturas de dados lineares e flexíveis/java/coletalixo/ColetaLixo.java b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/coletalixo/ColetaLixo.java new file mode 100644 index 0000000..34ac686 --- /dev/null +++ b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/coletalixo/ColetaLixo.java @@ -0,0 +1,24 @@ + + +class ColetaLixo { + private Celula primeiro; + + public ColetaLixo () { + primeiro = new Celula(); + } + + public void inserir(int x) { + primeiro.prox = new Celula(x); + primeiro = primeiro.prox; + } + + public static void main (String [] args) { + ColetaLixo coletaLixo = new ColetaLixo (); + + while(true){ + coletaLixo.inserir(0); + } + } +} + + diff --git a/fonte/U5 - Estruturas de dados lineares e flexíveis/java/fila/Celula.java b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/fila/Celula.java new file mode 100644 index 0000000..4a92aef --- /dev/null +++ b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/fila/Celula.java @@ -0,0 +1,26 @@ +/** + * Celula (pilha, lista e fila dinamica) + * @author Max do Val Machado + * @version 2 01/2015 + */ +class Celula { + public int elemento; // Elemento inserido na celula. + public Celula prox; // Aponta a celula prox. + + + /** + * Construtor da classe. + */ + public Celula() { + this(0); + } + + /** + * Construtor da classe. + * @param elemento int inserido na celula. + */ + public Celula(int elemento) { + this.elemento = elemento; + this.prox = null; + } +} diff --git a/fonte/U5 - Estruturas de dados lineares e flexíveis/java/fila/Fila.java b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/fila/Fila.java new file mode 100644 index 0000000..b32b83e --- /dev/null +++ b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/fila/Fila.java @@ -0,0 +1,61 @@ +/** + * Fila dinamica + * @author Max do Val Machado + * @version 2 01/2015 + */ +public class Fila { + private Celula primeiro; + private Celula ultimo; + + + /** + * Construtor da classe que cria uma fila sem elementos (somente no cabeca). + */ + public Fila() { + primeiro = new Celula(); + ultimo = primeiro; + } + + + /** + * Insere elemento na fila (politica FIFO). + * @param x int elemento a inserir. + */ + public void inserir(int x) { + ultimo.prox = new Celula(x); + ultimo = ultimo.prox; + } + + + /** + * Remove elemento da fila (politica FIFO). + * @return Elemento removido. + * @trhows Exception Se a fila nao tiver elementos. + */ + public int remover() throws Exception { + if (primeiro == ultimo) { + throw new Exception("Erro ao remover!"); + } + + Celula tmp = primeiro; + primeiro = primeiro.prox; + int resp = primeiro.elemento; + tmp.prox = null; + tmp = null; + return resp; + } + + + /** + * Mostra os elementos separados por espacos. + */ + public void mostrar() { + System.out.print("[ "); + + for(Celula i = primeiro.prox; i != null; i = i.prox) { + System.out.print(i.elemento + " "); + } + + System.out.println("] "); + } +} diff --git a/fonte/U5 - Estruturas de dados lineares e flexíveis/java/fila/PrincipalFila.java b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/fila/PrincipalFila.java new file mode 100644 index 0000000..9b1b3f4 --- /dev/null +++ b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/fila/PrincipalFila.java @@ -0,0 +1,63 @@ +/** + * Fila dinamica + * @author Max do Val Machado + * @version 2 01/2015 + */ +class PrincipalFila { + public static void main(String[] args) throws Exception { + System.out.println("==== FILA DINAMICA ===="); + Fila fila = new Fila(); + int x1, x2, x3; + + fila.inserir(5); + fila.inserir(7); + fila.inserir(8); + fila.inserir(9); + + System.out.println("Apos insercoes(5, 7, 8, 9): "); + fila.mostrar(); + + x1 = fila.remover(); + x2 = fila.remover(); + + System.out.println("Apos remocoes (" + x1 + ", " + x2 + "):"); + fila.mostrar(); + + fila.inserir(3); + fila.inserir(4); + + + System.out.println("Apos insercoes(3, 4): "); + fila.mostrar(); + + x1 = fila.remover(); + x2 = fila.remover(); + x3 = fila.remover(); + + System.out.println("Apos remocoes (" + x1 + ", " + x2 + ", " + x3 + "):"); + fila.mostrar(); + + fila.inserir(4); + fila.inserir(5); + + System.out.println("Apos insercoes(4, 5): "); + fila.mostrar(); + + x1 = fila.remover(); + x2 = fila.remover(); + + System.out.println("Apos remocoes (" + x1 + ", " + x2 + "):"); + fila.mostrar(); + + fila.inserir(6); + fila.inserir(7); + + System.out.println("Apos insercoes(6, 7): "); + fila.mostrar(); + + x1 = fila.remover(); + + System.out.println("Apos remocao (" + x1 + "): "); + fila.mostrar(); + } +} diff --git a/fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/Fila.java b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/Fila.java new file mode 100644 index 0000000..d7009ba --- /dev/null +++ b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/Fila.java @@ -0,0 +1,100 @@ +/** + * Fila estatica + * @author Max do Val Machado + * @version 2 01/2015 + */ +class Fila { + private int[] array; + private int primeiro; // Remove do indice "primeiro". + private int ultimo; // Insere no indice "ultimo". + + + /** + * Construtor da classe. + */ + public Fila () { + this(6); + } + + + /** + * Construtor da classe. + * @param tamanho Tamanho da fila. + */ + public Fila (int tamanho){ + array = new int[tamanho+1]; + primeiro = ultimo = 0; + } + + + /** + * Insere um elemento na ultima posicao da fila. + * @param x int elemento a ser inserido. + * @throws Exception Se a fila estiver cheia. + */ + public void inserir(int x) throws Exception { + + //validar insercao + if (((ultimo + 1) % array.length) == primeiro) { + throw new Exception("Erro ao inserir!"); + } + + array[ultimo] = x; + ultimo = (ultimo + 1) % array.length; + } + + + /** + * Remove um elemento da primeira posicao da fila e movimenta + * os demais elementos para o primeiro da mesma. + * @return resp int elemento a ser removido. + * @throws Exception Se a fila estiver vazia. + */ + public int remover() throws Exception { + + //validar remocao + if (primeiro == ultimo) { + throw new Exception("Erro ao remover!"); + } + + int resp = array[primeiro]; + primeiro = (primeiro + 1) % array.length; + return resp; + } + + + /** + * Mostra os array separados por espacos. + */ + public void mostrar (){ + System.out.print("[ "); + + for(int i = primeiro; i != ultimo; i = ((i + 1) % array.length)) { + System.out.print(array[i] + " "); + } + + System.out.println("]"); + } + + public void mostrarRec(){ + System.out.print("[ "); + mostrarRec(primeiro); + System.out.println("]"); + } + + public void mostrarRec(int i){ + if(i != ultimo){ + System.out.print(array[i] + " "); + mostrarRec((i + 1) % array.length); + } + } + + + /** + * Retorna um boolean indicando se a fila esta vazia + * @return boolean indicando se a fila esta vazia + */ + public boolean isVazia() { + return (primeiro == ultimo); + } +} diff --git a/fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/Fila2Pilha.java b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/Fila2Pilha.java new file mode 100644 index 0000000..035bc9c --- /dev/null +++ b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/Fila2Pilha.java @@ -0,0 +1,56 @@ +/** + * Fila 2 Pilha + * @author Felipe Cunha + * @version 1 1/2017 + */ + + public class Fila2Pilha{ + + private Fila f1, f2; + + public Fila2Pilha(){ + f1 = new Fila(6); + f2 = new Fila(6); + } + + public Fila2Pilha(int tamanho){ + f1 = new Fila (tamanho); + f2 = new Fila (tamanho); + } + + public void empilhar(int elemento) throws Exception { + while(!f1.isVazia()){ + f2.inserir(f1.remover()); + } + + f1.inserir(elemento); + + while(!f2.isVazia()){ + f1.inserir(f2.remover()); + } + } + + public int desempilhar() throws Exception { + return f1.remover(); + } + + public void mostrar(){ + f1.mostrar(); + } + + public boolean isVazia(){ + return f1.isVazia(); + } + + public static void main(String []args) throws Exception{ + Fila2Pilha p1 = new Fila2Pilha(); + + p1.empilhar(10); + p1.empilhar(11); + p1.empilhar(15); + p1.empilhar(20); + + p1.mostrar(); + + } + } diff --git a/fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/Lista.java b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/Lista.java new file mode 100644 index 0000000..60eeb77 --- /dev/null +++ b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/Lista.java @@ -0,0 +1,183 @@ +/** + * Lista estatica + * @author Max do Val Machado + * @version 2 01/2015 + */ +class Lista { + private int[] array; + private int n; + + + /** + * Construtor da classe. + */ + public Lista () { + this(6); + } + + + /** + * Construtor da classe. + * @param tamanho Tamanho da lista. + */ + public Lista (int tamanho){ + array = new int[tamanho]; + n = 0; + } + + + /** + * Insere um elemento na primeira posicao da lista e move os demais + * elementos para o fim da lista. + * @param x int elemento a ser inserido. + * @throws Exception Se a lista estiver cheia. + */ + public void inserirInicio(int x) throws Exception { + + //validar insercao + if(n >= array.length){ + throw new Exception("Erro ao inserir!"); + } + + //levar elementos para o fim do array + for(int i = n; i > 0; i--){ + array[i] = array[i-1]; + } + + array[0] = x; + n++; + } + + + /** + * Insere um elemento na ultima posicao da lista. + * @param x int elemento a ser inserido. + * @throws Exception Se a lista estiver cheia. + */ + public void inserirFim(int x) throws Exception { + + //validar insercao + if(n >= array.length){ + throw new Exception("Erro ao inserir!"); + } + + array[n] = x; + n++; + } + + + /** + * Insere um elemento em uma posicao especifica e move os demais + * elementos para o fim da lista. + * @param x int elemento a ser inserido. + * @param pos Posicao de insercao. + * @throws Exception Se a lista estiver cheia ou a posicao invalida. + */ + public void inserir(int x, int pos) throws Exception { + + //validar insercao + if(n >= array.length || pos < 0 || pos > n){ + throw new Exception("Erro ao inserir!"); + } + + //levar elementos para o fim do array + for(int i = n; i > pos; i--){ + array[i] = array[i-1]; + } + + array[pos] = x; + n++; + } + + + /** + * Remove um elemento da primeira posicao da lista e movimenta + * os demais elementos para o inicio da mesma. + * @return resp int elemento a ser removido. + * @throws Exception Se a lista estiver vazia. + */ + public int removerInicio() throws Exception { + + //validar remocao + if (n == 0) { + throw new Exception("Erro ao remover!"); + } + + int resp = array[0]; + n--; + + for(int i = 0; i < n; i++){ + array[i] = array[i+1]; + } + + return resp; + } + + + /** + * Remove um elemento da ultima posicao da lista. + * @return resp int elemento a ser removido. + * @throws Exception Se a lista estiver vazia. + */ + public int removerFim() throws Exception { + + //validar remocao + if (n == 0) { + throw new Exception("Erro ao remover!"); + } + + return array[--n]; + } + + + /** + * Remove um elemento de uma posicao especifica da lista e + * movimenta os demais elementos para o inicio da mesma. + * @param pos Posicao de remocao. + * @return resp int elemento a ser removido. + * @throws Exception Se a lista estiver vazia ou a posicao for invalida. + */ + public int remover(int pos) throws Exception { + + //validar remocao + if (n == 0 || pos < 0 || pos >= n) { + throw new Exception("Erro ao remover!"); + } + + int resp = array[pos]; + n--; + + for(int i = pos; i < n; i++){ + array[i] = array[i+1]; + } + + return resp; + } + + + /** + * Mostra os elementos da lista separados por espacos. + */ + public void mostrar (){ + System.out.print("[ "); + for(int i = 0; i < n; i++){ + System.out.print(array[i] + " "); + } + System.out.println("]"); + } + + + /** + * Procura um elemento e retorna se ele existe. + * @param x int elemento a ser pesquisado. + * @return true se o array existir, + * false em caso contrario. + */ + public boolean pesquisar(int x) { + boolean retorno = false; + for (int i = 0; i < n && retorno == false; i++) { + retorno = (array[i] == x); + } + return retorno; + } +} diff --git a/fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/ListaOrdenada.java b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/ListaOrdenada.java new file mode 100644 index 0000000..a60186c --- /dev/null +++ b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/ListaOrdenada.java @@ -0,0 +1,156 @@ +/** + * Lista estatica + * @author Max do Val Machado + * @version 2 01/2015 + */ +class ListaOrdenada { + private int[] array; + private int n; + + + /** + * Construtor da classe. + */ + public ListaOrdenada () { + this(6); + } + + + /** + * Construtor da classe. + * @param tamanho Tamanho da lista. + */ + public ListaOrdenada (int tamanho){ + array = new int[tamanho]; + n = 0; + } + + + /** + * Insere um elemento + * @param x int elemento a ser inserido. + * @throws Exception Se a lista estiver cheia ou a posicao invalida. + */ + public void inserir(int x) throws Exception { + + //validar insercao + if(n >= array.length){ + throw new Exception("Erro ao inserir!"); + } + + //procurar a posicao de insercao e movimentando os demais elementos para o fim do array + int pos; + for(pos = n-1; pos >= 0 && array[pos] > x; pos--){ + array[pos+1] = array[pos]; + } + array[pos+1] = x; + n++; + } + + /** + * Retorna verdadeiro/falso indicando se o array esta ordenado + * @return boolean indicando se o array esta ordenado + */ + public boolean isOrdenado(){ + boolean resp = true; + for(int i = 1; i < n; i++){ + if(array[i] < array[i-1]){ + i = n; + resp = false; + } + } + return resp; + } + + + /** + * Remove um elemento da primeira posicao da lista e movimenta + * os demais elementos para o inicio da mesma. + * @return resp int elemento a ser removido. + * @throws Exception Se a lista estiver vazia. + */ + public int removerInicio() throws Exception { + + //validar remocao + if (n == 0) { + throw new Exception("Erro ao remover!"); + } + + int resp = array[0]; + n--; + + for(int i = 0; i < n; i++){ + array[i] = array[i+1]; + } + + return resp; + } + + + /** + * Remove um elemento da ultima posicao da lista. + * @return resp int elemento a ser removido. + * @throws Exception Se a lista estiver vazia. + */ + public int removerFim() throws Exception { + + //validar remocao + if (n == 0) { + throw new Exception("Erro ao remover!"); + } + + return array[--n]; + } + + + /** + * Remove um elemento de uma posicao especifica da lista e + * movimenta os demais elementos para o inicio da mesma. + * @param pos Posicao de remocao. + * @return resp int elemento a ser removido. + * @throws Exception Se a lista estiver vazia ou a posicao for invalida. + */ + public int remover(int pos) throws Exception { + + //validar remocao + if (n == 0 || pos < 0 || pos >= n) { + throw new Exception("Erro ao remover!"); + } + + int resp = array[pos]; + n--; + + for(int i = pos; i < n; i++){ + array[i] = array[i+1]; + } + + return resp; + } + + + /** + * Mostra os elementos da lista separados por espacos. + */ + public void mostrar (){ + System.out.print("[ "); + for(int i = 0; i < n; i++){ + System.out.print(array[i] + " "); + } + System.out.println("]"); + } + + + /** + * Procura um elemento e retorna se ele existe. + * @param x int elemento a ser pesquisado. + * @return true se o array existir, + * false em caso contrario. + */ + public boolean pesquisar(int x) { + boolean retorno = false; + for (int i = 0; i < n && retorno == false; i++) { + retorno = (array[i] == x); + } + return retorno; + } +} diff --git a/fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/PrincipalFila.java b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/PrincipalFila.java new file mode 100644 index 0000000..dad9eea --- /dev/null +++ b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/PrincipalFila.java @@ -0,0 +1,63 @@ +/** + * Fila estatica + * @author Max do Val Machado + * @version 2 01/2015 + */ +class PrincipalFila { + public static void main(String[] args) throws Exception { + System.out.println("==== FILA ESTATICA ===="); + Fila fila = new Fila(); + int x1, x2, x3; + + fila.inserir(5); + fila.inserir(7); + fila.inserir(8); + fila.inserir(9); + + System.out.println("Apos insercoes(5, 7, 8, 9): "); + fila.mostrar(); + + x1 = fila.remover(); + x2 = fila.remover(); + + System.out.println("Apos remocoes (" + x1 + ", " + x2 + "):"); + fila.mostrar(); + + fila.inserir(3); + fila.inserir(4); + + + System.out.println("Apos insercoes(3, 4): "); + fila.mostrar(); + + x1 = fila.remover(); + x2 = fila.remover(); + x3 = fila.remover(); + + System.out.println("Apos remocoes (" + x1 + ", " + x2 + ", " + x3 + "):"); + fila.mostrar(); + + fila.inserir(4); + fila.inserir(5); + + System.out.println("Apos insercoes(4, 5): "); + fila.mostrar(); + + x1 = fila.remover(); + x2 = fila.remover(); + + System.out.println("Apos remocoes (" + x1 + ", " + x2 + "):"); + fila.mostrar(); + + fila.inserir(6); + fila.inserir(7); + + System.out.println("Apos insercoes(6, 7): "); + fila.mostrar(); + + x1 = fila.remover(); + + System.out.println("Apos remocao (" + x1 + "): "); + fila.mostrar(); + } +} diff --git a/fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/PrincipalLista.java b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/PrincipalLista.java new file mode 100644 index 0000000..ed737cb --- /dev/null +++ b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/PrincipalLista.java @@ -0,0 +1,29 @@ +/** + * Lista estatica + * @author Max do Val Machado + * @version 2 01/2015 + */ +class PrincipalLista { + public static void main(String[] args) throws Exception { + System.out.println("==== LISTA ESTATICA ===="); + Lista lista = new Lista(); + int x1, x2, x3; + + lista.inserirInicio(1); + lista.inserirInicio(0); + lista.inserirFim(2); + lista.inserirFim(3); + lista.inserir(4, 3); + lista.inserir(5, 2); + + System.out.print("Apos insercoes: "); + lista.mostrar(); + + x1 = lista.removerInicio(); + x2 = lista.removerFim(); + x3 = lista.remover(2); + + System.out.print("Apos remocoes (" + x1 + ", " + x2 + ", " + x3 + "):"); + lista.mostrar(); + } +} diff --git a/fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/PrincipalListaOrdenada.java b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/PrincipalListaOrdenada.java new file mode 100644 index 0000000..5f8a033 --- /dev/null +++ b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/PrincipalListaOrdenada.java @@ -0,0 +1,21 @@ +import java.util.*; +/** + * Lista estatica + * @author Max do Val Machado + * @version 2 01/2015 + */ +class PrincipalListaOrdenada { + public static void main(String[] args) throws Exception { + Random gerador = new Random(); + System.out.println("==== LISTA ESTATICA ===="); + ListaOrdenada lista = new ListaOrdenada(1000); + + for(int i = 0; i < 1000; i++){ + lista.inserir(Math.abs(gerador.nextInt()) % 1000); + } + + System.out.print("Apos insercoes: "); + lista.mostrar(); + System.out.print("Ordenada: " + lista.isOrdenado()); + } +} diff --git a/fonte/U5 - Estruturas de dados lineares e flexíveis/java/listadupla/CelulaDupla.java b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/listadupla/CelulaDupla.java new file mode 100644 index 0000000..53773d5 --- /dev/null +++ b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/listadupla/CelulaDupla.java @@ -0,0 +1,27 @@ +/** + * Celula Dupla (lista dupla dinamica) + * @author Max do Val Machado + * @version 2 01/2015 + */ +class CelulaDupla { + public int elemento; + public CelulaDupla ant; + public CelulaDupla prox; + + /** + * Construtor da classe. + */ + public CelulaDupla() { + this(0); + } + + + /** + * Construtor da classe. + * @param elemento int inserido na celula. + */ + public CelulaDupla(int elemento) { + this.elemento = elemento; + this.ant = this.prox = null; + } +} diff --git a/fonte/U5 - Estruturas de dados lineares e flexíveis/java/listadupla/ListaDupla.java b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/listadupla/ListaDupla.java new file mode 100644 index 0000000..a01e5e6 --- /dev/null +++ b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/listadupla/ListaDupla.java @@ -0,0 +1,204 @@ +/** + * Lista dupla dinamica + * @author Max do Val Machado + * @version 2 01/2015 + */ +class ListaDupla { + private CelulaDupla primeiro; + private CelulaDupla ultimo; + + + /** + * Construtor da classe que cria uma lista dupla sem elementos (somente no cabeca). + */ + public ListaDupla() { + primeiro = new CelulaDupla(); + ultimo = primeiro; + } + + + /** + * Insere um elemento na primeira posicao da lista. + * @param x int elemento a ser inserido. + */ + public void inserirInicio(int x) { + CelulaDupla tmp = new CelulaDupla(x); + + tmp.ant = primeiro; + tmp.prox = primeiro.prox; + primeiro.prox = tmp; + if(primeiro == ultimo){ + ultimo = tmp; + }else{ + tmp.prox.ant = tmp; + } + tmp = null; + } + + + /** + * Insere um elemento na ultima posicao da lista. + * @param x int elemento a ser inserido. + */ + public void inserirFim(int x) { + ultimo.prox = new CelulaDupla(x); + ultimo.prox.ant = ultimo; + ultimo = ultimo.prox; + } + + + /** + * Remove um elemento da primeira posicao da lista. + * @return resp int elemento a ser removido. + * @throws Exception Se a lista nao contiver elementos. + */ + public int removerInicio() throws Exception { + if (primeiro == ultimo) { + throw new Exception("Erro ao remover (vazia)!"); + } + + CelulaDupla tmp = primeiro; + primeiro = primeiro.prox; + int resp = primeiro.elemento; + tmp.prox = primeiro.ant = null; + tmp = null; + return resp; + } + + + /** + * Remove um elemento da ultima posicao da lista. + * @return resp int elemento a ser removido. + * @throws Exception Se a lista nao contiver elementos. + */ + public int removerFim() throws Exception { + if (primeiro == ultimo) { + throw new Exception("Erro ao remover (vazia)!"); + } + int resp = ultimo.elemento; + ultimo = ultimo.ant; + ultimo.prox.ant = null; + ultimo.prox = null; + return resp; + } + + + /** + * Insere um elemento em uma posicao especifica considerando que o + * primeiro elemento valido esta na posicao 0. + * @param x int elemento a ser inserido. + * @param pos int posicao da insercao. + * @throws Exception Se posicao invalida. + */ + public void inserir(int x, int pos) throws Exception { + + int tamanho = tamanho(); + + if(pos < 0 || pos > tamanho){ + throw new Exception("Erro ao inserir posicao (" + pos + " / tamanho = " + tamanho + ") invalida!"); + } else if (pos == 0){ + inserirInicio(x); + } else if (pos == tamanho){ + inserirFim(x); + } else { + // Caminhar ate a posicao anterior a insercao + CelulaDupla i = primeiro; + for(int j = 0; j < pos; j++, i = i.prox); + + CelulaDupla tmp = new CelulaDupla(x); + tmp.ant = i; + tmp.prox = i.prox; + tmp.ant.prox = tmp.prox.ant = tmp; + tmp = i = null; + } + } + + + /** + * Remove um elemento de uma posicao especifica da lista + * considerando que o primeiro elemento valido esta na posicao 0. + * @param posicao Meio da remocao. + * @return resp int elemento a ser removido. + * @throws Exception Se posicao invalida. + */ + public int remover(int pos) throws Exception { + int resp; + int tamanho = tamanho(); + + if (primeiro == ultimo){ + throw new Exception("Erro ao remover (vazia)!"); + + } else if(pos < 0 || pos >= tamanho){ + throw new Exception("Erro ao remover (posicao " + pos + " / " + tamanho + " invalida!"); + } else if (pos == 0){ + resp = removerInicio(); + } else if (pos == tamanho - 1){ + resp = removerFim(); + } else { + // Caminhar ate a posicao anterior a insercao + CelulaDupla i = primeiro.prox; + for(int j = 0; j < pos; j++, i = i.prox); + + i.ant.prox = i.prox; + i.prox.ant = i.ant; + resp = i.elemento; + i.prox = i.ant = null; + i = null; + } + + return resp; + } + + + /** + * Mostra os elementos da lista separados por espacos. + */ + public void mostrar() { + System.out.print("[ "); // Comeca a mostrar. + for (CelulaDupla i = primeiro.prox; i != null; i = i.prox) { + System.out.print(i.elemento + " "); + } + System.out.println("] "); // Termina de mostrar. + } + + + /** + * Mostra os elementos da lista de forma invertida + * e separados por espacos. + */ + public void mostrarInverso() { + System.out.print("[ "); + for (CelulaDupla i = ultimo; i != primeiro; i = i.ant){ + System.out.print(i.elemento + " "); + } + System.out.println("] "); // Termina de mostrar. + } + + + /** + * Procura um elemento e retorna se ele existe. + * @param x Elemento a pesquisar. + * @return true se o elemento existir, + * false em caso contrario. + */ + public boolean pesquisar(int x) { + boolean resp = false; + for (CelulaDupla i = primeiro.prox; i != null; i = i.prox) { + if(i.elemento == x){ + resp = true; + i = ultimo; + } + } + return resp; + } + + /** + * Calcula e retorna o tamanho, em numero de elementos, da lista. + * @return resp int tamanho + */ + public int tamanho() { + int tamanho = 0; + for(CelulaDupla i = primeiro; i != ultimo; i = i.prox, tamanho++); + return tamanho; + } +} diff --git a/fonte/U5 - Estruturas de dados lineares e flexíveis/java/listadupla/PrincipalListaDupla.java b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/listadupla/PrincipalListaDupla.java new file mode 100644 index 0000000..bfb50fd --- /dev/null +++ b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/listadupla/PrincipalListaDupla.java @@ -0,0 +1,40 @@ +/** + * Lista dupla dinamica + * @author Max do Val Machado + * @version 2 01/2015 + */ +class PrincipalListaDupla { + public static void main(String[] args) { + try { + System.out.println("=== LISTA DINAMICA DUPLAMENTE ENCADEADA ==="); + ListaDupla lista = new ListaDupla(); + + lista.inserirInicio(1); + lista.inserirInicio(0); + lista.inserirFim(4); + lista.inserirFim(5); + lista.inserir(2, 2); + lista.inserir(3, 3); + lista.inserir(6, 6); + lista.inserir(-1, 0); + lista.inserirFim(7); + lista.inserirFim(8); + + System.out.print("Apos insercoes: "); + lista.mostrar(); + + int x1 = lista.remover(3); + int x2 = lista.remover(2); + int x3 = lista.removerFim(); + int x4 = lista.removerInicio(); + int x5 = lista.remover(0); + int x6 = lista.remover(4); + + System.out.print("Apos remocoes (" +x1+ ", " +x2+ ", " +x3+ ", " +x4+ ", " +x5+ ", " +x6+ "): "); + lista.mostrar(); + } + catch(Exception erro) { + System.out.println(erro.getMessage()); + } + } +} diff --git a/fonte/U5 - Estruturas de dados lineares e flexíveis/java/listasimples/Celula.java b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/listasimples/Celula.java new file mode 100644 index 0000000..4a92aef --- /dev/null +++ b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/listasimples/Celula.java @@ -0,0 +1,26 @@ +/** + * Celula (pilha, lista e fila dinamica) + * @author Max do Val Machado + * @version 2 01/2015 + */ +class Celula { + public int elemento; // Elemento inserido na celula. + public Celula prox; // Aponta a celula prox. + + + /** + * Construtor da classe. + */ + public Celula() { + this(0); + } + + /** + * Construtor da classe. + * @param elemento int inserido na celula. + */ + public Celula(int elemento) { + this.elemento = elemento; + this.prox = null; + } +} diff --git a/fonte/U5 - Estruturas de dados lineares e flexíveis/java/listasimples/Lista.java b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/listasimples/Lista.java new file mode 100644 index 0000000..417aa5e --- /dev/null +++ b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/listasimples/Lista.java @@ -0,0 +1,188 @@ +/** + * Lista dinamica + * @author Max do Val Machado + * @version 2 01/2015 + */ +class Lista { + private Celula primeiro; + private Celula ultimo; + + + /** + * Construtor da classe que cria uma lista sem elementos (somente no cabeca). + */ + public Lista() { + primeiro = new Celula(); + ultimo = primeiro; + } + + + /** + * Insere um elemento na primeira posicao da lista. + * @param x int elemento a ser inserido. + */ + public void inserirInicio(int x) { + Celula tmp = new Celula(x); + tmp.prox = primeiro.prox; + primeiro.prox = tmp; + if (primeiro == ultimo) { + ultimo = tmp; + } + tmp = null; + } + + + /** + * Insere um elemento na ultima posicao da lista. + * @param x int elemento a ser inserido. + */ + public void inserirFim(int x) { + ultimo.prox = new Celula(x); + ultimo = ultimo.prox; + } + + + /** + * Remove um elemento da primeira posicao da lista. + * @return resp int elemento a ser removido. + * @throws Exception Se a lista nao contiver elementos. + */ + public int removerInicio() throws Exception { + if (primeiro == ultimo) { + throw new Exception("Erro ao remover (vazia)!"); + } + + Celula tmp = primeiro; + primeiro = primeiro.prox; + int resp = primeiro.elemento; + tmp.prox = null; + tmp = null; + return resp; + } + + + /** + * Remove um elemento da ultima posicao da lista. + * @return resp int elemento a ser removido. + * @throws Exception Se a lista nao contiver elementos. + */ + public int removerFim() throws Exception { + if (primeiro == ultimo) { + throw new Exception("Erro ao remover (vazia)!"); + } + + // Caminhar ate a penultima celula: + Celula i; + for(i = primeiro; i.prox != ultimo; i = i.prox); + + int resp = ultimo.elemento; + ultimo = i; + i = ultimo.prox = null; + + return resp; + } + + + /** + * Insere um elemento em uma posicao especifica considerando que o + * primeiro elemento valido esta na posicao 0. + * @param x int elemento a ser inserido. + * @param pos int posicao da insercao. + * @throws Exception Se posicao invalida. + */ + public void inserir(int x, int pos) throws Exception { + + int tamanho = tamanho(); + + if(pos < 0 || pos > tamanho){ + throw new Exception("Erro ao inserir posicao (" + pos + " / tamanho = " + tamanho + ") invalida!"); + } else if (pos == 0){ + inserirInicio(x); + } else if (pos == tamanho){ + inserirFim(x); + } else { + // Caminhar ate a posicao anterior a insercao + Celula i = primeiro; + for(int j = 0; j < pos; j++, i = i.prox); + + Celula tmp = new Celula(x); + tmp.prox = i.prox; + i.prox = tmp; + tmp = i = null; + } + } + + + /** + * Remove um elemento de uma posicao especifica da lista + * considerando que o primeiro elemento valido esta na posicao 0. + * @param posicao Meio da remocao. + * @return resp int elemento a ser removido. + * @throws Exception Se posicao invalida. + */ + public int remover(int pos) throws Exception { + int resp; + int tamanho = tamanho(); + + if (primeiro == ultimo){ + throw new Exception("Erro ao remover (vazia)!"); + + } else if(pos < 0 || pos >= tamanho){ + throw new Exception("Erro ao remover (posicao " + pos + " / " + tamanho + " invalida!"); + } else if (pos == 0){ + resp = removerInicio(); + } else if (pos == tamanho - 1){ + resp = removerFim(); + } else { + // Caminhar ate a posicao anterior a insercao + Celula i = primeiro; + for(int j = 0; j < pos; j++, i = i.prox); + + Celula tmp = i.prox; + resp = tmp.elemento; + i.prox = tmp.prox; + tmp.prox = null; + i = tmp = null; + } + + return resp; + } + + /** + * Mostra os elementos da lista separados por espacos. + */ + public void mostrar() { + System.out.print("[ "); + for (Celula i = primeiro.prox; i != null; i = i.prox) { + System.out.print(i.elemento + " "); + } + System.out.println("] "); + } + + /** + * Procura um elemento e retorna se ele existe. + * @param x Elemento a pesquisar. + * @return true se o elemento existir, + * false em caso contrario. + */ + public boolean pesquisar(int x) { + boolean resp = false; + for (Celula i = primeiro.prox; i != null; i = i.prox) { + if(i.elemento == x){ + resp = true; + i = ultimo; + } + } + return resp; + } + + /** + * Calcula e retorna o tamanho, em numero de elementos, da lista. + * @return resp int tamanho + */ + public int tamanho() { + int tamanho = 0; + for(Celula i = primeiro; i != ultimo; i = i.prox, tamanho++); + return tamanho; + } +} diff --git a/fonte/U5 - Estruturas de dados lineares e flexíveis/java/listasimples/PrincipalLista.java b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/listasimples/PrincipalLista.java new file mode 100644 index 0000000..39b9ba8 --- /dev/null +++ b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/listasimples/PrincipalLista.java @@ -0,0 +1,41 @@ +/** + * Lista simples dinamica + * @author Max do Val Machado + * @version 2 01/2015 + */ +class PrincipalLista { + public static void main(String[] args) { + try { + System.out.println("=== LISTA DINAMICA SIMPLESMENTE ENCADEADA ==="); + Lista lista = new Lista(); + + lista.inserirInicio(1); + lista.inserirInicio(0); + lista.inserirFim(4); + lista.inserirFim(5); + lista.inserir(2, 2); + lista.inserir(3, 3); + lista.inserir(6, 6); + lista.inserir(-1, 0); + lista.inserirFim(7); + lista.inserirFim(8); + + System.out.print("Apos insercoes: "); + lista.mostrar(); + + int x1 = lista.remover(3); + int x2 = lista.remover(2); + int x3 = lista.removerFim(); + int x4 = lista.removerInicio(); + int x5 = lista.remover(0); + int x6 = lista.remover(4); + lista.inserirFim(9); + + System.out.print("Apos remocoes (" +x1+ ", " +x2+ ", " +x3+ ", " +x4+ ", " +x5+ ", " +x6+ "): "); + lista.mostrar(); + } + catch(Exception erro) { + System.out.println(erro.getMessage()); + } + } +} diff --git a/fonte/U5 - Estruturas de dados lineares e flexíveis/java/matriz/Celula.java b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/matriz/Celula.java new file mode 100644 index 0000000..d22592a --- /dev/null +++ b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/matriz/Celula.java @@ -0,0 +1,20 @@ +class Celula { + private int elemento; + private Celula inf, sup, esq, dir; + + public Celula(){ + this(0, null, null, null, null); + } + + public Celula(int elemento){ + this(elemento, null, null, null, null); + } + + public Celula(int elemento, Celula inf, Celula sup, Celula esq, Celula dir){ + this.elemento = elemento; + this.inf = inf; + this.sup = sup; + this.esq = esq; + this.dir = dir; + } +} diff --git a/fonte/U5 - Estruturas de dados lineares e flexíveis/java/matriz/Matriz.java b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/matriz/Matriz.java new file mode 100644 index 0000000..4b4dded --- /dev/null +++ b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/matriz/Matriz.java @@ -0,0 +1,53 @@ +class Matriz { + private Celula inicio; + private int linha, coluna; + + public Matriz (){ + this.linha = this.coluna = 3; + + //alocar a matriz com this.linha linhas e this.coluna colunas + } + + public Matriz (int linha, int coluna){ + this.linha = linha; + this.coluna = coluna; + + //alocar a matriz com this.linha linhas e this.coluna colunas + } + + public Matriz soma (Matriz m) { + Matriz resp = null; + + if(this.linha == m.linha && this.coluna == m.coluna){ + //... + } + + return resp; + } + + public Matriz multiplicacao (Matriz m) { + Matriz resp = null; + + if(){ + //... + } + + return resp; + } + + public boolean isQuadrada(){ + boolean (this.linha == this.coluna); + } + + public void mostrarDiagonalPrincipal (){ + if(isQuadrada() == true){ + + } + } + + public void mostrarDiagonalSecundaria (){ + if(isQuadrada() == true){ + + } + } +} diff --git a/fonte/U5 - Estruturas de dados lineares e flexíveis/java/matriz/Principal.java b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/matriz/Principal.java new file mode 100644 index 0000000..9dfc596 --- /dev/null +++ b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/matriz/Principal.java @@ -0,0 +1,30 @@ +class Principal { + + public static void main(String[] args){ + Matriz m1, m2, soma, m3, m4, multiplicao; + + m1 = new Matriz(MyIO.readInt("Digite o numero de linhas (M1): "), MyIO.readInt("Digite o numero de colunas (M1): ")); + m2 = new Matriz(MyIO.readInt("Digite o numero de linhas (M2): "), MyIO.readInt("Digite o numero de colunas (M2): ")); + m3 = new Matriz(MyIO.readInt("Digite o numero de linhas (M3): "), MyIO.readInt("Digite o numero de colunas (M3): ")); + m4 = new Matriz(MyIO.readInt("Digite o numero de linhas (M4): "), MyIO.readInt("Digite o numero de colunas (M4): ")); + + + m1.ler(); + m2.ler(); + m3.ler(); + m4.ler(); + + //Somar as duas matrizes e salvar o resultado na matriz soma + soma = m1.soma(m2); //verifique se eh possivel somar + + //Imprimir a matriz 1 + soma.print(); + + //Multiplicar duas matrizes e salvar o resultado na matriz multiplicacao + multiplicacao = m3.multiplicacao(m4); //verifique se eh possivel multiplicar + + //Imprimir a matriz 1 + multiplicacao.print(); + + } +} diff --git a/fonte/U5 - Estruturas de dados lineares e flexíveis/java/matriz/entrada.in b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/matriz/entrada.in new file mode 100644 index 0000000..bf6e3cf --- /dev/null +++ b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/matriz/entrada.in @@ -0,0 +1,37 @@ +quantidade de testes (por exemplo, 3) +linhas da primeira matriz do primeiro teste +colunas da primeira matriz do primeiro teste +x x x x x ... x +x x x x x ... x +... +x x x x x ... x +linhas da segunda matriz do primeiro teste +colunas da segunda matriz do primeiro teste +x x x x x ... x +x x x x x ... x +... +x x x x x ... x +linhas da primeira matriz do segundo teste +colunas da primeira matriz do segundo teste +x x x x x ... x +x x x x x ... x +... +x x x x x ... x +linhas da segunda matriz do segundo teste +colunas da segunda matriz do segundo teste +x x x x x ... x +x x x x x ... x +... +x x x x x ... x +linhas da primeira matriz do terceiro teste +colunas da primeira matriz do terceiro teste +x x x x x ... x +x x x x x ... x +... +x x x x x ... x +linhas da segunda matriz do terceiro teste +colunas da segunda matriz do terceiro teste +x x x x x ... x +x x x x x ... x +... +x x x x x ... x diff --git a/fonte/U5 - Estruturas de dados lineares e flexíveis/java/pilha/Celula.java b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/pilha/Celula.java new file mode 100644 index 0000000..4a92aef --- /dev/null +++ b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/pilha/Celula.java @@ -0,0 +1,26 @@ +/** + * Celula (pilha, lista e fila dinamica) + * @author Max do Val Machado + * @version 2 01/2015 + */ +class Celula { + public int elemento; // Elemento inserido na celula. + public Celula prox; // Aponta a celula prox. + + + /** + * Construtor da classe. + */ + public Celula() { + this(0); + } + + /** + * Construtor da classe. + * @param elemento int inserido na celula. + */ + public Celula(int elemento) { + this.elemento = elemento; + this.prox = null; + } +} diff --git a/fonte/U5 - Estruturas de dados lineares e flexíveis/java/pilha/Pilha.java b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/pilha/Pilha.java new file mode 100644 index 0000000..38cc07a --- /dev/null +++ b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/pilha/Pilha.java @@ -0,0 +1,90 @@ +/** + * Pilha dinamica + * + * @author Max do Val Machado + * @version 2 01/2015 + */ +public class Pilha { + private Celula topo; + + /** + * Construtor da classe que cria uma fila sem elementos. + */ + public Pilha() { + topo = null; + } + + /** + * Insere elemento na pilha (politica FILO). + * + * @param x int elemento a inserir. + */ + public void inserir(int x) { + Celula tmp = new Celula(x); + tmp.prox = topo; + topo = tmp; + tmp = null; + } + + /** + * Remove elemento da pilha (politica FILO). + * + * @return Elemento removido. + * @trhows Exception Se a sequencia nao contiver elementos. + */ + public int remover() throws Exception { + if (topo == null) { + throw new Exception("Erro ao remover!"); + } + int resp = topo.elemento; + Celula tmp = topo; + topo = topo.prox; + tmp.prox = null; + tmp = null; + return resp; + } + + /** + * Mostra os elementos separados por espacos, comecando do topo. + */ + public void mostrar() { + System.out.print("[ "); + for (Celula i = topo; i != null; i = i.prox) { + System.out.print(i.elemento + " "); + } + System.out.println("] "); + } + + public int getSoma() { + return getSoma(topo); + } + + private int getSoma(Celula i) { + int resp = 0; + if (i != null) { + resp += i.elemento + getSoma(i.prox); + } + return resp; + } + + public int getMax() { + int max = topo.elemento; + for (Celula i = topo.prox; i != null; i = i.prox) { + if (i.elemento > max) + max = i.elemento; + } + return max; + } + + public void mostraPilha() { + mostraPilha(topo); + } + + private void mostraPilha(Celula i) { + if (i != null) { + mostraPilha(i.prox); + System.out.println("" + i.elemento); + } + } + +} diff --git a/fonte/U5 - Estruturas de dados lineares e flexíveis/java/pilha/PrincipalPilha.java b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/pilha/PrincipalPilha.java new file mode 100644 index 0000000..7014733 --- /dev/null +++ b/fonte/U5 - Estruturas de dados lineares e flexíveis/java/pilha/PrincipalPilha.java @@ -0,0 +1,35 @@ +/** + * Pilha dinamica + * @author Max do Val Machado + * @version 2 01/2015 + */ +public class PrincipalPilha { + public static void main(String[] args) { + try { + System.out.println(" ==== PILHA DINAMICA ===="); + Pilha pilha = new Pilha(); + int x1, x2, x3; + + pilha.inserir(0); + pilha.inserir(1); + pilha.inserir(2); + pilha.inserir(3); + pilha.inserir(4); + pilha.inserir(5); + + System.out.print("Apos insercoes: "); + pilha.mostrar(); + + x1 = pilha.remover(); + x2 = pilha.remover(); + x3 = pilha.remover(); + + System.out.print("Apos as remocoes (" + x1 + "," + x2 + "," + x3 + "): "); + pilha.mostrar(); + + } + catch(Exception erro) { + System.out.println(erro.getMessage()); + } + } +} diff --git a/fonte/U6 - Árvores binárias/c/arvoreBinariaC/arvorebinaria.c b/fonte/U6 - Árvores binárias/c/arvoreBinariaC/arvorebinaria.c new file mode 100644 index 0000000..da413de --- /dev/null +++ b/fonte/U6 - Árvores binárias/c/arvoreBinariaC/arvorebinaria.c @@ -0,0 +1,201 @@ +/** + * Arvore binaria de pesquisa + * @author Max do Val Machado + */ +#include +#include +#include +#include "arvorebinaria.h" + +/* + * Variavel global + */ +No* raiz; + +/** + * Criar arvore binaria. + */ +void start() { + raiz = NULL; +} + +/** + * Metodo publico iterativo para pesquisar elemento. + * @param x Elemento que sera procurado. + * @return true se o elemento existir, + * false em caso contrario. + */ +bool pesquisar(int x) { + return pesquisarRec(x, raiz); +} + +/** + * Metodo privado recursivo para pesquisar elemento. + * @param x Elemento que sera procurado. + * @param i No em analise. + * @return true se o elemento existir, + * false em caso contrario. + */ +bool pesquisarRec(int x, No* i) { + bool resp; + if (i == NULL) { + resp = false; + + } else if (x == i->elemento) { + resp = true; + + } else if (x < i->elemento) { + resp = pesquisarRec(x, i->esq); + + } else { + resp = pesquisarRec(x, i->dir); + } + return resp; +} + +/** + * Metodo publico iterativo para exibir elementos. + */ +void caminharCentral() { + printf("[ "); + caminharCentralRec(raiz); + printf("]\n"); +} + +/** + * Metodo privado recursivo para exibir elementos. + * @param i No em analise. + */ +void caminharCentralRec(No* i) { + if (i != NULL) { + caminharCentralRec(i->esq); + printf("%d ", i->elemento); + caminharCentralRec(i->dir); + } +} + +/** + * Metodo publico iterativo para exibir elementos. + */ +void caminharPre() { + printf("[ "); + caminharPreRec(raiz); + printf("]\n"); +} + +/** + * Metodo privado recursivo para exibir elementos. + * @param i No em analise. + */ +void caminharPreRec(No* i) { + if (i != NULL) { + printf("%d ", i->elemento); + caminharPreRec(i->esq); + caminharPreRec(i->dir); + } +} + +/** + * Metodo publico iterativo para exibir elementos. + */ +void caminharPos() { + printf("[ "); + caminharPosRec(raiz); + printf("]\n"); +} + +/** + * Metodo privado recursivo para exibir elementos. + * @param i No em analise. + */ +void caminharPosRec(No* i) { + if (i != NULL) { + caminharPosRec(i->esq); + caminharPosRec(i->dir); + printf("%d ", i->elemento); + } +} + +/** + * Metodo publico iterativo para inserir elemento. + * @param x Elemento a ser inserido. + */ +void inserir(int x) { + inserirRec(x, &raiz); +} + +/** + * Metodo privado recursivo para inserir elemento. + * @param x Elemento a ser inserido. + * @param i No** endereco do ponteiro No + */ +void inserirRec(int x, No** i) { + if (*i == NULL) { + *i = novoNo(x); + + } else if (x < (*i)->elemento) { + inserirRec(x, &((*i)->esq)); + + } else if (x > (*i)->elemento) { + inserirRec(x, &((*i)->dir)); + + } else { + errx(1, "Erro ao inserir!"); + } +} + +/** + * Metodo publico iterativo para remover elemento. + * @param x Elemento a ser removido. + */ +void remover(int x) { + removerRec(x, &raiz); +} + +/** + * Metodo privado recursivo para remover elemento. + * @param x Elemento a ser removido. + * @param i No** endereco do ponteiro No + */ +void removerRec(int x, No** i) { + if (*i == NULL) { + errx(1, "Erro ao remover!"); + + } else if (x < (*i)->elemento) { + removerRec(x, &((*i)->esq)); + + } else if (x > (*i)->elemento) { + removerRec(x, &((*i)->dir)); + + } else if ((*i)->dir == NULL) { + No* del = *i; + *i = (*i)->esq; + free(del); + + } else if ((*i)->esq == NULL) { + No* del = *i; + *i = (*i)->dir; + free(del); + + } else { + antecessor(i, &((*i)->esq)); + } +} + +/** + * Metodo para trocar no removido pelo antecessor. + * @param i No** endereco do ponteiro No que contem o elemento removido. + * @param j No** endereco do ponteiro No da subarvore esquerda. + */ +void antecessor(No** i, No** j) { + if ((*j)->dir != NULL) { + antecessor(i, &((*j)->dir)); + + } else { + No* del = *j; + (*i)->elemento = (*j)->elemento; + (*j) = (*j)->esq; + free(del); + } +} + diff --git a/fonte/U6 - Árvores binárias/c/arvoreBinariaC/arvorebinaria.h b/fonte/U6 - Árvores binárias/c/arvoreBinariaC/arvorebinaria.h new file mode 100644 index 0000000..f00b1ae --- /dev/null +++ b/fonte/U6 - Árvores binárias/c/arvoreBinariaC/arvorebinaria.h @@ -0,0 +1,25 @@ +/** + * Arvore binaria de pesquisa + * @author Max do Val Machado + */ + +#include "no.h" +#define bool short +#define true 1 +#define false 0 + +bool pesquisarRec(int, No*); +void caminharCentralRec(No*); +void caminharPreRec(No*); +void caminharPosRec(No*); +void inserirRec(int, No**); +void removerRec(int, No**); +void antecessor(No**, No**); + +void start(); +bool pesquisar(int); +void caminharCentral(); +void caminharPre(); +void caminharPos(); +void inserir(int); +void remover(int); diff --git a/fonte/U6 - Árvores binárias/c/arvoreBinariaC/makefile b/fonte/U6 - Árvores binárias/c/arvoreBinariaC/makefile new file mode 100644 index 0000000..fe17cf2 --- /dev/null +++ b/fonte/U6 - Árvores binárias/c/arvoreBinariaC/makefile @@ -0,0 +1,19 @@ +all: exec + +exec: principal.o arvorebinaria.o no.o + gcc -o exec principal.o arvorebinaria.o no.o + +principal.o: principal.c + gcc -o principal.o principal.c -c -W -Wall -ansi -pedantic + +arvorebinaria.o: arvorebinaria.c + gcc -o arvorebinaria.o arvorebinaria.c -c -W -Wall -ansi -pedantic + +no.o: no.c + gcc -o no.o no.c -c -W -Wall -ansi -pedantic + +clean: + rm -rf *.o *~ exec + +limpa: + rm -rf *.o diff --git a/fonte/U6 - Árvores binárias/c/arvoreBinariaC/no.c b/fonte/U6 - Árvores binárias/c/arvoreBinariaC/no.c new file mode 100644 index 0000000..40b286c --- /dev/null +++ b/fonte/U6 - Árvores binárias/c/arvoreBinariaC/no.c @@ -0,0 +1,18 @@ +/** + * No da arvore binaria + * @author Max do Val Machado + */ +#include +#include "no.h" + +/** + * Criacao do novo no + * @param elemento Conteudo do no. + */ +No* novoNo(int elemento) { + No* novo = (No*) malloc(sizeof(No)); + novo->elemento = elemento; + novo->esq = NULL; + novo->dir = NULL; + return novo; +} diff --git a/fonte/U6 - Árvores binárias/c/arvoreBinariaC/no.h b/fonte/U6 - Árvores binárias/c/arvoreBinariaC/no.h new file mode 100644 index 0000000..8f30c06 --- /dev/null +++ b/fonte/U6 - Árvores binárias/c/arvoreBinariaC/no.h @@ -0,0 +1,15 @@ +/** + * No da arvore binaria + * @author Max do Val Machado + */ + +typedef struct No { + int elemento; + struct No *esq, *dir; +} No; + +/** + * Criacao do novo no + * @param elemento Conteudo do no. + */ +No* novoNo(int elemento); diff --git a/fonte/U6 - Árvores binárias/c/arvoreBinariaC/no.o b/fonte/U6 - Árvores binárias/c/arvoreBinariaC/no.o new file mode 100644 index 0000000000000000000000000000000000000000..fe1bf71522f46a5b28f130345f46e87bd06c3f0e GIT binary patch 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%_4my-0D#@wTfcEqb zXxmk7VScXs7Juk0;-nMKDyYc_vgvSs3JyUiy7+k#u7}_>TN`VuEoYKcUoGS%~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$nzpWUo_` +#include + +int main(){ + + start(); + + inserir(3); + inserir(5); + inserir(1); + inserir(8); + inserir(2); + inserir(4); + inserir(7); + inserir(6); + + printf("\nInserir: 3, 5, 1, 8, 2, 4, 7 e 6"); + printf("\nCaminhar: central, pre e pos\n"); + caminharCentral(); + caminharPre(); + caminharPos(); + + printf("\nRemover: 2"); + printf("\nCaminhar: central, pre e pos\n"); + remover(2); + + caminharCentral(); + caminharPre(); + caminharPos(); + + printf("\nVoltando com a árvore inicial"); + printf("\nRemover: 1"); + printf("\nCaminhar: central, pre e pos\n"); + inserir(2); + remover(1); + + caminharCentral(); + caminharPre(); + caminharPos(); + + printf("\nVoltando com a árvore inicial"); + printf("\nRemover: 3"); + printf("\nCaminhar: central, pre e pos\n"); + remover(2); + inserir(1); + inserir(2); + remover(3); + + caminharCentral(); + caminharPre(); + caminharPos(); + + + return 1; +} diff --git a/fonte/U6 - Árvores binárias/c/arvoreBinariaCC/arvorebinaria.cc b/fonte/U6 - Árvores binárias/c/arvoreBinariaCC/arvorebinaria.cc new file mode 100644 index 0000000..ce0f31c --- /dev/null +++ b/fonte/U6 - Árvores binárias/c/arvoreBinariaCC/arvorebinaria.cc @@ -0,0 +1,200 @@ +/** + * Arvore binaria de pesquisa + * @author Max do Val Machado + */ + +#include +#include "arvorebinaria.h" + +/** + * Construtor da classe. + */ +ArvoreBinaria::ArvoreBinaria() { + raiz = NULL; +} + +/** + * Metodo publico iterativo para pesquisar elemento. + * @param x Elemento que sera procurado. + * @return true se o elemento existir, + * false em caso contrario. + */ +bool ArvoreBinaria::pesquisar(int x) { + return pesquisar(x, raiz); +} + +/** + * Metodo privado recursivo para pesquisar elemento. + * @param x Elemento que sera procurado. + * @param i No em analise. + * @return true se o elemento existir, + * false em caso contrario. + */ +bool ArvoreBinaria::pesquisar(int x, No* i) { + bool resp; + if (i == NULL) { + resp = false; + + } else if (x == i->elemento) { + resp = true; + + } else if (x < i->elemento) { + resp = pesquisar(x, i->esq); + + } else { + resp = pesquisar(x, i->dir); + } + return resp; +} + +/** + * Metodo publico iterativo para exibir elementos. + */ +void ArvoreBinaria::caminharCentral() { + cout << "[ "; + caminharCentral(raiz); + cout << "]\n"; +} + +/** + * Metodo privado recursivo para exibir elementos. + * @param i No em analise. + */ +void ArvoreBinaria::caminharCentral(No* i) { + if (i != NULL) { + caminharCentral(i->esq); // Elementos da esquerda. + cout << i->elemento << " "; // Conteudo do no. + caminharCentral(i->dir); // Elementos da direita. + } +} + +/** + * Metodo publico iterativo para exibir elementos. + */ +void ArvoreBinaria::caminharPre() { + cout << "[ "; + caminharPre(raiz); + cout << "]\n"; +} + +/** + * Metodo privado recursivo para exibir elementos. + * @param i No em analise. + */ +void ArvoreBinaria::caminharPre(No* i) { + if (i != NULL) { + cout << i->elemento << " "; // Conteudo do no. + caminharPre(i->esq); // Elementos da esquerda. + caminharPre(i->dir); // Elementos da direita. + } +} + +/** + * Metodo publico iterativo para exibir elementos. + */ +void ArvoreBinaria::caminharPos() { + cout << "[ "; + caminharPos(raiz); + cout << "]\n"; +} + +/** + * Metodo privado recursivo para exibir elementos. + * @param i No em analise. + */ +void ArvoreBinaria::caminharPos(No* i) { + if (i != NULL) { + caminharPos(i->esq); // Elementos da esquerda. + caminharPos(i->dir); // Elementos da direita. + cout << i->elemento << " "; // Conteudo do no. + } +} + +/** + * Metodo publico iterativo para inserir elemento. + * @param x Elemento a ser inserido. + */ +void ArvoreBinaria::inserir(int x) { + inserir(x, raiz); +} + +/** + * Metodo privado recursivo para inserir elemento. + * @param x Elemento a ser inserido. + * @param i No em analise. + */ +void ArvoreBinaria::inserir(int x, No* &i) { + if (i == NULL) { + i = new No(x); + + } else if (x < i->elemento) { + inserir(x, i->esq); + + } else if (x > i->elemento) { + inserir(x, i->dir); + + } else { + errx(1, "Erro ao inserir!"); + } +} + + /** + * Metodo publico iterativo para remover elemento. + * @param x Elemento a ser removido. + */ +void ArvoreBinaria::remover(int x) { + remover(x, raiz); +} + +/** + * Metodo privado recursivo para remover elemento. + * @param x Elemento a ser removido. + * @param i No em analise. + */ +void ArvoreBinaria::remover(int x, No* &i) { + if (i == NULL) { + errx(1, "Erro ao remover!"); + + } else if (x < i->elemento) { + remover(x, i->esq); + + } else if (x > i->elemento) { + remover(x, i->dir); + + // Sem no a direita. + } else if (i->dir == NULL) { + No* del = i; + i = i->esq; + delete del; + + // Sem no a esquerda. + } else if (i->esq == NULL) { + No* del = i; + i = i->dir; + delete del; + + // No a esquerda e no a direita. + } else { + antecessor(i, i->esq); + } +} + + +/** + * Metodo para trocar no removido pelo antecessor. + * @param i No que teve o elemento removido. + * @param j No da subarvore esquerda. + */ +void ArvoreBinaria::antecessor(No* i, No* &j) { + // Existe no a direita. + if (j->dir != NULL) { + antecessor(i, j->dir); // Caminha para direita. + + // Encontrou o maximo da subarvore esquerda. + } else { + No* del = j; + i->elemento = j->elemento; // Substitui i por j. + j = j->esq; // Substitui j por j.ESQ. + delete del; + } +} diff --git a/fonte/U6 - Árvores binárias/c/arvoreBinariaCC/arvorebinaria.h b/fonte/U6 - Árvores binárias/c/arvoreBinariaCC/arvorebinaria.h new file mode 100644 index 0000000..3a1ac44 --- /dev/null +++ b/fonte/U6 - Árvores binárias/c/arvoreBinariaCC/arvorebinaria.h @@ -0,0 +1,27 @@ +/** + * Arvore binaria de pesquisa + * @author Max do Val Machado + */ + +#include "no.h" + +class ArvoreBinaria { + private: + No* raiz; // Raiz da arvore. + bool pesquisar(int, No*); + void caminharCentral(No*); + void caminharPre(No*); + void caminharPos(No*); + void inserir(int, No* &); + void remover(int, No* &); + void antecessor(No*, No* &); + + public: + ArvoreBinaria(); + bool pesquisar(int); + void caminharCentral(); + void caminharPre(); + void caminharPos(); + void inserir(int); + void remover(int); +}; diff --git a/fonte/U6 - Árvores binárias/c/arvoreBinariaCC/makefile b/fonte/U6 - Árvores binárias/c/arvoreBinariaCC/makefile new file mode 100644 index 0000000..cc9a0b4 --- /dev/null +++ b/fonte/U6 - Árvores binárias/c/arvoreBinariaCC/makefile @@ -0,0 +1,16 @@ +all: exec + +exec: principal.o arvorebinaria.o no.o + g++ -o exec principal.o arvorebinaria.o no.o + +principal.o: principal.cc arvorebinaria.h no.h + g++ -o principal.o principal.cc -c -W -Wall -ansi -pedantic + +arvorebinaria.o: arvorebinaria.cc arvorebinaria.h no.h + g++ -o arvorebinaria.o arvorebinaria.cc -c -W -Wall -ansi -pedantic + +no.o: no.cc no.h + g++ -o no.o no.cc -c -W -Wall -ansi -pedantic + +clean: + rm -rf *.o *~ exec diff --git a/fonte/U6 - Árvores binárias/c/arvoreBinariaCC/no.cc b/fonte/U6 - Árvores binárias/c/arvoreBinariaCC/no.cc new file mode 100644 index 0000000..c74a118 --- /dev/null +++ b/fonte/U6 - Árvores binárias/c/arvoreBinariaCC/no.cc @@ -0,0 +1,16 @@ +/** + * No da arvore binaria + * @author Max do Val Machado + */ + +#include "no.h" + +/** + * Construtor da classe. + * @param elemento Conteudo do no. + */ +No::No(int elemento) { + this->elemento = elemento; + this->esq = NULL; + this->dir = NULL; +} diff --git a/fonte/U6 - Árvores binárias/c/arvoreBinariaCC/no.h b/fonte/U6 - Árvores binárias/c/arvoreBinariaCC/no.h new file mode 100644 index 0000000..ed8b13e --- /dev/null +++ b/fonte/U6 - Árvores binárias/c/arvoreBinariaCC/no.h @@ -0,0 +1,14 @@ +/** + * No da arvore binaria + * @author Max do Val Machado + */ +#include + +using namespace std; + +class No { + public: + int elemento; // Conteudo do no. + No *esq, *dir; // Filhos da esq e dir. + No(int); +}; diff --git a/fonte/U6 - Árvores binárias/c/arvoreBinariaCC/principal.cc b/fonte/U6 - Árvores binárias/c/arvoreBinariaCC/principal.cc new file mode 100644 index 0000000..48db146 --- /dev/null +++ b/fonte/U6 - Árvores binárias/c/arvoreBinariaCC/principal.cc @@ -0,0 +1,60 @@ +/** + * Principal para Arvore Binaria de Pesquisa + * @author Max do Val Machado + */ +#include "arvorebinaria.h" +#include +using namespace std; + +int main(){//int argc, char** argv){ + ArvoreBinaria* arvoreBinaria = new ArvoreBinaria(); + + arvoreBinaria->inserir(3); + arvoreBinaria->inserir(5); + arvoreBinaria->inserir(1); + arvoreBinaria->inserir(8); + arvoreBinaria->inserir(2); + arvoreBinaria->inserir(4); + arvoreBinaria->inserir(7); + arvoreBinaria->inserir(6); + + cout << "\nInserir: 3, 5, 1, 8, 2, 4, 7 e 6"; + cout << "\nCaminhar: central, pre e pos\n"; + arvoreBinaria->caminharCentral(); + arvoreBinaria->caminharPre(); + arvoreBinaria->caminharPos(); + + + cout << "\nRemover: 2"; + cout << "\nCaminhar: central, pre e pos\n"; + arvoreBinaria->remover(2); + + arvoreBinaria->caminharCentral(); + arvoreBinaria->caminharPre(); + arvoreBinaria->caminharPos(); + + cout << "\nVoltando com a árvore inicial"; + cout << "\nRemover: 1"; + cout << "\nCaminhar: central, pre e pos\n"; + arvoreBinaria->inserir(2); + arvoreBinaria->remover(1); + + arvoreBinaria->caminharCentral(); + arvoreBinaria->caminharPre(); + arvoreBinaria->caminharPos(); + + cout << "\nVoltando com a árvore inicial"; + cout << "\nRemover: 3"; + cout << "\nCaminhar: central, pre e pos\n"; + arvoreBinaria->remover(2); + arvoreBinaria->inserir(1); + arvoreBinaria->inserir(2); + arvoreBinaria->remover(3); + + arvoreBinaria->caminharCentral(); + arvoreBinaria->caminharPre(); + arvoreBinaria->caminharPos(); + + + return 1; +} diff --git a/fonte/U6 - Árvores binárias/java/arvoreArvore/ArvoreArvore.java b/fonte/U6 - Árvores binárias/java/arvoreArvore/ArvoreArvore.java new file mode 100644 index 0000000..ed6d92e --- /dev/null +++ b/fonte/U6 - Árvores binárias/java/arvoreArvore/ArvoreArvore.java @@ -0,0 +1,67 @@ +/** + * Arvore de arvore + * @author Max do Val Machado + */ +public class ArvoreArvore { + private No raiz; // Raiz da arvore. + + /** + * Construtor da classe. + */ + public ArvoreArvore() { + raiz = null; + inserir('M'); + inserir('T'); + inserir('F'); + //os outros 23 caracteres. + } + + /** + * Metodo publico iterativo para pesquisar elemento. + * @param elemento Elemento que sera procurado. + * @return true se o elemento existir, + * false em caso contrario. + */ + public boolean pesquisar(String elemento) { + return pesquisar(raiz, elemento); + } + + private boolean pesquisar(No no, String x) { + boolean resp; + if (no == null) { + resp = false; + + } else if (x.charAt(0) == no.elemento) { + resp = pesquisarSegundaArvore(no.outro, x); + + } else if (x.charAt(0) < no.elemento) { + resp = pesquisar(no.esq, x); + + } else { + resp = pesquisar(no.dir, x); + } + return resp; + } + + private boolean pesquisarSegundaArvore(No2 no, String x) { + boolean resp; + if (no == null) { + resp = false; + + } else if (x.equals(no.elemento)) { + resp = true; + + } else if (x.compareTo(no.elemento) < 0) { + resp = pesquisarSegundaArvore(no.esq, x); + + } else { + resp = pesquisarSegundaArvore(no.dir, x); + } + return resp; + } + + private void inserir(char c){ + System.out.println(c); + //implementar + } +} diff --git a/fonte/U6 - Árvores binárias/java/arvoreArvore/No.java b/fonte/U6 - Árvores binárias/java/arvoreArvore/No.java new file mode 100644 index 0000000..6e51f11 --- /dev/null +++ b/fonte/U6 - Árvores binárias/java/arvoreArvore/No.java @@ -0,0 +1,35 @@ +class No { + public char elemento; // Conteudo do no. + public No esq; // No da esquerda. + public No dir; // No da direita. + public No2 outro; + + /** + * Construtor da classe. + * @param elemento Conteudo do no. + */ + No(char elemento) { + this.elemento = elemento; + this.esq = this.dir = null; + this.outro = null; + } + + /** + * Construtor da classe. + * @param elemento Conteudo do no. + * @param esq No da esquerda. + * @param dir No da direita. + */ + No(char elemento, No esq, No dir) { + this.elemento = elemento; + this.esq = esq; + this.dir = dir; + this.outro = null; + } +} + + + + + + diff --git a/fonte/U6 - Árvores binárias/java/arvoreArvore/No2.java b/fonte/U6 - Árvores binárias/java/arvoreArvore/No2.java new file mode 100644 index 0000000..a42206e --- /dev/null +++ b/fonte/U6 - Árvores binárias/java/arvoreArvore/No2.java @@ -0,0 +1,26 @@ +class No2 { + public String elemento; // Conteudo do no. + public No2 esq; // No da esquerda. + public No2 dir; // No da direita. + + /** + * Construtor da classe. + * @param elemento Conteudo do no. + */ + No2(String elemento) { + this.elemento = elemento; + this.esq = this.dir = null; + } + + /** + * Construtor da classe. + * @param elemento Conteudo do no. + * @param esq No2 da esquerda. + * @param dir No2 da direita. + */ + No2(String elemento, No2 esq, No2 dir) { + this.elemento = elemento; + this.esq = esq; + this.dir = dir; + } +} diff --git a/fonte/U6 - Árvores binárias/java/arvoreBinariaDeLista/Agenda.java b/fonte/U6 - Árvores binárias/java/arvoreBinariaDeLista/Agenda.java new file mode 100644 index 0000000..0faff51 --- /dev/null +++ b/fonte/U6 - Árvores binárias/java/arvoreBinariaDeLista/Agenda.java @@ -0,0 +1,98 @@ +public class Agenda { + private No raiz; + + public Agenda() { + /*raiz = new No ('M'); + raiz.esq = new No ('F'); + raiz.dir = new No ('T'); + raiz.esq.esq = new No ('C');*/ + raiz = null; + //inserir todas as 26 letras do alfabeto... + } + + public boolean pesquisarNome(String nome) { + return pesquisarNome(raiz, nome); + } + + private boolean pesquisarNome(No no, String nome) { + boolean resp; + if (no == null) { + resp = false; + } else if (Char.toUpper(nome.charAt(0)) == no.letra) { + resp = false; + for(Celula i = no.primeiro.prox; (!resp && i != null); i = i.prox){ + if(i.contato.nome.equals(nome) == true){ + resp = true; + } + } + } else if (Char.toUpper(nome.charAt(0)) < no.letra) { + resp = pesquisarNome(no.esq, nome); + + } else { + resp = pesquisarNome(no.dir, nome); + } + return resp; + } + + public void inserir(Contato contato) throws Exception { + if(Character.isLetter(contato.nome.charAt(0))){ + raiz = inserir(raiz, contato); + } else { + throw new Exception("Erro ao inserir!"); + } + } + + private No inserir(No no, Contato contato) throws Exception { + // insere o nó com a letra + if (no == null) { + no = new no(Character.toUpperCase(contato.nome.charAt(0))); + no.primeiro = no.ultimo = new Celula(); + no.ultimo.prox = new Celula(contato); + no.ultimo = no.ultimo.prox; + + // insere o contatinho + } else if (Character.toUpperCase(contato.nome.charAt(0)) == no.letra) { + no.ultimo.prox = new Celula(contato); + no.ultimo = no.ultimo.prox; + + // letra menor, caminha para a esquerda + } else if (Character.toUpperCase(contato.nome.charAt(0)) < no.letra) { + no.esq = inserir(no.esq, contato); + + // letra maior, caminha para a direita + } else { + no.dir = inserir(no.dir, contato); + } + return no; + } + + public boolean pesquisar(int cpf) { + return pesquisar(raiz, cpf); + } + + private boolean pesquisar(No i, int cpf) { + boolean resp = false; + if (i != null) { + resp = pesquisar(i.primeiro.prox, cpf); + if(resp == false){ + resp = pesquisar(i.esq, cpf); + if(resp == false){ + resp = pesquisar(i.dir, cpf); + } + } + } + return resp; + } + + private boolean pesquisar(Celula i, int cpf){ + //efeuar a pesquisa na lista a partir do i + } + +} + + + + + + + diff --git a/fonte/U6 - Árvores binárias/java/arvoreBinariaDeLista/Celula.java b/fonte/U6 - Árvores binárias/java/arvoreBinariaDeLista/Celula.java new file mode 100644 index 0000000..d06e246 --- /dev/null +++ b/fonte/U6 - Árvores binárias/java/arvoreBinariaDeLista/Celula.java @@ -0,0 +1,18 @@ +class Celula { + Contato contato; + Celula prox; + + public Celula (){ + this.contato = null; + this.prox = null; + } + + public Celula (Contato contato, Celula prox){ + this.contato = contato; + this.prox = prox; + } + + public Celula(Contato contato){ + this(contato, null); + } +} diff --git a/fonte/U6 - Árvores binárias/java/arvoreBinariaDeLista/Contato.java b/fonte/U6 - Árvores binárias/java/arvoreBinariaDeLista/Contato.java new file mode 100644 index 0000000..b966d1e --- /dev/null +++ b/fonte/U6 - Árvores binárias/java/arvoreBinariaDeLista/Contato.java @@ -0,0 +1,6 @@ +class Contato { + public String nome; + public String telefone; + public String email; + public int cpf; +} diff --git a/fonte/U6 - Árvores binárias/java/arvoreBinariaDeLista/No.java b/fonte/U6 - Árvores binárias/java/arvoreBinariaDeLista/No.java new file mode 100644 index 0000000..1a883e2 --- /dev/null +++ b/fonte/U6 - Árvores binárias/java/arvoreBinariaDeLista/No.java @@ -0,0 +1,12 @@ + +class No { + public Celula primeiro, ultimo; + public No esq, dir; + public char letra; + + No(char letra) { + this.letra = letra; + this.esq = this.dir = null; + primeiro = ultimo = new Celula(); + } +} diff --git a/fonte/U6 - Árvores binárias/java/arvoreBinariaJava/ArvoreBinaria.java b/fonte/U6 - Árvores binárias/java/arvoreBinariaJava/ArvoreBinaria.java new file mode 100644 index 0000000..9b025eb --- /dev/null +++ b/fonte/U6 - Árvores binárias/java/arvoreBinariaJava/ArvoreBinaria.java @@ -0,0 +1,350 @@ +/** + * Arvore binaria de pesquisa + * @author Max do Val Machado + */ +public class ArvoreBinaria { + private No raiz; // Raiz da arvore. + + /** + * Construtor da classe. + */ + public ArvoreBinaria() { + raiz = null; + } + + /** + * Metodo publico iterativo para pesquisar elemento. + * @param x Elemento que sera procurado. + * @return true se o elemento existir, + * false em caso contrario. + */ + public boolean pesquisar(int x) { + return pesquisar(x, raiz); + } + + /** + * Metodo privado recursivo para pesquisar elemento. + * @param x Elemento que sera procurado. + * @param i No em analise. + * @return true se o elemento existir, + * false em caso contrario. + */ + private boolean pesquisar(int x, No i) { + boolean resp; + if (i == null) { + resp = false; + + } else if (x == i.elemento) { + resp = true; + + } else if (x < i.elemento) { + resp = pesquisar(x, i.esq); + + } else { + resp = pesquisar(x, i.dir); + } + return resp; + } + + /** + * Metodo publico iterativo para exibir elementos. + */ + public void caminharCentral() { + System.out.print("[ "); + caminharCentral(raiz); + System.out.println("]"); + } + + /** + * Metodo privado recursivo para exibir elementos. + * @param i No em analise. + */ + private void caminharCentral(No i) { + if (i != null) { + caminharCentral(i.esq); // Elementos da esquerda. + System.out.print(i.elemento + " "); // Conteudo do no. + caminharCentral(i.dir); // Elementos da direita. + } + } + + /** + * Metodo publico iterativo para exibir elementos. + */ + public void caminharPre() { + System.out.print("[ "); + caminharPre(raiz); + System.out.println("]"); + } + + /** + * Metodo privado recursivo para exibir elementos. + * @param i No em analise. + */ + private void caminharPre(No i) { + if (i != null) { + System.out.print(i.elemento + " "); // Conteudo do no. + caminharPre(i.esq); // Elementos da esquerda. + caminharPre(i.dir); // Elementos da direita. + } + } + + /** + * Metodo publico iterativo para exibir elementos. + */ + public void caminharPos() { + System.out.print("[ "); + caminharPos(raiz); + System.out.println("]"); + } + + /** + * Metodo privado recursivo para exibir elementos. + * @param i No em analise. + */ + private void caminharPos(No i) { + if (i != null) { + caminharPos(i.esq); // Elementos da esquerda. + caminharPos(i.dir); // Elementos da direita. + System.out.print(i.elemento + " "); // Conteudo do no. + } + } + + + /** + * Metodo publico iterativo para inserir elemento. + * @param x Elemento a ser inserido. + * @throws Exception Se o elemento existir. + */ + public void inserir(int x) throws Exception { + raiz = inserir(x, raiz); + } + + /** + * Metodo privado recursivo para inserir elemento. + * @param x Elemento a ser inserido. + * @param i No em analise. + * @return No em analise, alterado ou nao. + * @throws Exception Se o elemento existir. + */ + private No inserir(int x, No i) throws Exception { + if (i == null) { + i = new No(x); + + } else if (x < i.elemento) { + i.esq = inserir(x, i.esq); + + } else if (x > i.elemento) { + i.dir = inserir(x, i.dir); + + } else { + throw new Exception("Erro ao inserir!"); + } + + return i; + } + + /** + * Metodo publico para inserir elemento. + * @param x Elemento a ser inserido. + * @throws Exception Se o elemento existir. + */ + public void inserirPai(int x) throws Exception { + if(raiz == null){ + raiz = new No(x); + } else if(x < raiz.elemento){ + inserirPai(x, raiz.esq, raiz); + } else if(x > raiz.elemento){ + inserirPai(x, raiz.dir, raiz); + } else { + throw new Exception("Erro ao inserirPai!"); + } + } + + /** + * Metodo privado recursivo para inserirPai elemento. + * @param x Elemento a ser inserido. + * @param i No em analise. + * @param pai No superior ao em analise. + * @throws Exception Se o elemento existir. + */ + private void inserirPai(int x, No i, No pai) throws Exception { + if (i == null) { + if(x < i.elemento){ + pai.esq = new No(x); + } else { + pai.dir = new No(x); + } + } else if (x < i.elemento) { + inserirPai(x, i.esq, i); + } else if (x > i.elemento) { + inserirPai(x, i.dir, i); + } else { + throw new Exception("Erro ao inserirPai!"); + } + } + + + /** + * Metodo publico iterativo para remover elemento. + * @param x Elemento a ser removido. + * @throws Exception Se nao encontrar elemento. + */ + public void remover(int x) throws Exception { + raiz = remover(x, raiz); + } + + /** + * Metodo privado recursivo para remover elemento. + * @param x Elemento a ser removido. + * @param i No em analise. + * @return No em analise, alterado ou nao. + * @throws Exception Se nao encontrar elemento. + */ + private No remover(int x, No i) throws Exception { + + if (i == null) { + throw new Exception("Erro ao remover!"); + + } else if (x < i.elemento) { + i.esq = remover(x, i.esq); + + } else if (x > i.elemento) { + i.dir = remover(x, i.dir); + + // Sem no a direita. + } else if (i.dir == null) { + i = i.esq; + + // Sem no a esquerda. + } else if (i.esq == null) { + i = i.dir; + + // No a esquerda e no a direita. + } else { + i.esq = antecessor(i, i.esq); + } + + return i; + } + + /** + * Metodo para trocar no removido pelo antecessor. + * @param i No que teve o elemento removido. + * @param j No da subarvore esquerda. + * @return No em analise, alterado ou nao. + */ + private No antecessor(No i, No j) { + + // Existe no a direita. + if (j.dir != null) { + // Caminha para direita. + j.dir = antecessor(i, j.dir); + + // Encontrou o maximo da subarvore esquerda. + } else { + i.elemento = j.elemento; // Substitui i por j. + j = j.esq; // Substitui j por j.ESQ. + } + return j; + } + + /** + * Metodo publico iterativo para remover elemento. + * @param x Elemento a ser removido. + * @throws Exception Se nao encontrar elemento. + */ + public void remover2(int x) throws Exception { + if (raiz == null) { + throw new Exception("Erro ao remover2!"); + } else if(x < raiz.elemento){ + remover2(x, raiz.esq, raiz); + } else if (x > raiz.elemento){ + remover2(x, raiz.dir, raiz); + } else if (raiz.dir == null) { + raiz = raiz.esq; + } else if (raiz.esq == null) { + raiz = raiz.dir; + } else { + raiz.esq = antecessor(raiz, raiz.esq); + } + } + + /** + * Metodo privado recursivo para remover elemento. + * @param x Elemento a ser removido. + * @param i No em analise. + * @param pai do No em analise. + * @throws Exception Se nao encontrar elemento. + */ + private void remover2(int x, No i, No pai) throws Exception { + if (i == null) { + throw new Exception("Erro ao remover2!"); + } else if (x < i.elemento) { + remover2(x, i.esq, i); + } else if (x > i.elemento) { + remover2(x, i.dir, i); + } else if (i.dir == null) { + pai = i.esq; + } else if (i.esq == null) { + pai = i.dir; + } else { + i.esq = antecessor(i, i.esq); + } + } + + public int getRaiz() throws Exception { + return raiz.elemento; + } + + public static boolean igual (ArvoreBinaria a1, ArvoreBinaria a2){ + return igual(a1.raiz, a2.raiz); + } + + private static boolean igual (No i1, No i2){ + boolean resp; + if(i1 != null && i2 != null){ + resp = (i1.elemento == i2.elemento) && igual(i1.esq, i2.esq) && igual(i1.dir, i2.dir); + } else if(i1 == null && i2 == null){ + resp = true; + } else { + resp = false; + } + return resp; + } + + public int soma(){ + return soma(raiz); + } + + public int soma(No i){ + int resp = 0; + if(i != null){ + resp = i.elemento + soma(i.esq) + soma(i.dir); + } + return resp; + } + + public int quantidadePares(){ + return quantidadePares(raiz); + } + + public int quantidadePares(No i){ + int resp = 0; + if(i != null){ + resp = ((i.elemento % 2 == 0) ? 1 : 0) + quantidadePares(i.esq) + quantidadePares(i.dir); + } + return resp; + } + + public boolean hasDiv11(){ + return hasDiv11(raiz); + } + + public boolean hasDiv11(No i){ + boolean resp = false; + if(i != null){ + resp = (i.elemento % 11 == 0) || hasDiv11(i.esq) || hasDiv11(i.dir); + } + return resp; + } +} diff --git a/fonte/U6 - Árvores binárias/java/arvoreBinariaJava/No.java b/fonte/U6 - Árvores binárias/java/arvoreBinariaJava/No.java new file mode 100644 index 0000000..f7953cb --- /dev/null +++ b/fonte/U6 - Árvores binárias/java/arvoreBinariaJava/No.java @@ -0,0 +1,28 @@ +/** + * No da arvore binaria + * @author Max do Val Machado + */ +class No { + public int elemento; // Conteudo do no. + public No esq, dir; // Filhos da esq e dir. + + /** + * Construtor da classe. + * @param elemento Conteudo do no. + */ + public No(int elemento) { + this(elemento, null, null); + } + + /** + * Construtor da classe. + * @param elemento Conteudo do no. + * @param esq No da esquerda. + * @param dir No da direita. + */ + public No(int elemento, No esq, No dir) { + this.elemento = elemento; + this.esq = esq; + this.dir = dir; + } +} diff --git a/fonte/U6 - Árvores binárias/java/arvoreBinariaJava/Principal.java b/fonte/U6 - Árvores binárias/java/arvoreBinariaJava/Principal.java new file mode 100644 index 0000000..5624f59 --- /dev/null +++ b/fonte/U6 - Árvores binárias/java/arvoreBinariaJava/Principal.java @@ -0,0 +1,30 @@ +/** + * Principal para Arvore Binaria de Pesquisa + * @author Max do Val Machado + */ +public class Principal { + public static void main(String[] args) throws Exception { + ArvoreBinaria arvoreBinaria = new ArvoreBinaria(); + + arvoreBinaria.inserir(3); + arvoreBinaria.inserir(5); + arvoreBinaria.inserir(1); + arvoreBinaria.inserir(8); + arvoreBinaria.inserir(2); + arvoreBinaria.inserir(4); + arvoreBinaria.inserir(7); + arvoreBinaria.inserir(6); + + arvoreBinaria.caminharCentral(); + arvoreBinaria.caminharPre(); + arvoreBinaria.caminharPos(); + + arvoreBinaria.remover(6); + arvoreBinaria.remover(2); + arvoreBinaria.remover(4); + + arvoreBinaria.caminharCentral(); + arvoreBinaria.caminharPre(); + arvoreBinaria.caminharPos(); + } +} diff --git a/fonte/U6 - Árvores binárias/java/arvoreBinariaJava/Principal2.java b/fonte/U6 - Árvores binárias/java/arvoreBinariaJava/Principal2.java new file mode 100644 index 0000000..508e6d7 --- /dev/null +++ b/fonte/U6 - Árvores binárias/java/arvoreBinariaJava/Principal2.java @@ -0,0 +1,33 @@ +/** + * Principal para Arvore Binaria de Pesquisa + * @author Max do Val Machado + */ +import java.util.*; + +public class Principal2 { + public static void main(String[] args) throws Exception { + ArvoreBinaria a1 = new ArvoreBinaria(); + ArvoreBinaria a2 = new ArvoreBinaria(); + + Random gerador = new Random(); + gerador.setSeed(4); + for(int i = 1; i < 100000; i++){ + int valor = Math.abs(gerador.nextInt()); + if(a1.pesquisar(valor) == false){ + a1.inserir(valor); + a2.inserir(valor); + } + if(i % 100 == 0){ + a1.remover(valor); + a2.remover(valor); + a1.remover(a1.getRaiz()); + a2.remover(a2.getRaiz()); + } + + if(ArvoreBinaria.igual(a1, a2) == false){ + System.out.println("Árvores diferentes..."); + } + + } + } +} diff --git a/fonte/U7 - Balanceamento de árvores/java/alvinegra/Alvinegra.java b/fonte/U7 - Balanceamento de árvores/java/alvinegra/Alvinegra.java new file mode 100644 index 0000000..3c62bff --- /dev/null +++ b/fonte/U7 - Balanceamento de árvores/java/alvinegra/Alvinegra.java @@ -0,0 +1,295 @@ +/** + * Arvore binaria de pesquisa + * @author Max do Val Machado + */ +public class Alvinegra { + private NoAN raiz; // Raiz da arvore. + + /** + * Construtor da classe. + */ + public Alvinegra() { + raiz = null; + } + + /** + * Metodo publico iterativo para pesquisar elemento. + * @param elemento Elemento que sera procurado. + * @return true se o elemento existir, + * false em caso contrario. + */ + public boolean pesquisar(int elemento) { + return pesquisar(elemento, raiz); + } + + /** + * Metodo privado recursivo para pesquisar elemento. + * @param elemento Elemento que sera procurado. + * @param i NoAN em analise. + * @return true se o elemento existir, + * false em caso contrario. + */ + private boolean pesquisar(int elemento, NoAN i) { + boolean resp; + if (i == null) { + resp = false; + + } else if (elemento == i.elemento) { + resp = true; + + } else if (elemento < i.elemento) { + resp = pesquisar(elemento, i.esq); + + } else { + resp = pesquisar(elemento, i.dir); + } + return resp; + } + + /** + * Metodo publico iterativo para exibir elementos. + */ + public void mostrarCentral() { + System.out.print("[ "); + mostrarCentral(raiz); + System.out.println("]"); + } + + /** + * Metodo privado recursivo para exibir elementos. + * @param i NoAN em analise. + */ + private void mostrarCentral(NoAN i) { + if (i != null) { + mostrarCentral(i.esq); // Elementos da esquerda. + System.out.print(i.elemento + ((i.cor) ? "(p) " : "(b) ")); // Conteudo do no. + mostrarCentral(i.dir); // Elementos da direita. + } + } + + /** + * Metodo publico iterativo para exibir elementos. + */ + public void mostrarPre() { + System.out.print("[ "); + mostrarPre(raiz); + System.out.println("]"); + } + + /** + * Metodo privado recursivo para exibir elementos. + * @param i NoAN em analise. + */ + private void mostrarPre(NoAN i) { + if (i != null) { + System.out.print(i.elemento + ((i.cor) ? "(p) " : "(b) ")); // Conteudo do no. + mostrarPre(i.esq); // Elementos da esquerda. + mostrarPre(i.dir); // Elementos da direita. + } + } + + /** + * Metodo publico iterativo para exibir elementos. + */ + public void mostrarPos() { + System.out.print("[ "); + mostrarPos(raiz); + System.out.println("]"); + } + + /** + * Metodo privado recursivo para exibir elementos. + * @param i NoAN em analise. + */ + private void mostrarPos(NoAN i) { + if (i != null) { + mostrarPos(i.esq); // Elementos da esquerda. + mostrarPos(i.dir); // Elementos da direita. + System.out.print(i.elemento + ((i.cor) ? "(p) " : "(b) ")); // Conteudo do no. + } + } + + + /** + * Metodo publico iterativo para inserir elemento. + * @param elemento Elemento a ser inserido. + * @throws Exception Se o elemento existir. + */ + public void inserir(int elemento) throws Exception { + + //Se a arvore estiver vazia + if(raiz == null){ + raiz = new NoAN(elemento, false); + System.out.println("Antes, zero elementos. Agora, raiz(" + raiz.elemento + ")."); + + //Senao, se a arvore tiver um elemento + } else if (raiz.esq == null && raiz.dir == null){ + if (raiz.elemento > elemento){ + raiz.esq = new NoAN(elemento, true); + System.out.println("Antes, um elemento. Agora, raiz(" + raiz.elemento + ") e esq(" + raiz.esq.elemento +")."); + } else { + raiz.dir = new NoAN(elemento, true); + System.out.println("Antes, um elemento. Agora, raiz(" + raiz.elemento + ") e dir(" + raiz.dir.elemento +")."); + } + + //Senao, se a arvore tiver dois elementos (raiz e dir) + } else if (raiz.esq == null){ + + if(raiz.elemento > elemento){ + raiz.esq = new NoAN(elemento); + System.out.println("Antes, dois elementos(A). Agora, raiz(" + raiz.elemento + "), esq (" + raiz.esq.elemento +") e dir(" + raiz.dir.elemento +")."); + + } else if (raiz.dir.elemento > elemento){ + raiz.esq = new NoAN(raiz.elemento); + raiz.elemento = elemento; + System.out.println("Antes, dois elementos(B). Agora, raiz(" + raiz.elemento + "), esq (" + raiz.esq.elemento +") e dir(" + raiz.dir.elemento +")."); + + } else { + raiz.esq = new NoAN(raiz.elemento); + raiz.elemento = raiz.dir.elemento; + raiz.dir.elemento = elemento; + System.out.println("Antes, dois elementos(C). Agora, raiz(" + raiz.elemento + "), esq (" + raiz.esq.elemento +") e dir(" + raiz.dir.elemento +")."); + } + + raiz.esq.cor = raiz.dir.cor = false; + + //Senao, se a arvore tiver dois elementos (raiz e esq) + } else if (raiz.dir == null){ + + if(raiz.elemento < elemento){ + raiz.dir = new NoAN(elemento); + System.out.println("Antes, dois elementos(D). Agora, raiz(" + raiz.elemento + "), esq (" + raiz.esq.elemento +") e dir(" + raiz.dir.elemento +")."); + } else if (raiz.esq.elemento < elemento){ + raiz.dir = new NoAN(raiz.elemento); + raiz.elemento = elemento; + System.out.println("Antes, dois elementos(E). Agora, raiz(" + raiz.elemento + "), esq (" + raiz.esq.elemento +") e dir(" + raiz.dir.elemento +")."); + } else { + raiz.dir = new NoAN(raiz.elemento); + raiz.elemento = raiz.esq.elemento; + raiz.esq.elemento = elemento; + System.out.println("Antes, dois elementos(F). Agora, raiz(" + raiz.elemento + "), esq (" + raiz.esq.elemento +") e dir(" + raiz.dir.elemento +")."); + } + + raiz.esq.cor = raiz.dir.cor = false; + + //Senao, a arvore tem tres ou mais elementos + } else { + System.out.println("Arvore com tres ou mais elementos..."); + inserir(elemento, null, null, null, raiz); + } + + raiz.cor = false; + } + + private void balancear(NoAN bisavo, NoAN avo, NoAN pai, NoAN i){ + + //Se o pai tambem e preto, reequilibrar a arvore, rotacionando o avo + if(pai.cor == true){ + + //4 tipos de reequilibrios e acoplamento + if(pai.elemento > avo.elemento){ // rotacao a esquerda ou direita-esquerda + if(i.elemento > pai.elemento){ + avo = rotacaoEsq(avo); + } else { + avo = rotacaoDirEsq(avo); + } + + } else { // rotacao a direita ou esquerda-direita + if(i.elemento < pai.elemento){ + avo = rotacaoDir(avo); + } else { + avo = rotacaoEsqDir(avo); + } + } + + if (bisavo == null){ + raiz = avo; + } else { + if(avo.elemento < bisavo.elemento){ + bisavo.esq = avo; + } else { + bisavo.dir = avo; + } + } + + //reestabelecer as cores apos a rotacao + avo.cor = false; + avo.esq.cor = avo.dir.cor = true; + System.out.println("Reestabeler cores: avo(" + avo.elemento + "->branco) e avo.esq / avo.dir(" + avo.esq.elemento + "," + avo.dir.elemento + "-> pretos)"); + } //if(pai.cor == true) + } + + /** + * Metodo privado recursivo para inserir elemento. + * @param elemento Elemento a ser inserido. + * @param avo NoAN em analise. + * @param pai NoAN em analise. + * @param i NoAN em analise. + * @throws Exception Se o elemento existir. + */ + private void inserir(int elemento, NoAN bisavo, NoAN avo, NoAN pai, NoAN i) throws Exception { + if (i == null) { + + if(elemento < pai.elemento){ + i = pai.esq = new NoAN(elemento, true); + } else { + i = pai.dir = new NoAN(elemento, true); + } + + if(pai.cor == true){ + balancear(bisavo, avo, pai, i); + } + + } else { + + //Achou um 4-no: eh preciso fragmeta-lo e reequilibrar a arvore + if(i.esq != null && i.dir != null && i.esq.cor == true && i.dir.cor == true){ + i.cor = true; + i.esq.cor = i.dir.cor = false; + if(i == raiz){ + i.cor = false; + }else if(pai.cor == true){ + balancear(bisavo, avo, pai, i); + } + } + if (elemento < i.elemento) { + inserir(elemento, avo, pai, i, i.esq); + } else if (elemento > i.elemento) { + inserir(elemento, avo, pai, i, i.dir); + } else { + throw new Exception("Erro inserir (elemento repetido)!"); + } + } + } + + private NoAN rotacaoDir(NoAN no) { + System.out.println("Rotacao DIR(" + no.elemento + ")"); + NoAN noEsq = no.esq; + NoAN noEsqDir = noEsq.dir; + + noEsq.dir = no; + no.esq = noEsqDir; + + return noEsq; + } + + private NoAN rotacaoEsq(NoAN no) { + System.out.println("Rotacao ESQ(" + no.elemento + ")"); + NoAN noDir = no.dir; + NoAN noDirEsq = noDir.esq; + + noDir.esq = no; + no.dir = noDirEsq; + return noDir; + } + + private NoAN rotacaoDirEsq(NoAN no) { + no.dir = rotacaoDir(no.dir); + return rotacaoEsq(no); + } + + private NoAN rotacaoEsqDir(NoAN no) { + no.esq = rotacaoEsq(no.esq); + return rotacaoDir(no); + } +} diff --git a/fonte/U7 - Balanceamento de árvores/java/alvinegra/NoAN.java b/fonte/U7 - Balanceamento de árvores/java/alvinegra/NoAN.java new file mode 100644 index 0000000..3e00739 --- /dev/null +++ b/fonte/U7 - Balanceamento de árvores/java/alvinegra/NoAN.java @@ -0,0 +1,24 @@ +/** + * NoAN da arvore binaria + * @author Max do Val Machado + */ +class NoAN{ + public boolean cor; + public int elemento; + public NoAN esq, dir; + public NoAN (){ + this(-1); + } + public NoAN (int elemento){ + this(elemento, false, null, null); + } + public NoAN (int elemento, boolean cor){ + this(elemento, cor, null, null); + } + public NoAN (int elemento, boolean cor, NoAN esq, NoAN dir){ + this.cor = cor; + this.elemento = elemento; + this.esq = esq; + this.dir = dir; + } +} diff --git a/fonte/U7 - Balanceamento de árvores/java/alvinegra/Principal.java b/fonte/U7 - Balanceamento de árvores/java/alvinegra/Principal.java new file mode 100644 index 0000000..439eb37 --- /dev/null +++ b/fonte/U7 - Balanceamento de árvores/java/alvinegra/Principal.java @@ -0,0 +1,77 @@ +import java.util.*; + +/** + * Principal para Arvore Binaria de Pesquisa + * @author Max do Val Machado + */ +public class Principal { + public static void main(String[] args) throws Exception { + Alvinegra arvore = new Alvinegra(); + + /* + arvore.inserir(1); + arvore.inserir(2); + arvore.inserir(3); + arvore.mostrarPre(); + + arvore = new Alvinegra(); + arvore.inserir(1); + arvore.inserir(3); + arvore.inserir(2); + arvore.mostrarPre(); + + arvore = new Alvinegra(); + arvore.inserir(2); + arvore.inserir(1); + arvore.inserir(3); + arvore.mostrarPre(); + + arvore = new Alvinegra(); + arvore.inserir(2); + arvore.inserir(3); + arvore.inserir(1); + arvore.mostrarPre(); + + arvore = new Alvinegra(); + arvore.inserir(3); + arvore.inserir(1); + arvore.inserir(2); + arvore.mostrarPre(); + + arvore = new Alvinegra(); + arvore.inserir(3); + arvore.inserir(2); + arvore.inserir(1); + arvore.mostrarPre(); + */ + + arvore = new Alvinegra(); + arvore.inserir(4); + arvore.inserir(35); + arvore.inserir(10); + arvore.inserir(13); + arvore.inserir(3); + arvore.inserir(30); + arvore.inserir(15); + arvore.inserir(12); + arvore.inserir(7); + arvore.inserir(40); + arvore.inserir(20); + arvore.mostrarPre(); + + + /* + arvore = new Alvinegra(); + Random gerador = new Random(); + gerador.setSeed(4); + for(int i = 0; i < 4000; i++){ + int elemento; + do { + elemento = ((int)Math.abs(gerador.nextInt())) % 100000; + } while (arvore.pesquisar(elemento) == true); + arvore.inserir(elemento); + arvore.mostrarPre(); + } + */ + } +} diff --git a/fonte/U7 - Balanceamento de árvores/java/avl/AVL.java b/fonte/U7 - Balanceamento de árvores/java/avl/AVL.java new file mode 100644 index 0000000..db228a3 --- /dev/null +++ b/fonte/U7 - Balanceamento de árvores/java/avl/AVL.java @@ -0,0 +1,276 @@ +/** + * Arvore binaria de pesquisa + * @author Max do Val Machado + */ +public class AVL { + private No raiz; // Raiz da arvore. + + /** + * Construtor da classe. + */ + public AVL() { + raiz = null; + } + + /** + * Metodo publico iterativo para pesquisar elemento. + * @param x Elemento que sera procurado. + * @return true se o elemento existir, + * false em caso contrario. + */ + public boolean pesquisar(int x) { + return pesquisar(x, raiz); + } + + /** + * Metodo privado recursivo para pesquisar elemento. + * @param x Elemento que sera procurado. + * @param i No em analise. + * @return true se o elemento existir, + * false em caso contrario. + */ + private boolean pesquisar(int x, No i) { + boolean resp; + if (i == null) { + resp = false; + + } else if (x == i.elemento) { + resp = true; + + } else if (x < i.elemento) { + resp = pesquisar(x, i.esq); + + } else { + resp = pesquisar(x, i.dir); + } + return resp; + } + + /** + * Metodo publico iterativo para exibir elementos. + */ + public void mostrarCentral() { + System.out.print("[ "); + mostrarCentral(raiz); + System.out.println("]"); + } + + /** + * Metodo privado recursivo para exibir elementos. + * @param i No em analise. + */ + private void mostrarCentral(No i) { + if (i != null) { + mostrarCentral(i.esq); // Elementos da esquerda. + System.out.print(i.elemento + " "); // Conteudo do no. + mostrarCentral(i.dir); // Elementos da direita. + } + } + + /** + * Metodo publico iterativo para exibir elementos. + */ + public void mostrarPre() { + System.out.print("[ "); + mostrarPre(raiz); + System.out.println("]"); + } + + /** + * Metodo privado recursivo para exibir elementos. + * @param i No em analise. + */ + private void mostrarPre(No i) { + if (i != null) { + System.out.print(i.elemento + "(fator " + (No.getNivel(i.dir) - No.getNivel(i.esq)) + ") "); // Conteudo do no. + mostrarPre(i.esq); // Elementos da esquerda. + mostrarPre(i.dir); // Elementos da direita. + } + } + + /** + * Metodo publico iterativo para exibir elementos. + */ + public void mostrarPos() { + System.out.print("[ "); + mostrarPos(raiz); + System.out.println("]"); + } + + /** + * Metodo privado recursivo para exibir elementos. + * @param i No em analise. + */ + private void mostrarPos(No i) { + if (i != null) { + mostrarPos(i.esq); // Elementos da esquerda. + mostrarPos(i.dir); // Elementos da direita. + System.out.print(i.elemento + " "); // Conteudo do no. + } + } + + + /** + * Metodo publico iterativo para inserir elemento. + * @param x Elemento a ser inserido. + * @throws Exception Se o elemento existir. + */ + public void inserir(int x) throws Exception { + raiz = inserir(x, raiz); + } + + /** + * Metodo privado recursivo para inserir elemento. + * @param x Elemento a ser inserido. + * @param i No em analise. + * @return No em analise, alterado ou nao. + * @throws Exception Se o elemento existir. + */ + private No inserir(int x, No i) throws Exception { + if (i == null) { + i = new No(x); + + } else if (x < i.elemento) { + i.esq = inserir(x, i.esq); + + } else if (x > i.elemento) { + i.dir = inserir(x, i.dir); + + } else { + throw new Exception("Erro ao inserir!"); + } + + return balancear(i); + } + + + /** + * Metodo publico iterativo para remover elemento. + * @param x Elemento a ser removido. + * @throws Exception Se nao encontrar elemento. + */ + public void remover(int x) throws Exception { + raiz = remover(x, raiz); + } + + /** + * Metodo privado recursivo para remover elemento. + * @param x Elemento a ser removido. + * @param i No em analise. + * @return No em analise, alterado ou nao. + * @throws Exception Se nao encontrar elemento. + */ + private No remover(int x, No i) throws Exception { + + if (i == null) { + throw new Exception("Erro ao remover!"); + + } else if (x < i.elemento) { + i.esq = remover(x, i.esq); + + } else if (x > i.elemento) { + i.dir = remover(x, i.dir); + + // Sem no a direita. + } else if (i.dir == null) { + i = i.esq; + + // Sem no a esquerda. + } else if (i.esq == null) { + i = i.dir; + + // No a esquerda e no a direita. + } else { + i.esq = antecessor(i, i.esq); + } + + return balancear(i); + } + + /** + * Metodo para trocar no removido pelo antecessor. + * @param i No que teve o elemento removido. + * @param j No da subarvore esquerda. + * @return No em analise, alterado ou nao. + */ + private No antecessor(No i, No j) { + + // Existe no a direita. + if (j.dir != null) { + // Caminha para direita. + j.dir = antecessor(i, j.dir); + + // Encontrou o maximo da subarvore esquerda. + } else { + i.elemento = j.elemento; // Substitui i por j. + j = j.esq; // Substitui j por j.ESQ. + } + return j; + } + + + private No balancear(No no) throws Exception { + if(no != null){ + int fator = No.getNivel(no.dir) - no.getNivel(no.esq); + + //Se balanceada + if (Math.abs(fator) <= 1){ + no.setNivel(); + + //Se desbalanceada para a direita + }else if (fator == 2){ + + int fatorFilhoDir = No.getNivel(no.dir.dir) - No.getNivel(no.dir.esq); + + //Se o filho a direita tambem estiver desbalanceado + if (fatorFilhoDir == -1) { + no.dir = rotacionarDir(no.dir); + } + no = rotacionarEsq(no); + + //Se desbalanceada para a esquerda + }else if (fator == -2){ + + int fatorFilhoEsq = No.getNivel(no.esq.dir) - No.getNivel(no.esq.esq); + + //Se o filho a esquerda tambem estiver desbalanceado + if (fatorFilhoEsq == 1) { + no.esq = rotacionarEsq(no.esq); + } + no = rotacionarDir(no); + + }else{ + throw new Exception("Erro fator de balanceamento (" + fator + ") invalido!"); + } + } + + return no; + } + + private No rotacionarDir(No no) { + System.out.println("Rotacionar DIR(" + no.elemento + ")"); + No noEsq = no.esq; + No noEsqDir = noEsq.dir; + + noEsq.dir = no; + no.esq = noEsqDir; + + no.setNivel(); + noEsq.setNivel(); + + return noEsq; + } + + private No rotacionarEsq(No no) { + System.out.println("Rotacionar ESQ(" + no.elemento + ")"); + No noDir = no.dir; + No noDirEsq = noDir.esq; + + noDir.esq = no; + no.dir = noDirEsq; + + no.setNivel(); + noDir.setNivel(); + return noDir; + } +} diff --git a/fonte/U7 - Balanceamento de árvores/java/avl/No.java b/fonte/U7 - Balanceamento de árvores/java/avl/No.java new file mode 100644 index 0000000..92e52d3 --- /dev/null +++ b/fonte/U7 - Balanceamento de árvores/java/avl/No.java @@ -0,0 +1,45 @@ +/** + * No da arvore binaria + * @author Max do Val Machado + */ +class No { + public int elemento; // Conteudo do no. + public No esq, dir; // Filhos da esq e dir. + public int nivel; //Numero de niveis abaixo do no + + /** + * Construtor da classe. + * @param elemento Conteudo do no. + */ + public No(int elemento) { + this(elemento, null, null, 1); + } + + /** + * Construtor da classe. + * @param elemento Conteudo do no. + * @param esq No da esquerda. + * @param dir No da direita. + */ + public No(int elemento, No esq, No dir, int nivel) { + this.elemento = elemento; + this.esq = esq; + this.dir = dir; + this.nivel = nivel; + } + + /** + * Cálculo do número de níveis a partir de um vértice + */ + public void setNivel() { + this.nivel = 1 + Math.max(getNivel(esq),getNivel(dir)); + } + + /** + * Retorna o número de níveis a partir de um vértice + * @param no nó que se deseja o nível. + */ + public static int getNivel(No no) { + return (no == null) ? 0 : no.nivel; + } +} diff --git a/fonte/U7 - Balanceamento de árvores/java/avl/Principal.java b/fonte/U7 - Balanceamento de árvores/java/avl/Principal.java new file mode 100644 index 0000000..17b1bde --- /dev/null +++ b/fonte/U7 - Balanceamento de árvores/java/avl/Principal.java @@ -0,0 +1,76 @@ +/** + * Principal para Arvore Binaria de Pesquisa + * @author Max do Val Machado + */ +public class Principal { + public static void main(String[] args) { + try { + AVL avl = new AVL(); + avl.inserir(9); + avl.mostrarPre(); + avl.inserir(8); + avl.mostrarPre(); + avl.inserir(4); + avl.mostrarPre(); + avl.inserir(6); + avl.mostrarPre(); + avl.inserir(5); + avl.mostrarPre(); + avl.inserir(3); + avl.mostrarPre(); + avl.inserir(7); + avl.mostrarPre(); + avl.inserir(2); + avl.mostrarPre(); + avl.inserir(1); + avl.mostrarPre(); + /* + avl.inserir(8); + avl.mostrarPre(); + avl.inserir(10); + avl.mostrarPre(); + avl.inserir(5); + avl.mostrarPre(); + avl.inserir(6); + avl.mostrarPre(); + avl.inserir(2); + avl.mostrarPre(); + avl.inserir(9); + avl.mostrarPre(); + avl.inserir(11); + avl.mostrarPre(); + avl.inserir(1); + avl.mostrarPre(); + avl.inserir(4); + avl.mostrarPre(); + avl.inserir(7); + avl.mostrarPre(); + avl.inserir(12); + avl.mostrarPre(); + avl.inserir(3); + avl.mostrarPre(); + + for(int i = 40; i >= 21; i--){ + avl.inserir(i); + avl.mostrarPre(); + System.out.println("Inserindo o " + i + " (altura = " + avl.getAltura() +")"); + } + + avl.mostrarCentral(); + avl.mostrarPre(); + avl.mostrarPos(); + + avl.remover(6); + avl.remover(2); + avl.remover(4); + + avl.mostrarCentral(); + avl.mostrarPre(); + avl.mostrarPos(); + */ + } + catch(Exception erro) { + System.out.println(erro.getMessage()); + } + } +} diff --git a/fonte/U8 - Tabelas e dicionários/java/doidona/DoidonaComTADsProntas.java b/fonte/U8 - Tabelas e dicionários/java/doidona/DoidonaComTADsProntas.java new file mode 100644 index 0000000..7b653e8 --- /dev/null +++ b/fonte/U8 - Tabelas e dicionários/java/doidona/DoidonaComTADsProntas.java @@ -0,0 +1,117 @@ +class DoidonaComTADsProntas { + final int TAMT1 = 100; + final int TAMT3 = 100; + final int NULO = -0x7FFFFF; + + int[] t1; + int[] t3; + + ArvoreBinaria arvoreBinaria; + ListaSimples lista; + AVL arvoreAVL; + + public Doidona(){ + t1 = new int [TAMT1]; + t3 = new int [TAMT3]; + + for(int i = 0; i < TAMT1; i++){ + t1[i] = NULO; + } + for(int i = 0; i < TAMT3; i++){ + t3[i] = NULO; + } + + arvoreBinaria = new ArvoreBinaria(); + arvoreAVL = new AVL(); + lista = new ListaSimples(); + } + + public int hashT1(int elemento){ + } + + public int hashT2(int elemento){ + return elemento % 3; + } + + public int hashT3(int elemento){ + } + + public int rehashT3(int elemento){ + } + + public void inserir(int elemento){ + int i = hashT1(elemento); + if(elemento == NULO) { + //???? + } else if(t1[i] == NULO){ + t1[i] = elemento; + }else if(hashT2(elemento) == 0){ + int i = hashT3(elemento); + + if(t3[i] == NULO){ + t3[i] = elemento; + } else { + i = rehashT3(elemento); + + if(t3[i] == NULO){ + t3[i] = elemento; + } else { + arvoreBinaria.inserir(elemento); + } + } + }else if (hashT2(elemento) == 1){ + lista.inserirFim(elemento); + }else if (hashT2(elemento) == 2){ + arvoreAVL.inserir(elemento); + } else { + System.out.println("ERRO!!!!"); + } + } + void remover (int valor){ + } + + boolean pesquisar (int valor){ + boolean resp = false; + int pos = hashT1(valor); + if(t1[pos] == valor){ + resp = true; + }else { + pos = hashT2(valor); + if (pos == 0){ + pos = hashT3(valor); + if(t3[pos] == valor){ + resp = true; + }else{ + pos = rehashT3(valor); + if(t3[pos] == valor){ + resp = true; + }else{ + resp = arvoreBinaria.pesquisar(valor); + } + } + }else if (pos == 1){ + resp = lista.pesquisar(valor); + } else { + resp = arvoreAVL.pesquisar(valor); + } + } + return resp; + } + + void mostrar(){ + //t1, t3, arvoreBinaria, lista, arvoreAVL + for(int i = 0; i < TAMT1; i++){ + if(t1[i] != NULO){ + System.out.println(t1[i]); + } + } + for(int i = 0; i < TAMT3; i++){ + if(t3[i] != NULO){ + System.out.println(t3[i]); + } + } + arvoreBinaria.mostrar(); + lista.mostrar(); + arvoreAVL.mostrar(); + } +} diff --git a/fonte/U8 - Tabelas e dicionários/java/doidona/DoidonaSemTADsProntas.java b/fonte/U8 - Tabelas e dicionários/java/doidona/DoidonaSemTADsProntas.java new file mode 100644 index 0000000..ad2dfb5 --- /dev/null +++ b/fonte/U8 - Tabelas e dicionários/java/doidona/DoidonaSemTADsProntas.java @@ -0,0 +1,159 @@ +class DoidonaSemTADsProntas { + final int TAMT1 = 100; + final int TAMT3 = 100; + final int NULO = -0x7FFFFF; + + int[] t1; + int[] t3; + + Celula primeiroListaT2, ultimoListaT2; + No raizArvoreT2, raizArvoreT3; + + public Doidona (){ + t1 = new int[TAMT1]; + t3 = new int[TAMT3]; + + for(int i = 0; i < TAMT1; i++){ + t1[i] = NULO; + } + for(int i = 0; i < TAMT3; i++){ + t3[i] = NULO; + } + + primeiroListaT2 = ultimoListaT2 = new Celula(); + + raizArvoreT2 = raizArvoreT3 = null; + } + + public int hashT1(int elemento){ + } + + public int hashT2(int elemento){ + } + + public int hashT3(int elemento){ + } + + public int rehashT3(int elemento){ + } + + public void inserir(int elemento){ + int i = hashT1(elemento); + + if(elemento == NULO){ + // gerar msg de erro!!!! + } else if(t1[i] == NULO){ + t1[i] = elemento; + }else if(hashT2(elemento) == 0){ + inserirT3(elemento); + }else if (hashT2(elemento) == 1){ + inserirLista(elemento); + }else if (hashT2(elemento) == 2){ + raizArvoreT2 = inserirArvore(raizArvoreT2, elemento); + } else { + System.out.println("ERRO!!!!"); + } + } + + public void inserirT3(int elemento){ + int i = hashT3(elemento); + + if(t3[i] == NULO){ + t3[i] = elemento; + } else { + i = rehashT3(elemento); + + if(t3[i] == NULO){ + t3[i] = elemento; + } else { + raizArvoreT3 = inserirArvore(raizArvoreT3, elemento); + } + } + } + + public void inserirLista(int elemento){ + ultimoListaT2.prox = new Celula(elemento); + ultimoListaT2 = ultimoListaT2.prox; + } + + public No inserirArvore(No no, int elemento){ + if(no == null){ + no = new No (elemento); + } else if (no.elemento < elemento){ + no.esq = inserirArvore(no.esq, elemento); + } else if (no.elemento > elemento){ + no.dir = inserirArvore(no.dir, elemento); + } else { + System.out.println("Erro de Insercao"); + } + return no; + } + + public boolean pesquisar(int elemento){ + boolean resp; + int i = hashT1(elemento); + if(t1[i] == NULO){ + resp = false; + }else if(t1[i] == elemento){ + resp = true; + }else if(hashT2(elemento) == 0){ + resp = pesquisarT3(elemento); + }else if (hashT2(elemento) == 1){ + resp = pesquisarLista(elemento); + }else if (hashT2(elemento) == 2){ + resp = pesquisarArvore(raizArvoreT2, elemento); + } else { + resp = false; + System.out.println("ERRO!!!!"); + } + return resp; + } + + public boolean pesquisarT3(int elemento){ + int i = hashT3(elemento); + + if(t3[i] == NULO){ + resp = false; + }else if(t3[i] == elemento){ + resp = true; + } else { + i = rehashT3(elemento); + + if(t3[i] == NULO){ + resp = false; + } else if(t3[i] == elemento){ + resp = true; + } else { + resp = pesquisarArvore(raizArvoreT3, elemento); + } + } + + return resp; + } + + public boolean pesquisarLista(int elemento){ + boolean resp = false; + for(Celula i = primeiroListaT2.prox; i != null; i = i.prox){ + if(i.elemento == elemento){ + resp = true; + i = ultimoListaT2; + } + } + return resp; + } + + public boolean pesquisarArvore(No no, int elemento){ + boolean resp; + + if(no == null){ + resp = false; + } else if (no.elemento < elemento){ + resp = pesquisarArvore(no.esq, elemento); + } else if (no.elemento > elemento){ + resp = pesquisarArvore(no.dir, elemento); + } else { + resp = true; + } + return resp; + } +} diff --git a/fonte/U8 - Tabelas e dicionários/java/hashDiretoRehash/Hash.java b/fonte/U8 - Tabelas e dicionários/java/hashDiretoRehash/Hash.java new file mode 100644 index 0000000..6a3c60f --- /dev/null +++ b/fonte/U8 - Tabelas e dicionários/java/hashDiretoRehash/Hash.java @@ -0,0 +1,76 @@ +class Hash { + int tabela[]; + int m; + int NULO = -1; + + public Hash (){ + this(13); + } + + public Hash (int m){ + this.m = m; + this.tabela = new int [this.m]; + for(int i = 0; i < m; i++){ + tabela[i] = NULO; + } + } + + public int h(int elemento){ + return elemento % m; + } + + public int reh(int elemento){ + return ++elemento % m; + } + + public boolean inserir (int elemento){ + boolean resp = false; + + if(elemento != NULO){ + + int pos = h(elemento); + + if(tabela[pos] == NULO){ + tabela[pos] = elemento; + resp = true; + + } else{ + + pos = reh(elemento); + + if(tabela[pos] == NULO){ + tabela[pos] = elemento; + resp = true; + } + } + } + + return resp; + } + + public boolean pesquisar (int elemento){ + boolean resp = false; + + int pos = h(elemento); + + if(tabela[pos] == elemento){ + resp = true; + + } else { + pos = reh(elemento); + + if(tabela[pos] == elemento){ + resp = true; + } + } + return resp; + } + + boolean remover (int elemento){ + boolean resp = false; + + //... + + return resp; + } +} diff --git a/fonte/U8 - Tabelas e dicionários/java/hashDiretoReserva/Hash.java b/fonte/U8 - Tabelas e dicionários/java/hashDiretoReserva/Hash.java new file mode 100644 index 0000000..e102361 --- /dev/null +++ b/fonte/U8 - Tabelas e dicionários/java/hashDiretoReserva/Hash.java @@ -0,0 +1,73 @@ +public class Hash { + int tabela[]; + int m1, m2, m, reserva; + int NULO = -1; + + public Hash (){ + this(13, 7); + } + + public Hash (int m1, int m2){ + this.m1 = m1; + this.m2 = m2; + this.m = m1 + m2; + this.tabela = new int [this.m]; + for(int i = 0; i < m; i++){ + tabela[i] = NULO; + } + reserva = 0; + } + + public int h(int elemento){ + return elemento % m1; + } + + public boolean inserir (int elemento){ + boolean resp = false; + + if(elemento != NULO){ + + int pos = h(elemento); + + if(tabela[pos] == NULO){ + tabela[pos] = elemento; + resp = true; + + } else if (reserva < m2){ + tabela[m1 + reserva] = elemento; + reserva++; + resp = true; + } + } + + return resp; + } + + + public boolean pesquisar (int elemento){ + boolean resp = false; + + int pos = h(elemento); + + if(tabela[pos] == elemento){ + resp = true; + + } else { + for(int i = 0; i < reserva; i++){ + if(tabela[m1 + i] == elemento){ + resp = true; + i = reserva; + } + } + } + return resp; + } + + boolean remover (int elemento){ + boolean resp = false; + + //... + + return resp; + } +} diff --git a/fonte/U8 - Tabelas e dicionários/java/hashIndiretoLista/Hash.java b/fonte/U8 - Tabelas e dicionários/java/hashIndiretoLista/Hash.java new file mode 100644 index 0000000..44a535a --- /dev/null +++ b/fonte/U8 - Tabelas e dicionários/java/hashIndiretoLista/Hash.java @@ -0,0 +1,43 @@ +class HashIndiretoLista { + Lista tabela[]; + int tamanho; + final int NULO = -1; + + public HashIndiretoLista (){ + this(7); + } + + public HashIndiretoLista (int tamanho){ + this.tamanho = tamanho; + tabela = new Lista[tamanho]; + for(int i = 0; i < tamanho; i++){ + tabela[i] = new Lista(); + } + } + + public int h(int elemento){ + return elemento % tamanho; + } + + boolean pesquisar(int elemento){ + int pos = h(elemento); + return tabela[pos].pesquisar(elemento); + } + + public void inserirInicio (int elemento){ + int pos = h(elemento); + tabela[pos].inserirInicio(elemento); + } +/* + void remover(int elemento){ + int resp = NULO; + if (pesquisar(elemento) == false){ + throw new Exception("Erro ao remover!"); + } else { + int pos = h(elemento); + resp = tabela[pos].remover(elemento); + } + return resp; + } +*/ +} diff --git a/fonte/U8 - Tabelas e dicionários/java/hashIndiretoLista/Lista.java b/fonte/U8 - Tabelas e dicionários/java/hashIndiretoLista/Lista.java new file mode 100644 index 0000000..847bb87 --- /dev/null +++ b/fonte/U8 - Tabelas e dicionários/java/hashIndiretoLista/Lista.java @@ -0,0 +1,206 @@ +/** + * Celula simplesmente encadeada + * @author Joao Paulo Domingos Silva + * @version 1.1 02/2012 + */ +class Celula { + public int elemento; // Elemento inserido na celula. + public Celula prox; // Aponta a celula prox. + + /** + * Construtor da classe. + * @param elemento Elemento inserido na celula. + */ + Celula(int elemento) { + this.elemento = elemento; + this.prox = null; + } + + /** + * Construtor da classe. + * @param elemento Elemento inserido na celula. + * @param prox Aponta a celula prox. + */ + Celula(int elemento, Celula prox) { + this.elemento = elemento; + this.prox = prox; + } +} + +/** + * Lista dinamica simplesmente encadeada + * @author Joao Paulo Domingos Silva + * @version 1.1 02/2012 + */ +public class Lista { + private Celula primeiro; // Primeira celula: SEM elemento valido. + private Celula ultimo; // Ultima celula: COM elemento valido. + + /** + * Construtor da classe: Instancia uma celula (primeira e ultima). + */ + public Lista() { + primeiro = new Celula(-1); + ultimo = primeiro; + } + + /** + * Mostra os elementos separados por espacos. + */ + public void mostrar() { + System.out.print("[ "); // Comeca a mostrar. + for (Celula i = primeiro.prox; i != null; i = i.prox) { + System.out.print(i.elemento + " "); + } + System.out.println("] "); // Termina de mostrar. + } + + /** + * Procura um elemento e retorna se ele existe. + * @param x Elemento a pesquisar. + * @return true se o elemento existir, + * false em caso contrario. + */ + public boolean pesquisar(int x) { + boolean retorno = false; + for (Celula i = primeiro.prox; i != null; i = i.prox) { + if(i.elemento == x){ + retorno = true; + i = ultimo; + } + } + return retorno; + } + + /** + * Insere um elemento na primeira posicao da sequencia. + * @param elemento Elemento a inserir. + */ + public void inserirInicio(int elemento) { + Celula tmp = new Celula(elemento); + tmp.prox = primeiro.prox; + primeiro.prox = tmp; + if (primeiro == ultimo) { + ultimo = tmp; + } + tmp = null; + } + + /** + * Insere um elemento na ultima posicao da sequencia. + * @param elemento Elemento a inserir. + */ + public void inserirFim(int elemento) { + Celula tmp = new Celula(elemento); + ultimo.prox = tmp; + ultimo = ultimo.prox; + tmp = null; + } + + /** + * Insere elemento em um indice especifico. + * Considera que primeiro elemento esta no indice 0. + * @param x Elemento a inserir. + * @param posicao Meio da insercao. + * @throws Exception Se posicao for incorreta. + */ + public void inserirMeio(int x, int posicao) throws Exception { + Celula i; + int cont; + + // Caminhar ate chegar na posicao anterior a insercao + for(i = primeiro, cont = 0; (i.prox != ultimo && cont < posicao); i = i.prox, cont++); + + // Se indice for incorreto: + if (posicao < 0 || posicao > cont + 1) { + throw new Exception("Erro ao inserir (posicao " + posicao + "(cont = " + cont + ") invalida)!"); + + } else if (posicao == cont + 1) { + inserirFim(x); + }else{ + Celula tmp = new Celula(x); + tmp.prox = i.prox; + i.prox = tmp; + tmp = i = null; + } + } + + /** + * Remove um elemento da primeira posicao da sequencia. + * @return Elemento removido. + * @throws Exception Se a sequencia nao contiver elementos. + */ + public int removerInicio() throws Exception { + int resp = -1; + + if (primeiro == ultimo) { + throw new Exception("Erro ao remover (vazia)!"); + }else{ + primeiro = primeiro.prox; + resp = primeiro.elemento; + } + + return resp; + } + + /** + * Remove um elemento da ultima posicao da sequencia. + * @return Elemento removido. + * @throws Exception Se a sequencia nao contiver elementos. + */ + public int removerFim() throws Exception { + int resp = -1; + Celula i = null; + + if (primeiro == ultimo) { + throw new Exception("Erro ao remover (vazia)!"); + } else { + + resp = ultimo.elemento; + + // Caminhar ate a penultima celula: + for(i = primeiro; i.prox != ultimo; i = i.prox); + + ultimo = i; + i = ultimo.prox = null; + } + + return resp; + } + + /** + * Remove elemento de um indice especifico. + * Considera que primeiro elemento esta no indice 0. + * @param posicao Meio da remocao. + * @return Elemento removido. + * @throws Exception Se posicao for incorreta. + */ + public int removerMeio(int posicao) throws Exception { + Celula i; + int resp = -1, cont; + + if (primeiro == ultimo){ + throw new Exception("Erro ao remover (vazia)!"); + }else{ + + // Caminhar ate chegar na posicao anterior a insercao + for(i = primeiro, cont = 0; (i.prox != ultimo && cont < posicao); i = i.prox, cont++); + + // Se indice for incorreto: + if (posicao < 0 || posicao > cont + 1) { + throw new Exception("Erro ao remover (posicao " + posicao + " invalida)!"); + + } else if (posicao == cont + 1) { + resp = removerFim(); + }else{ + Celula tmp = i.prox; + resp = tmp.elemento; + i.prox = tmp.prox; + tmp.prox = null; + i = tmp = null; + } + } + + return resp; + } +} diff --git a/fonte/U9 - Árvores TRIE/java/patricia/No.java b/fonte/U9 - Árvores TRIE/java/patricia/No.java new file mode 100644 index 0000000..494150e --- /dev/null +++ b/fonte/U9 - Árvores TRIE/java/patricia/No.java @@ -0,0 +1,31 @@ +class No { + public int i, j, k; + public int tamanho = 255; + public No[] prox; + public boolean folha; + + public No (){ + this(-1, -1, -1); + } + + public No (int i, int j, int k){ + this(i, j, k, false); + } + + public No (int i, int j, int k, boolean folha){ + this.i = i; + this.j = j; + this.k = k; + this.folha = folha; + + prox = new No [tamanho]; + + for (int l = 0; l < tamanho; l++){ + prox[l] = null; + } + } + + public static int hash (char x){ + return (int)x; + } +} diff --git a/fonte/U9 - Árvores TRIE/java/patricia/Patricia.java b/fonte/U9 - Árvores TRIE/java/patricia/Patricia.java new file mode 100644 index 0000000..7ed2411 --- /dev/null +++ b/fonte/U9 - Árvores TRIE/java/patricia/Patricia.java @@ -0,0 +1,114 @@ +class Patricia { + No raiz; + String[] array; //ignorar questão de tamanho do array + + public Patricia(){ + raiz = new No(); + array = null; + } + + public void setArray(String[] array) throws Exception { + this.array = array; + for(int i = 0; i < array.length; i++){ + inserir(i); + } + } + + public String string(No no){ + return (no == raiz) ? " " : string(no.i, no.j, no.k); + } + public String string(int i, int j, int k){ + //System.out.println("i("+i+") j("+j+") k("+k+") array(i)("+array[i]+") ijk(" + array[i].substring(j,k+1) + ")"); + return array[i].substring(j,k+1); + } + + public void inserir(int i) throws Exception { + System.out.print("\n==================================================== INSERINDO : " + array[i]); + inserir(raiz, i, 0); + mostrar(); + } + private void inserir(No no, int i, int j) throws Exception { + + System.out.println("\nEM NO(" + string(no) + ") i("+ i +") j(" + j + ")"); + + if(no.prox[array[i].charAt(j)] == null){ + no.prox[array[i].charAt(j)] = new No(i, j, array[i].length()-1, true); + System.out.print("--> criando folha(" + array[i].charAt(j) + "/" + string(no.prox[array[i].charAt(j)]) + ")"); + + } else { + String prox = string(no.prox[array[i].charAt(j)]); + String inserindo = array[i].substring(j); + System.out.println("prox(" + prox + ") e inserindo(" + inserindo + ")"); + + int k; + for(k = 1; k < prox.length() && k < inserindo.length() && prox.charAt(k) == inserindo.charAt(k); k++); + System.out.println("k (" + k + ")"); + + if(k == prox.length()){ + if(no.prox[array[i].charAt(j)].folha == true){ + throw new Exception("Erro: exite um prefixo de [" + array[i] + "] na arvore"); + } else { + inserir(no.prox[array[i].charAt(j)], i, j + k); + } + } else if (k == inserindo.length()){ + throw new Exception("Erro: [" + array[i] + "] é prefixo de outra palavra da árvore"); + } else { + No novo = new No(i, j, j + k - 1, false); + novo.prox[prox.charAt(k)] = no.prox[array[i].charAt(j)]; + novo.prox[prox.charAt(k)].j = j + k; + novo.prox[inserindo.charAt(k)] = new No(i, j + k, array[i].length()-1, true); + no.prox[array[i].charAt(j)] = novo; + System.out.println("no(" + string(no) + ") e filhoNOVO(" + string(novo) + ") neto1(" + string(novo.prox[inserindo.charAt(k)]) + ") neto2(" + string(novo.prox[prox.charAt(k)]) + ")"); + } + } + } + + + public boolean pesquisar(String s){ + System.out.println("\n==================================================== PESQUISAR: " + s); + return pesquisar (raiz, s, 0); + } + public boolean pesquisar (No no, String s, int cont){ + boolean resp; + + System.out.println("EM NO(" + string(no) + ") s("+ s +") cont(" + cont + ") prox(" + no.prox[s.charAt(cont)] + ")"); + + if(no.prox[s.charAt(cont)] == null){ + System.out.println("não existe filho para [" + s.charAt(cont) + "]"); + resp = false; + } else { + String prox = string(no.prox[s.charAt(cont)]); + System.out.println("prox: " + prox); + + int i1, i2; + for(i1 = 0, i2 = cont; i1 < prox.length() && i2 < s.length() && prox.charAt(i1) == s.charAt(i2); i1++, i2++); + + if(i2 == s.length()){ + System.out.println("resp = consumiuTodosOsCaracteresDeProx(" + (i1 == prox.length()) + ") and proxFolha(" + (no.prox[s.charAt(cont)].folha) + ")"); + resp = i1 == prox.length() && no.prox[s.charAt(cont)].folha; + } else { + resp = pesquisar(no.prox[s.charAt(cont)], s, i2); + } + } + + return resp; + } + + public void mostrar(){ + System.out.println("\n==================================================== MOSTRAR: "); + mostrar("", raiz); + } + + public void mostrar(String s, No no) { + if(no.folha == true){ + System.out.println("Palavra: " + (s + string(no))); + } else { + for(int i = 0; i < no.prox.length; i++){ + if(no.prox[i] != null){ + System.out.println("ESTOU EM (" + string(no) + ") E VOU PARA (" + string(no.prox[i]) + ")"); + mostrar(s + string(no), no.prox[i]); + } + } + } + } +} diff --git a/fonte/U9 - Árvores TRIE/java/patricia/Principal.java b/fonte/U9 - Árvores TRIE/java/patricia/Principal.java new file mode 100644 index 0000000..634cee0 --- /dev/null +++ b/fonte/U9 - Árvores TRIE/java/patricia/Principal.java @@ -0,0 +1,47 @@ +class Principal { + public static void main (String[] args) throws Exception { + Patricia arv = new Patricia(); + + String array[] = new String[18]; + + array[0] = "bear"; + array[1] = "bell"; + array[2] = "bid"; + array[3] = "bull"; + array[4] = "buy"; + array[5] = "sell"; + array[6] = "stock"; + array[7] = "stop"; + array[8] = "sapo"; + array[9] = "sapato"; + array[10] = "ABACAXI"; + array[11] = "BALA"; + array[12] = "BOLO"; + array[13] = "ABACATE"; + array[14] = "galo"; + array[15] = "pata"; + array[16] = "pato"; + array[17] = "gato"; + //array[17] = "ABAC"; + //array[17] = "ABACAXIS"; + arv.setArray(array); + + arv.mostrar(); + for(int i = 0; i < array.length; i++){ + System.out.println("Pesquisar(" + array[i] + "):" + arv.pesquisar(array[i])); + } + + String s = "ABACA"; + System.out.println("Pesquisar(" + s + "):" + arv.pesquisar(s)); + + s = "ABACAXIS"; + System.out.println("Pesquisar(" + s + "):" + arv.pesquisar(s)); + + s = "gaga"; + System.out.println("Pesquisar(" + s + "):" + arv.pesquisar(s)); + + s = "ABAC"; + System.out.println("Pesquisar(" + s + "):" + arv.pesquisar(s)); + + } +} diff --git a/fonte/U9 - Árvores TRIE/java/trie/ArvoreTrie.java b/fonte/U9 - Árvores TRIE/java/trie/ArvoreTrie.java new file mode 100644 index 0000000..bd35277 --- /dev/null +++ b/fonte/U9 - Árvores TRIE/java/trie/ArvoreTrie.java @@ -0,0 +1,91 @@ +class ArvoreTrie { + private No raiz; + + public ArvoreTrie(){ + raiz = new No(); + } + + public void inserir(String s) throws Exception { + inserir(s, raiz, 0); + } + + private void inserir(String s, No no, int i) throws Exception { + System.out.print("\nEM NO(" + no.elemento + ") (" + i + ")"); + if(no.prox[s.charAt(i)] == null){ + System.out.print("--> criando filho(" + s.charAt(i) + ")"); + no.prox[s.charAt(i)] = new No(s.charAt(i)); + + if(i == s.length() - 1){ + System.out.print("(folha)"); + no.prox[s.charAt(i)].folha = true; + }else{ + inserir(s, no.prox[s.charAt(i)], i + 1); + } + + } else if (no.prox[s.charAt(i)].folha == false && i < s.length() - 1){ + inserir(s, no.prox[s.charAt(i)], i + 1); + + } else { + throw new Exception("Erro ao inserir!"); + } + } + + + public boolean pesquisar(String s) throws Exception { + return pesquisar(s, raiz, 0); + } + + public boolean pesquisar(String s, No no, int i) throws Exception { + boolean resp; + if(no.prox[s.charAt(i)] == null){ + resp = false; + } else if(i == s.length() - 1){ + resp = (no.prox[s.charAt(i)].folha == true); + } else if(i < s.length() - 1 ){ + resp = pesquisar(s, no.prox[s.charAt(i)], i + 1); + } else { + throw new Exception("Erro ao pesquisar!"); + } + return resp; + } + + + public void mostrar(){ + mostrar("", raiz); + } + + public void mostrar(String s, No no) { + if(no.folha == true){ + System.out.println("Palavra: " + (s + no.elemento)); + } else { + for(int i = 0; i < no.prox.length; i++){ + if(no.prox[i] != null){ + System.out.println("ESTOU EM (" + no.elemento + ") E VOU PARA (" + no.prox[i].elemento + ")"); + mostrar(s + no.elemento, no.prox[i]); + } + } + } + } + + public int contarAs(){ + int resp = 0; + if(raiz != null){ + resp = contarAs(raiz); + } + return resp; + } + + public int contarAs(No no) { + int resp = (no.elemento == 'A') ? 1 : 0; + + if(no.folha == false){ + for(int i = 0; i < no.prox.length; i++){ + if(no.prox[i] != null){ + resp += contarAs(no.prox[i]); + } + } + } + return resp; + } +} + diff --git a/fonte/U9 - Árvores TRIE/java/trie/No.java b/fonte/U9 - Árvores TRIE/java/trie/No.java new file mode 100644 index 0000000..d36263c --- /dev/null +++ b/fonte/U9 - Árvores TRIE/java/trie/No.java @@ -0,0 +1,21 @@ +class No { + public char elemento; + public int tamanho = 255; + public No[] prox; + public boolean folha; + + public No (){ + this(' '); + } + + public No (char elemento){ + this.elemento = elemento; + prox = new No [tamanho]; + for (int i = 0; i < tamanho; i++) prox[i] = null; + folha = false; + } + + public static int hash (char x){ + return (int)x; + } +} diff --git a/fonte/U9 - Árvores TRIE/java/trie/Patricia.java b/fonte/U9 - Árvores TRIE/java/trie/Patricia.java new file mode 100644 index 0000000..e388648 --- /dev/null +++ b/fonte/U9 - Árvores TRIE/java/trie/Patricia.java @@ -0,0 +1,104 @@ +public class Trie { + + // Alphabet size (# of symbols) + static final int ALPHABET_SIZE = 26; + + // trie node + static class TrieNode + { + TrieNode[] children = new TrieNode[ALPHABET_SIZE]; + + // isEndOfWord is true if the node represents + // end of a word + boolean isEndOfWord; + + TrieNode(){ + isEndOfWord = false; + for (int i = 0; i < ALPHABET_SIZE; i++) + children[i] = null; + } + }; + + static TrieNode root; + + // If not present, inserts key into trie + // If the key is prefix of trie node, + // just marks leaf node + static void insert(String key) + { + int level; + int length = key.length(); + int index; + + TrieNode pCrawl = root; + + for (level = 0; level < length; level++) + { + index = key.charAt(level) - 'a'; + if (pCrawl.children[index] == null) + pCrawl.children[index] = new TrieNode(); + + pCrawl = pCrawl.children[index]; + } + + // mark last node as leaf + pCrawl.isEndOfWord = true; + } + + // Returns true if key presents in trie, else false + static boolean search(String key) + { + int level; + int length = key.length(); + int index; + TrieNode pCrawl = root; + + for (level = 0; level < length; level++) + { + index = key.charAt(level) - 'a'; + + if (pCrawl.children[index] == null) + return false; + + pCrawl = pCrawl.children[index]; + } + + return (pCrawl != null && pCrawl.isEndOfWord); + } + + // Driver + public static void main(String args[]) + { + // Input keys (use only 'a' through 'z' and lower case) + String keys[] = {"the", "a", "there", "answer", "any", + "by", "bye", "their"}; + + String output[] = {"Not present in trie", "Present in trie"}; + + + root = new TrieNode(); + + // Construct trie + int i; + for (i = 0; i < keys.length ; i++) + insert(keys[i]); + + // Search for different keys + if(search("the") == true) + System.out.println("the --- " + output[1]); + else System.out.println("the --- " + output[0]); + + if(search("these") == true) + System.out.println("these --- " + output[1]); + else System.out.println("these --- " + output[0]); + + if(search("their") == true) + System.out.println("their --- " + output[1]); + else System.out.println("their --- " + output[0]); + + if(search("thaw") == true) + System.out.println("thaw --- " + output[1]); + else System.out.println("thaw --- " + output[0]); + + } +} \ No newline at end of file diff --git a/fonte/U9 - Árvores TRIE/java/trie/Principal.java b/fonte/U9 - Árvores TRIE/java/trie/Principal.java new file mode 100644 index 0000000..734cc83 --- /dev/null +++ b/fonte/U9 - Árvores TRIE/java/trie/Principal.java @@ -0,0 +1,37 @@ +class Principal { + public static void main (String[] args) throws Exception { + ArvoreTrie arv = new ArvoreTrie(); + + String array[] = new String[8]; + array[0] = "ABACAXI"; + array[1] = "BALA"; + array[2] = "BOLO"; + array[3] = "ABACATE"; + array[4] = "galo"; + array[5] = "pata"; + array[6] = "pato"; + array[7] = "gato"; + + for(int i = 0; i < array.length; i++){ + arv.inserir(array[i]); + } + arv.mostrar(); + for(int i = 0; i < array.length; i++){ + System.out.println("Pesquisar(" + array[i] + "):" + arv.pesquisar(array[i])); + System.out.println("PesquisarI(" + array[i] + "):" + arv.pesquisarI(array[i])); + } + + String s = "ABACA"; + System.out.println("Pesquisar(" + s + "):" + arv.pesquisar(s)); + System.out.println("PesquisarI(" + s + "):" + arv.pesquisarI(s)); + + s = "ABACAXIS"; + System.out.println("Pesquisar(" + s + "):" + arv.pesquisar(s)); + System.out.println("PesquisarI(" + s + "):" + arv.pesquisarI(s)); + + s = "gaga"; + System.out.println("Pesquisar(" + s + "):" + arv.pesquisar(s)); + System.out.println("PesquisarI(" + s + "):" + arv.pesquisarI(s)); + + } +} diff --git a/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieAB/ArvoreTrie.java b/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieAB/ArvoreTrie.java new file mode 100644 index 0000000..0527cbd --- /dev/null +++ b/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieAB/ArvoreTrie.java @@ -0,0 +1,71 @@ +class ArvoreTrie { + private No raiz; + + public ArvoreTrie(){ + raiz = new No(); + } + + public void inserir(String s) throws Exception { + inserir(s, raiz, 0); + } + + private void inserir(String s, No no, int i) throws Exception { + System.out.print("\nEM NO(" + no.elemento + ") (" + i + ")"); + No filho = no.pesquisar(s.charAt(i)); + if(filho == null){ + System.out.print("--> criando filho(" + s.charAt(i) + ")"); + filho = no.inserir(s.charAt(i)); + + if(i == s.length() - 1){ + System.out.print("(folha)"); + no.setFilhoFolha(s.charAt(i)); + }else{ + inserir(s, filho, i + 1); + } + + } else if (filho.folha == false && i < s.length() - 1){ + inserir(s, filho, i + 1); + + } else { + throw new Exception("Erro ao inserir!"); + } + } + + + public boolean pesquisar(String s) throws Exception { + return pesquisar(s, raiz, 0); + } + + public boolean pesquisar(String s, No no, int i) throws Exception { + boolean resp; + No filho = no.pesquisar(s.charAt(i)); + if(filho == null){ + resp = false; + } else if(i == s.length() - 1){ + resp = (filho.folha == true); + } else if(i < s.length() - 1 ){ + resp = pesquisar(s, filho, i + 1); + } else { + throw new Exception("Erro ao pesquisar!"); + } + return resp; + } + + + public void mostrar(){ + mostrar("", raiz); + } + + public void mostrar(String s, No no) { + if(no.folha == true){ + System.out.println("Palavra: " + (s + no.elemento)); + } else { + No[] filho = no.getFilho(); + for(int i = 0; i < filho.length; i++){ + System.out.println("ESTOU EM (" + no.elemento + ") E VOU PARA (" + filho[i].elemento + ")"); + mostrar(s + no.elemento, filho[i]); + } + } + } +} + diff --git a/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieAB/No.java b/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieAB/No.java new file mode 100644 index 0000000..b332e7b --- /dev/null +++ b/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieAB/No.java @@ -0,0 +1,103 @@ +class No { + public char elemento; + private NoAB raiz; + public boolean folha; + + public No (){ + this(' '); + } + + public No (char elemento){ + this.elemento = elemento; + raiz = null; + folha = false; + } + + public No inserir(char x) throws Exception { + raiz = inserir(x, raiz); + return pesquisar(x); + } + + private NoAB inserir(char x, NoAB i) throws Exception { + if (i == null) { + i = new NoAB(x); + + } else if (x < i.elemento) { + i.esq = inserir(x, i.esq); + + } else if (x > i.elemento) { + i.dir = inserir(x, i.dir); + + } else { + throw new Exception("Erro ao inserir!"); + } + + return i; + } + + public No pesquisar(char x) { + return pesquisar(x, raiz); + } + + private No pesquisar(int x, NoAB i) { + No resp; + if (i == null) { + resp = null; + + } else if (x == i.elemento) { + resp = i.no; + + } else if (x < i.elemento) { + resp = pesquisar(x, i.esq); + + } else { + resp = pesquisar(x, i.dir); + } + return resp; + } + + public void setFilhoFolha(char x){ + setFilhoFolha(x, raiz); + } + public void setFilhoFolha(char x, NoAB i){ + if (i == null) { + //nada... + + } else if (x == i.elemento) { + i.no.folha = true; + + } else if (x < i.elemento) { + setFilhoFolha(x, i.esq); + + } else { + setFilhoFolha(x, i.dir); + } + } + + public int getN() { + return getN(raiz); + } + private int getN(NoAB i) { + int resp = 0; + if (i != null) { + resp = 1 + getN(i.esq) + getN(i.dir); + } + return resp; + } + + public No[] getFilho(){ + int n = getN(); + No[] vet = new No[n]; + getFilho(vet, 0, raiz); + return vet; + } + + public int getFilho(No[] vet, int pos, NoAB i){ + if(i != null){ + vet[pos++] = i.no; + pos = getFilho(vet, pos, i.esq); + pos = getFilho(vet, pos, i.dir); + } + return pos; + } +} diff --git a/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieAB/NoAB.java b/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieAB/NoAB.java new file mode 100644 index 0000000..8945997 --- /dev/null +++ b/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieAB/NoAB.java @@ -0,0 +1,27 @@ +class NoAB { + public char elemento; + public NoAB esq, dir; + public No no; + + + /** + * Construtor da classe. + */ + public NoAB() { + this.elemento = 0; + this.esq = null; + this.dir = null; + this.no = null; + } + + /** + * Construtor da classe. + * @param elemento char inserido na celula. + */ + public NoAB(char elemento) { + this.elemento = elemento; + this.esq = null; + this.dir = null; + this.no = new No(elemento); + } +} diff --git a/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieAB/Principal.java b/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieAB/Principal.java new file mode 100644 index 0000000..6944759 --- /dev/null +++ b/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieAB/Principal.java @@ -0,0 +1,34 @@ +class Principal { + public static void main (String[] args) throws Exception { + ArvoreTrie arv = new ArvoreTrie(); + + String array[] = new String[8]; + array[0] = "ABACAXI"; + array[1] = "BALA"; + array[2] = "BOLO"; + array[3] = "ABACATE"; + array[4] = "galo"; + array[5] = "pata"; + array[6] = "pato"; + array[7] = "gato"; + + for(int i = 0; i < array.length; i++){ + arv.inserir(array[i]); + } + + arv.mostrar(); + for(int i = 0; i < array.length; i++){ + System.out.println("Pesquisar(" + array[i] + "):" + arv.pesquisar(array[i])); + } + + String s = "ABACA"; + System.out.println("Pesquisar(" + s + "):" + arv.pesquisar(s)); + + s = "ABACAXIS"; + System.out.println("Pesquisar(" + s + "):" + arv.pesquisar(s)); + + s = "gaga"; + System.out.println("Pesquisar(" + s + "):" + arv.pesquisar(s)); + + } +} diff --git a/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieAB/oi b/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieAB/oi new file mode 100644 index 0000000..7204d70 --- /dev/null +++ b/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieAB/oi @@ -0,0 +1,84 @@ + +EM NO( ) (0)--> criando filho(A) +EM NO(A) (1)--> criando filho(B) +EM NO(B) (2)--> criando filho(A) +EM NO(A) (3)--> criando filho(C) +EM NO(C) (4)--> criando filho(A) +EM NO(A) (5)--> criando filho(X) +EM NO(X) (6)--> criando filho(I)(folha) +EM NO( ) (0)--> criando filho(B) +EM NO(B) (1)--> criando filho(A) +EM NO(A) (2)--> criando filho(L) +EM NO(L) (3)--> criando filho(A)(folha) +EM NO( ) (0) +EM NO(B) (1)--> criando filho(O) +EM NO(O) (2)--> criando filho(L) +EM NO(L) (3)--> criando filho(O)(folha) +EM NO( ) (0) +EM NO(A) (1) +EM NO(B) (2) +EM NO(A) (3) +EM NO(C) (4) +EM NO(A) (5)--> criando filho(T) +EM NO(T) (6)--> criando filho(E)(folha) +EM NO( ) (0)--> criando filho(g) +EM NO(g) (1)--> criando filho(a) +EM NO(a) (2)--> criando filho(l) +EM NO(l) (3)--> criando filho(o)(folha) +EM NO( ) (0)--> criando filho(p) +EM NO(p) (1)--> criando filho(a) +EM NO(a) (2)--> criando filho(t) +EM NO(t) (3)--> criando filho(a)(folha) +EM NO( ) (0) +EM NO(p) (1) +EM NO(a) (2) +EM NO(t) (3)--> criando filho(o)(folha) +EM NO( ) (0) +EM NO(g) (1) +EM NO(a) (2)--> criando filho(t) +EM NO(t) (3)--> criando filho(o)(folha)ESTOU EM ( ) E VOU PARA (A) +ESTOU EM (A) E VOU PARA (B) +ESTOU EM (B) E VOU PARA (A) +ESTOU EM (A) E VOU PARA (C) +ESTOU EM (C) E VOU PARA (A) +ESTOU EM (A) E VOU PARA (X) +ESTOU EM (X) E VOU PARA (I) +Palavra: ABACAXI +ESTOU EM (A) E VOU PARA (T) +ESTOU EM (T) E VOU PARA (E) +Palavra: ABACATE +ESTOU EM ( ) E VOU PARA (B) +ESTOU EM (B) E VOU PARA (A) +ESTOU EM (A) E VOU PARA (L) +ESTOU EM (L) E VOU PARA (A) +Palavra: BALA +ESTOU EM (B) E VOU PARA (O) +ESTOU EM (O) E VOU PARA (L) +ESTOU EM (L) E VOU PARA (O) +Palavra: BOLO +ESTOU EM ( ) E VOU PARA (g) +ESTOU EM (g) E VOU PARA (a) +ESTOU EM (a) E VOU PARA (l) +ESTOU EM (l) E VOU PARA (o) +Palavra: galo +ESTOU EM (a) E VOU PARA (t) +ESTOU EM (t) E VOU PARA (o) +Palavra: gato +ESTOU EM ( ) E VOU PARA (p) +ESTOU EM (p) E VOU PARA (a) +ESTOU EM (a) E VOU PARA (t) +ESTOU EM (t) E VOU PARA (a) +Palavra: pata +ESTOU EM (t) E VOU PARA (o) +Palavra: pato +Pesquisar(ABACAXI):true +Pesquisar(BALA):true +Pesquisar(BOLO):true +Pesquisar(ABACATE):true +Pesquisar(galo):true +Pesquisar(pata):true +Pesquisar(pato):true +Pesquisar(gato):true +Pesquisar(ABACA):false +Pesquisar(ABACAXIS):false +Pesquisar(gaga):false diff --git a/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieHashAceitandoPrexixo/ArvoreTrie.java b/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieHashAceitandoPrexixo/ArvoreTrie.java new file mode 100644 index 0000000..0e1e3e7 --- /dev/null +++ b/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieHashAceitandoPrexixo/ArvoreTrie.java @@ -0,0 +1,72 @@ +class ArvoreTrie { + private No raiz; + + public ArvoreTrie(){ + raiz = new No(); + } + + public void inserir(String s) throws Exception { + inserir(s, raiz, 0); + } + + private void inserir(String s, No no, int i) throws Exception { + System.out.print("\nEM NO(" + no.elemento + ") (" + i + ")"); + if(no.prox[s.charAt(i)] == null){ + System.out.print("--> criando filho(" + s.charAt(i) + ")"); + no.prox[s.charAt(i)] = new No(s.charAt(i)); + + if(i == s.length() - 1){ + System.out.print("(folha)"); + no.prox[s.charAt(i)].folha = true; + }else{ + inserir(s, no.prox[s.charAt(i)], i + 1); + } + + } else if (i < s.length() - 1){ + inserir(s, no.prox[s.charAt(i)], i + 1); + + } else if(i == s.length() - 1){ + System.out.print("(folha)"); + no.prox[s.charAt(i)].folha = true; + } + } + + + public boolean pesquisar(String s) throws Exception { + return pesquisar(s, raiz, 0); + } + + public boolean pesquisar(String s, No no, int i) throws Exception { + boolean resp; + if(no.prox[s.charAt(i)] == null){ + resp = false; + } else if(i == s.length() - 1){ + resp = (no.prox[s.charAt(i)].folha == true); + } else if(i < s.length() - 1 ){ + resp = pesquisar(s, no.prox[s.charAt(i)], i + 1); + } else { + throw new Exception("Erro ao pesquisar!"); + } + return resp; + } + + + public void mostrar(){ + mostrar("", raiz); + } + + public void mostrar(String s, No no) { + if(no.folha == true){ + System.out.println("Palavra: " + (s + no.elemento)); + } + + for(int i = 0; i < no.prox.length; i++){ + if(no.prox[i] != null){ + System.out.println("ESTOU EM (" + no.elemento + ") E VOU PARA (" + no.prox[i].elemento + ")"); + mostrar(s + no.elemento, no.prox[i]); + } + } + + } +} + diff --git a/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieHashAceitandoPrexixo/No.java b/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieHashAceitandoPrexixo/No.java new file mode 100644 index 0000000..d36263c --- /dev/null +++ b/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieHashAceitandoPrexixo/No.java @@ -0,0 +1,21 @@ +class No { + public char elemento; + public int tamanho = 255; + public No[] prox; + public boolean folha; + + public No (){ + this(' '); + } + + public No (char elemento){ + this.elemento = elemento; + prox = new No [tamanho]; + for (int i = 0; i < tamanho; i++) prox[i] = null; + folha = false; + } + + public static int hash (char x){ + return (int)x; + } +} diff --git a/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieHashAceitandoPrexixo/Principal.java b/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieHashAceitandoPrexixo/Principal.java new file mode 100644 index 0000000..6541d76 --- /dev/null +++ b/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieHashAceitandoPrexixo/Principal.java @@ -0,0 +1,36 @@ +class Principal { + public static void main (String[] args) throws Exception { + ArvoreTrie arv = new ArvoreTrie(); + + String array[] = new String[11]; + array[0] = "ABACAXI"; + array[1] = "BALA"; + array[2] = "BOLO"; + array[3] = "ABACATE"; + array[4] = "galo"; + array[5] = "pata"; + array[6] = "pato"; + array[7] = "gato"; + array[8] = "BAL"; + array[9] = "BA"; + array[10] = "BALAS"; + + for(int i = 0; i < array.length; i++){ + arv.inserir(array[i]); + } + arv.mostrar(); + for(int i = 0; i < array.length; i++){ + System.out.println("Pesquisar(" + array[i] + "):" + arv.pesquisar(array[i])); + } + + String s = "ABACA"; + System.out.println("Pesquisar(" + s + "):" + arv.pesquisar(s)); + + s = "ABACAXIS"; + System.out.println("Pesquisar(" + s + "):" + arv.pesquisar(s)); + + s = "gaga"; + System.out.println("Pesquisar(" + s + "):" + arv.pesquisar(s)); + + } +} diff --git a/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieListaFlexivel/ArvoreTrie.java b/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieListaFlexivel/ArvoreTrie.java new file mode 100644 index 0000000..0527cbd --- /dev/null +++ b/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieListaFlexivel/ArvoreTrie.java @@ -0,0 +1,71 @@ +class ArvoreTrie { + private No raiz; + + public ArvoreTrie(){ + raiz = new No(); + } + + public void inserir(String s) throws Exception { + inserir(s, raiz, 0); + } + + private void inserir(String s, No no, int i) throws Exception { + System.out.print("\nEM NO(" + no.elemento + ") (" + i + ")"); + No filho = no.pesquisar(s.charAt(i)); + if(filho == null){ + System.out.print("--> criando filho(" + s.charAt(i) + ")"); + filho = no.inserir(s.charAt(i)); + + if(i == s.length() - 1){ + System.out.print("(folha)"); + no.setFilhoFolha(s.charAt(i)); + }else{ + inserir(s, filho, i + 1); + } + + } else if (filho.folha == false && i < s.length() - 1){ + inserir(s, filho, i + 1); + + } else { + throw new Exception("Erro ao inserir!"); + } + } + + + public boolean pesquisar(String s) throws Exception { + return pesquisar(s, raiz, 0); + } + + public boolean pesquisar(String s, No no, int i) throws Exception { + boolean resp; + No filho = no.pesquisar(s.charAt(i)); + if(filho == null){ + resp = false; + } else if(i == s.length() - 1){ + resp = (filho.folha == true); + } else if(i < s.length() - 1 ){ + resp = pesquisar(s, filho, i + 1); + } else { + throw new Exception("Erro ao pesquisar!"); + } + return resp; + } + + + public void mostrar(){ + mostrar("", raiz); + } + + public void mostrar(String s, No no) { + if(no.folha == true){ + System.out.println("Palavra: " + (s + no.elemento)); + } else { + No[] filho = no.getFilho(); + for(int i = 0; i < filho.length; i++){ + System.out.println("ESTOU EM (" + no.elemento + ") E VOU PARA (" + filho[i].elemento + ")"); + mostrar(s + no.elemento, filho[i]); + } + } + } +} + diff --git a/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieListaFlexivel/Celula.java b/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieListaFlexivel/Celula.java new file mode 100644 index 0000000..23f6612 --- /dev/null +++ b/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieListaFlexivel/Celula.java @@ -0,0 +1,30 @@ +/** + * Celula (pilha, lista e fila dinamica) + * @author Max do Val Machado + * @version 2 01/2015 + */ +class Celula { + public char elemento; // Elemento inserido na celula. + public Celula prox; // Aponta a celula prox. + public No no; + + + /** + * Construtor da classe. + */ + public Celula() { + this.elemento = 0; + this.prox = null; + this.no = null; + } + + /** + * Construtor da classe. + * @param elemento char inserido na celula. + */ + public Celula(char elemento) { + this.elemento = elemento; + this.prox = null; + this.no = new No(elemento); + } +} diff --git a/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieListaFlexivel/No.java b/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieListaFlexivel/No.java new file mode 100644 index 0000000..50204fd --- /dev/null +++ b/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieListaFlexivel/No.java @@ -0,0 +1,63 @@ +class No { + public char elemento; + private Celula primeiro; + private Celula ultimo; + public boolean folha; + + public No (){ + this(' '); + } + + public No (char elemento){ + this.elemento = elemento; + ultimo = primeiro = new Celula(); + folha = false; + } + + public No inserir(char x){ + ultimo.prox = new Celula(x); + ultimo = ultimo.prox; + return ultimo.no; + } + + public No pesquisar(char x){ + No resp = null; + for (Celula i = primeiro.prox; i != null; i = i.prox) { + if(i.elemento == x){ + resp = i.no; + i = ultimo; + } + } + return resp; + } + + public void setFilhoFolha(char x){ + for (Celula i = primeiro.prox; i != null; i = i.prox) { + if(i.elemento == x){ + i.no.folha = true; + i = ultimo; + } + } + } + + public No[] getFilho(){ + int n = 0; + for (Celula i = primeiro.prox; i != null; i = i.prox, n++); + No[] vet = new No[n]; + + n = 0; + for (Celula i = primeiro.prox; i != null; i = i.prox){ + vet[n++] = i.no; + } + + return vet; + } + + public void mostrar() { + System.out.print("[ "); + for (Celula i = primeiro.prox; i != null; i = i.prox) { + System.out.print(i.elemento + " "); + } + System.out.println("] "); + } +} diff --git a/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieListaFlexivel/Principal.java b/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieListaFlexivel/Principal.java new file mode 100644 index 0000000..6944759 --- /dev/null +++ b/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieListaFlexivel/Principal.java @@ -0,0 +1,34 @@ +class Principal { + public static void main (String[] args) throws Exception { + ArvoreTrie arv = new ArvoreTrie(); + + String array[] = new String[8]; + array[0] = "ABACAXI"; + array[1] = "BALA"; + array[2] = "BOLO"; + array[3] = "ABACATE"; + array[4] = "galo"; + array[5] = "pata"; + array[6] = "pato"; + array[7] = "gato"; + + for(int i = 0; i < array.length; i++){ + arv.inserir(array[i]); + } + + arv.mostrar(); + for(int i = 0; i < array.length; i++){ + System.out.println("Pesquisar(" + array[i] + "):" + arv.pesquisar(array[i])); + } + + String s = "ABACA"; + System.out.println("Pesquisar(" + s + "):" + arv.pesquisar(s)); + + s = "ABACAXIS"; + System.out.println("Pesquisar(" + s + "):" + arv.pesquisar(s)); + + s = "gaga"; + System.out.println("Pesquisar(" + s + "):" + arv.pesquisar(s)); + + } +} diff --git a/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieListaFlexivel/oi b/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieListaFlexivel/oi new file mode 100644 index 0000000..7204d70 --- /dev/null +++ b/fonte/U9 - Árvores TRIE/java/trieVariacoes/trieListaFlexivel/oi @@ -0,0 +1,84 @@ + +EM NO( ) (0)--> criando filho(A) +EM NO(A) (1)--> criando filho(B) +EM NO(B) (2)--> criando filho(A) +EM NO(A) (3)--> criando filho(C) +EM NO(C) (4)--> criando filho(A) +EM NO(A) (5)--> criando filho(X) +EM NO(X) (6)--> criando filho(I)(folha) +EM NO( ) (0)--> criando filho(B) +EM NO(B) (1)--> criando filho(A) +EM NO(A) (2)--> criando filho(L) +EM NO(L) (3)--> criando filho(A)(folha) +EM NO( ) (0) +EM NO(B) (1)--> criando filho(O) +EM NO(O) (2)--> criando filho(L) +EM NO(L) (3)--> criando filho(O)(folha) +EM NO( ) (0) +EM NO(A) (1) +EM NO(B) (2) +EM NO(A) (3) +EM NO(C) (4) +EM NO(A) (5)--> criando filho(T) +EM NO(T) (6)--> criando filho(E)(folha) +EM NO( ) (0)--> criando filho(g) +EM NO(g) (1)--> criando filho(a) +EM NO(a) (2)--> criando filho(l) +EM NO(l) (3)--> criando filho(o)(folha) +EM NO( ) (0)--> criando filho(p) +EM NO(p) (1)--> criando filho(a) +EM NO(a) (2)--> criando filho(t) +EM NO(t) (3)--> criando filho(a)(folha) +EM NO( ) (0) +EM NO(p) (1) +EM NO(a) (2) +EM NO(t) (3)--> criando filho(o)(folha) +EM NO( ) (0) +EM NO(g) (1) +EM NO(a) (2)--> criando filho(t) +EM NO(t) (3)--> criando filho(o)(folha)ESTOU EM ( ) E VOU PARA (A) +ESTOU EM (A) E VOU PARA (B) +ESTOU EM (B) E VOU PARA (A) +ESTOU EM (A) E VOU PARA (C) +ESTOU EM (C) E VOU PARA (A) +ESTOU EM (A) E VOU PARA (X) +ESTOU EM (X) E VOU PARA (I) +Palavra: ABACAXI +ESTOU EM (A) E VOU PARA (T) +ESTOU EM (T) E VOU PARA (E) +Palavra: ABACATE +ESTOU EM ( ) E VOU PARA (B) +ESTOU EM (B) E VOU PARA (A) +ESTOU EM (A) E VOU PARA (L) +ESTOU EM (L) E VOU PARA (A) +Palavra: BALA +ESTOU EM (B) E VOU PARA (O) +ESTOU EM (O) E VOU PARA (L) +ESTOU EM (L) E VOU PARA (O) +Palavra: BOLO +ESTOU EM ( ) E VOU PARA (g) +ESTOU EM (g) E VOU PARA (a) +ESTOU EM (a) E VOU PARA (l) +ESTOU EM (l) E VOU PARA (o) +Palavra: galo +ESTOU EM (a) E VOU PARA (t) +ESTOU EM (t) E VOU PARA (o) +Palavra: gato +ESTOU EM ( ) E VOU PARA (p) +ESTOU EM (p) E VOU PARA (a) +ESTOU EM (a) E VOU PARA (t) +ESTOU EM (t) E VOU PARA (a) +Palavra: pata +ESTOU EM (t) E VOU PARA (o) +Palavra: pato +Pesquisar(ABACAXI):true +Pesquisar(BALA):true +Pesquisar(BOLO):true +Pesquisar(ABACATE):true +Pesquisar(galo):true +Pesquisar(pata):true +Pesquisar(pato):true +Pesquisar(gato):true +Pesquisar(ABACA):false +Pesquisar(ABACAXIS):false +Pesquisar(gaga):false