diff --git a/UNP/ref/Java/#ED2-Java-BKP/ED1/Arrays/EntradaJogo.java b/UNP/ref/Java/#ED2-Java-BKP/ED1/Arrays/EntradaJogo.java new file mode 100644 index 0000000..c3383ec --- /dev/null +++ b/UNP/ref/Java/#ED2-Java-BKP/ED1/Arrays/EntradaJogo.java @@ -0,0 +1,24 @@ +package ED1.Arrays; + +public class EntradaJogo { + protected String nome; + protected int score; + + public EntradaJogo(String nome, int score) { + this.nome = nome; + this.score = score; + } + + public String getNome() { + return nome; + } + + public int getScore() { + return score; + } + + public String toString(){ + return "[" + this.nome + " - " + this.score + "]"; + } + +} diff --git a/UNP/ref/Java/#ED2-Java-BKP/ED1/Arrays/Scores.java b/UNP/ref/Java/#ED2-Java-BKP/ED1/Arrays/Scores.java new file mode 100644 index 0000000..751d8a4 --- /dev/null +++ b/UNP/ref/Java/#ED2-Java-BKP/ED1/Arrays/Scores.java @@ -0,0 +1,23 @@ +package ED1.Arrays; + +public class Scores { + + public static final int maximoEntradas = 10; //quantidade de escores que serão armazenados + protected int numEntradas; //número real de registros + protected EntradaJogo[] placares; + + public Scores() { + placares = new EntradaJogo[maximoEntradas]; + numEntradas = 0; + } + public String toString(){ + StringBuilder s = new StringBuilder("["); + for (int i = 0; i < numEntradas; i++) { + if(i>0) s.append(", "); + s.append(placares[i]); + } + return s + "]"; + } + + +} diff --git a/UNP/ref/Java/#ED2-Java-BKP/ED1/Arrays/TabelaScores.java b/UNP/ref/Java/#ED2-Java-BKP/ED1/Arrays/TabelaScores.java new file mode 100644 index 0000000..843b00e --- /dev/null +++ b/UNP/ref/Java/#ED2-Java-BKP/ED1/Arrays/TabelaScores.java @@ -0,0 +1,57 @@ +package ED1.Arrays; + +public class TabelaScores { + + + private int numEntries = 0; + + private EntradaJogo[] board; //array of game entries(names & scores) + + public TabelaScores(int capacity){ + this.board = new EntradaJogo[capacity]; + } + + public void add(EntradaJogo e){ + int newScore = e.getScore(); + + if(numEntries < board.length || newScore > board[numEntries-1].getScore()){ + if(numEntries < board.length) // no score drops from the board + numEntries++; //so overall number increases + } + + int j = numEntries - 1; + while(j > 0 && board[j-1].getScore() < newScore){ + board[j] = board[j-1]; //shift entry from j-1 to j + j -- ; //decrement + } + + board[j] = e; //when done add new entry + } + + public EntradaJogo remove(int i) throws IndexOutOfBoundsException{ + if (i < 0 || i >= numEntries){ // If index is less than 0 or index is greater than or equal than numEntries + throw new IndexOutOfBoundsException("invalid index:" + i); // throw index out of bound exception + + } + EntradaJogo temp = board[i]; // create temp variable to return + + for(int j = i; j < numEntries - 1; j++){ //for-loop through + board[j] = board[j+1]; + board[numEntries - 1 ] = null; + numEntries--; + + } + return temp; + } + + public String toString(){ + StringBuilder s = new StringBuilder("["); + for (int i = 0; i < numEntries; i++) { + if(i>0) s.append(", \n"); + s.append(board[i]); + } + return s + "]"; + } + + +} diff --git a/UNP/ref/Java/#ED2-Java-BKP/ED1/Arrays/TestaTabelaScores.java b/UNP/ref/Java/#ED2-Java-BKP/ED1/Arrays/TestaTabelaScores.java new file mode 100644 index 0000000..63711d7 --- /dev/null +++ b/UNP/ref/Java/#ED2-Java-BKP/ED1/Arrays/TestaTabelaScores.java @@ -0,0 +1,25 @@ +package ED1.Arrays; + +public class TestaTabelaScores { + public static void main(String[] args) { + TabelaScores tabela = new TabelaScores(10); + tabela.add(new EntradaJogo("Joeliton", 100)); + tabela.add(new EntradaJogo("Mariana", 200)); + tabela.add(new EntradaJogo("Joseph", 300)); + tabela.add(new EntradaJogo("Pietro", 400)); + tabela.add(new EntradaJogo("Alice", 500)); + tabela.add(new EntradaJogo("João", 600)); + tabela.add(new EntradaJogo("Maria", 700)); + tabela.add(new EntradaJogo("Jose", 800)); + tabela.add(new EntradaJogo("Pedro", 900)); + tabela.add(new EntradaJogo("Ana", 1000)); + tabela.add(new EntradaJogo("Carlos", 1100)); + System.out.println("Placares do jogo\n============================"); + System.out.println(tabela); + tabela.remove(7); + System.out.println("Placares do jogo\n============================"); + System.out.println(tabela); + + + } +} diff --git a/UNP/ref/Java/#ED2-Java-BKP/EstruturasBasicas/EncadeadaPrimeiro/Lista.java b/UNP/ref/Java/#ED2-Java-BKP/EstruturasBasicas/EncadeadaPrimeiro/Lista.java new file mode 100644 index 0000000..e94ea76 --- /dev/null +++ b/UNP/ref/Java/#ED2-Java-BKP/EstruturasBasicas/EncadeadaPrimeiro/Lista.java @@ -0,0 +1,38 @@ +package EstruturasBasicas.EncadeadaPrimeiro; + +public class Lista { + No primeiro; + No ultimo; + int tamanho; + + public Lista() { + this.tamanho = 0; + } + + // Método para adicionar um elemento na lista + public void adicionar(String info) { + No novoNo = new No(); + novoNo.info = info; + novoNo.proximo = null; + + if (primeiro == null) { + primeiro = novoNo; + ultimo = novoNo; + } else { + ultimo.proximo = novoNo; + ultimo = novoNo; + } + + tamanho++; + } + + // Método para imprimir a lista + public void imprimir() { + No atual = primeiro; + + while (atual != null) { + System.out.println(atual.info); + atual = atual.proximo; + } + } +} diff --git a/UNP/ref/Java/#ED2-Java-BKP/EstruturasBasicas/EncadeadaPrimeiro/Main.java b/UNP/ref/Java/#ED2-Java-BKP/EstruturasBasicas/EncadeadaPrimeiro/Main.java new file mode 100644 index 0000000..366efd1 --- /dev/null +++ b/UNP/ref/Java/#ED2-Java-BKP/EstruturasBasicas/EncadeadaPrimeiro/Main.java @@ -0,0 +1,17 @@ +package EstruturasBasicas.EncadeadaPrimeiro; + +public class Main { + + public static void main(String[] args) { + Lista lista = new Lista(); + + // Adicionando elementos + lista.adicionar("Elemento 1"); + lista.adicionar("Elemento 2"); + lista.adicionar("Elemento 3"); + //lista.adicionar(2); + + // Imprimindo a lista + lista.imprimir(); + } +} diff --git a/UNP/ref/Java/#ED2-Java-BKP/EstruturasBasicas/EncadeadaPrimeiro/No.java b/UNP/ref/Java/#ED2-Java-BKP/EstruturasBasicas/EncadeadaPrimeiro/No.java new file mode 100644 index 0000000..77165df --- /dev/null +++ b/UNP/ref/Java/#ED2-Java-BKP/EstruturasBasicas/EncadeadaPrimeiro/No.java @@ -0,0 +1,6 @@ +package EstruturasBasicas.EncadeadaPrimeiro; + +public class No { + String info; + No proximo; +} diff --git a/UNP/ref/Java/#ED2-Java-BKP/EstruturasBasicas/Fila/FilaPrioridadeArray.java b/UNP/ref/Java/#ED2-Java-BKP/EstruturasBasicas/Fila/FilaPrioridadeArray.java index 6bb036d..3018d9d 100644 --- a/UNP/ref/Java/#ED2-Java-BKP/EstruturasBasicas/Fila/FilaPrioridadeArray.java +++ b/UNP/ref/Java/#ED2-Java-BKP/EstruturasBasicas/Fila/FilaPrioridadeArray.java @@ -153,5 +153,7 @@ public static void main(String[] args) throws Exception { pulaLinha(1); fila.imprime(); pulaLinha(1); + + } } diff --git a/UNP/ref/Java/#ED2-Java-BKP/EstruturasBasicas/ListasTiposGenericos/Lista.java b/UNP/ref/Java/#ED2-Java-BKP/EstruturasBasicas/ListasTiposGenericos/Lista.java index 611e7a6..6c7b60a 100644 --- a/UNP/ref/Java/#ED2-Java-BKP/EstruturasBasicas/ListasTiposGenericos/Lista.java +++ b/UNP/ref/Java/#ED2-Java-BKP/EstruturasBasicas/ListasTiposGenericos/Lista.java @@ -29,7 +29,6 @@ public void adicionar(T informacao) { public void imprimir() { imprimirNo(primeiro); } - private void imprimirNo(Celula celula) { if (celula != null) { System.out.println(""+celula.info); diff --git a/UNP/ref/Java/#ED2-Java-BKP/EstruturasBasicas/Pilha/PilhaLivroTeste.java b/UNP/ref/Java/#ED2-Java-BKP/EstruturasBasicas/Pilha/PilhaLivroTeste.java new file mode 100644 index 0000000..c013a65 --- /dev/null +++ b/UNP/ref/Java/#ED2-Java-BKP/EstruturasBasicas/Pilha/PilhaLivroTeste.java @@ -0,0 +1,62 @@ +package EstruturasBasicas.Pilha; + +import java.util.EmptyStackException; + +// Definição do TAD Pilha +public class PilhaLivroTeste { + private Celula top; + + // Definição da estrutura do nó da pilha + private static class Celula { + private T info; + private Celula proximo; + + public Celula(T info) { + this.info = info; + } + } + + // Operação para verificar se a pilha está vazia + public boolean estaVazia() { + return top == null; + } + + // Operação para adicionar um elemento no topo da pilha + public void push(T info) { + Celula novaCelula = new Celula(info); + novaCelula.proximo = top; + top = novaCelula; + } + + // Operação para remover e retornar o elemento no topo da pilha + public T pop() { + if (estaVazia()) { + throw new EmptyStackException(); + } + T info = top.info; + top = top.proximo; + return info; + } + + // Operação para consultar o elemento no topo da pilha + public T peek() { + if (estaVazia()) { + throw new EmptyStackException(); + } + return top.info; + } + + public static void main(String[] args) { + PilhaLivroTeste Pilha = new PilhaLivroTeste(); + + Pilha.push(3); + Pilha.push(5); + Pilha.push(7); + + System.out.println("Pilha: "); + while (!Pilha.estaVazia()) { + System.out.println(Pilha.pop()); + } + } +} + diff --git a/UNP/ref/Java/#ED2-Java-BKP/TestaTrabalhos/Testa.java b/UNP/ref/Java/#ED2-Java-BKP/TestaTrabalhos/Testa.java new file mode 100644 index 0000000..fc0c325 --- /dev/null +++ b/UNP/ref/Java/#ED2-Java-BKP/TestaTrabalhos/Testa.java @@ -0,0 +1,23 @@ +package TestaTrabalhos; + +public class Testa { + + public static double calculateSum(int n) { + + if (n == 1) { + return 1.0; + } else { + return calculateSum(n - 1) + 1.0 / n; + } + + } + + public static void main(String[] args) { + + int n = 5; // Change this value to the desired number of terms + double sum = calculateSum(n); + System.out.println("Sum of the series: " + sum); + } + + +} diff --git a/UNP/ref/Java/#ED2-Java-BKP/arvores/AVL/ArvoreAVL.java b/UNP/ref/Java/#ED2-Java-BKP/arvores/AVL/ArvoreAVL.java new file mode 100644 index 0000000..6eb5637 --- /dev/null +++ b/UNP/ref/Java/#ED2-Java-BKP/arvores/AVL/ArvoreAVL.java @@ -0,0 +1,160 @@ +package arvores.AVL; + +import arvores.ArvoreBinaria; + +public class ArvoreAVL { + private No raiz; + + public void inserir(int chave) { + raiz = inserirNo(raiz, chave); + } + + private No inserirNo(No no, int chave) { + if (no == null) { + return new No(chave); + } + + if (chave < no.chave) { + no.filhoEsquerda = inserirNo(no.filhoEsquerda, chave); + } else if (chave > no.chave) { + no.filhoDireita = inserirNo(no.filhoDireita, chave); + } else { + // Duplicatas não são permitidas (você pode personalizar isso conforme necessário) + return no; + } + + atualizarAltura(no); + int fatorBalanceamento = calcularFatorBalanceamento(no); + + if (fatorBalanceamento > 1) { + if (chave < no.filhoEsquerda.chave) { + return rotacaoDireita(no); + } + + if (chave > no.filhoEsquerda.chave) { + no.filhoEsquerda = rotacaoEsquerda(no.filhoEsquerda); + return rotacaoDireita(no); + } + } + + if (fatorBalanceamento < -1) { + if (chave > no.filhoDireita.chave) { + return rotacaoEsquerda(no); + } + + if (chave < no.filhoDireita.chave) { + no.filhoDireita = rotacaoDireita(no.filhoDireita); + return rotacaoEsquerda(no); + } + } + + return no; + } + + // Implementação das funções de rotação aqui + private int altura(No no) { + if (no != null) { + return no.altura; + } else { + return 0; + } + } + + private int calcularFatorBalanceamento(No no) { + if (no != null) { + return altura(no.filhoEsquerda) - altura(no.filhoDireita); + } else { + return 0; + } + } + + private void atualizarAltura(No no) { + if (no != null) { + no.altura = 1 + Math.max(altura(no.filhoEsquerda), altura(no.filhoDireita)); + } + } + + private No rotacaoEsquerda(No pai) { + No filho = pai.filhoDireita; + No T2 = filho.filhoEsquerda; + + filho.filhoEsquerda = pai; + pai.filhoDireita = T2; + + atualizarAltura(pai); + atualizarAltura(filho); + + return filho; + } + + private No rotacaoDireita(No pai) { + No filho = pai.filhoEsquerda; + No T2 = filho.filhoDireita; + + filho.filhoDireita = pai; + pai.filhoEsquerda = T2; + + atualizarAltura(pai); + atualizarAltura(filho); + + return filho; + } + + private No rotacaoEsquerdaDireita(No z) { + z.filhoEsquerda = rotacaoEsquerda(z.filhoEsquerda); + return rotacaoDireita(z); + } + + private No rotacaoDireitaEsquerda(No z) { + z.filhoDireita = rotacaoDireita(z.filhoDireita); + return rotacaoEsquerda(z); + } + + public void printArvoreAVL() { + printArvoreAVL(raiz, 0); + } + + private void printArvoreAVL(No no, int level) { + if (no == null) { + return; + } + + printArvoreAVL(no.filhoDireita, level + 1); + + for (int i = 0; i < level; i++) { + System.out.print(" "); + } + + System.out.println(no.chave); + + printArvoreAVL(no.filhoEsquerda, level + 1); + } + + public static void main(String[] args) { + ArvoreAVL arvore = new ArvoreAVL(); + ArvoreBinaria binaria = new ArvoreBinaria(); +/* + arvore.inserir(5); + arvore.inserir(4); + arvore.inserir(3);*/ + System.out.println("Binária: "); + binaria.inserir(1); + binaria.inserir(2); + binaria.inserir(4); + binaria.inserir(3); + binaria.inserir(6); + binaria.inserir(8); + binaria.imprimeArvore(); + System.out.println(); + System.out.println("AVL"); + /* arvore.inserir(1); + arvore.inserir(2);*/ + arvore.inserir(1); + arvore.inserir(2); + arvore.inserir(4); + arvore.inserir(3); + arvore.inserir(6); + arvore.inserir(8); + arvore.printArvoreAVL(); + } +} diff --git a/UNP/ref/Java/#ED2-Java-BKP/arvores/AVL/No.java b/UNP/ref/Java/#ED2-Java-BKP/arvores/AVL/No.java new file mode 100644 index 0000000..7c2eec3 --- /dev/null +++ b/UNP/ref/Java/#ED2-Java-BKP/arvores/AVL/No.java @@ -0,0 +1,15 @@ +package arvores.AVL; + +class No { + int chave; + No filhoEsquerda; + No filhoDireita; + int altura; + + public No(int chave) { + this.chave = chave; + this.filhoEsquerda = null; + this.filhoDireita = null; + this.altura = 1; + } +} diff --git a/UNP/ref/Java/#ED2-Java-BKP/arvores/ArvoreBinaria.java b/UNP/ref/Java/#ED2-Java-BKP/arvores/ArvoreBinaria.java index d9717af..875bd4d 100644 --- a/UNP/ref/Java/#ED2-Java-BKP/arvores/ArvoreBinaria.java +++ b/UNP/ref/Java/#ED2-Java-BKP/arvores/ArvoreBinaria.java @@ -1,5 +1,8 @@ package arvores; +import java.util.LinkedList; +import java.util.Queue; + public class ArvoreBinaria { //Arvore Binária usando a classe Node como base Node raiz; @@ -9,13 +12,16 @@ public ArvoreBinaria() { } public void inserir(Object data) { + raiz = inserir(raiz, data); } - private Node inserir(Node raiz, Object data) { - if (raiz == null) { + private > Node inserir(Node raiz, Object data) { + //if (raiz == null) { + if (arvoreVazia(raiz)) { raiz = new Node(data); - } else if ((Integer)data < (Integer)raiz.data) { + // } else if ((Integer)data < (Integer)raiz.data) { + } else if (raiz.data.toString().compareTo(data.toString()) > 0) { raiz.esquerda = inserir(raiz.esquerda, data); } else { raiz.direita = inserir(raiz.direita, data); @@ -23,15 +29,102 @@ private Node inserir(Node raiz, Object data) { return raiz; } - public void exibir() { - exibir(raiz); + boolean arvoreVazia(Node t){ + return t == null; + } + + + public void remover(Object data) { + raiz = remover(raiz, data); + } + + private > Node remover(Node raiz, Object data) { + if (arvoreVazia(raiz)) { + return null; //não tem filhos + } else if (raiz.data.toString().compareTo(data.toString()) > 0) { + raiz.esquerda = remover(raiz.esquerda, data); //não tem filhos a esquerda + } else if (raiz.data.toString().compareTo(data.toString()) < 0) { + raiz.direita = remover(raiz.direita, data); //não tem filhos a direita + } else { + if (raiz.esquerda == null) { + return raiz.direita; + } else if (raiz.direita == null) { + return raiz.esquerda; + } + raiz.data = menor(raiz.direita); + raiz.direita = remover(raiz.direita, raiz.data); + } + return raiz; + } + + + private > Object menor(Node raiz) { + if (raiz.esquerda == null) { + return raiz.data; + } + return menor(raiz.esquerda); + } + + + public void exibirEmOrdem() { + exibirEmOrdem(raiz); + } + + private void exibirEmOrdem(Node raiz) { + if (raiz != null) { + exibirEmOrdem(raiz.esquerda); + System.out.println(raiz.data); + exibirEmOrdem(raiz.direita); + } + } + + public void exibirPreOrdem() { + exibirPreOrdem(raiz); + } + + private void exibirPreOrdem(Node raiz) { + if (raiz != null) { + System.out.println(raiz.data); + exibirPreOrdem(raiz.esquerda); + exibirPreOrdem(raiz.direita); + } + } + + //exibe em pós ordem + + public void exibirPosOrdem() { + exibirPosOrdem(raiz); } - private void exibir(Node raiz) { + private void exibirPosOrdem(Node raiz) { if (raiz != null) { - exibir(raiz.esquerda); + exibirPosOrdem(raiz.esquerda); + exibirPosOrdem(raiz.direita); System.out.println(raiz.data); - exibir(raiz.direita); + } + } + + + + public void exibirEmNivel() { + Node tree = raiz; + if (tree == null) { + return; + } + + Queue fila = new LinkedList<>(); + fila.add(tree); + + while (!fila.isEmpty()) { + Node no = fila.poll(); + System.out.print(no.data + " "); + + if (no.esquerda != null) { + fila.add(no.esquerda); + } + if (no.direita != null) { + fila.add(no.direita); + } } } @@ -59,6 +152,70 @@ private void exibirTextoInvertido(Node raiz) { } } + public void imprimeArvore(){ + imprimeArvore(this.raiz, 0); + } + + public static void imprimeArvore(Node raiz, int level) { + if (raiz == null) { + return; + } + imprimeArvore(raiz.direita, level + 1); + + for (int i = 0; i < level; i++) { + //System.out.print(" "); + System.out.print(" "); + } + + System.out.println(raiz.data); + + imprimeArvore(raiz.esquerda, level + 1); + } + + public Node buscar(Object dado){ + + return buscar(raiz, dado); + } + private Node buscar(Node raiz, Object dado){ + if (arvoreVazia(raiz)){ + return null; + } + int comparacao = raiz.data.toString().compareTo(dado.toString()); + + if (comparacao == 0) { + return raiz; // Encontrou o elemento + } else if (comparacao > 0) { + return buscar(raiz.esquerda, dado); // Procura na subárvore esquerda + } else { + return buscar(raiz.direita, dado); // Procura na subárvore direita + } + + } + + public Node buscarElemento(Object elemento){ + Node encontrado = buscar(elemento); + if (encontrado!= null){ + System.out.println("Elemento encontrado: " + encontrado.data); + }else{ + System.out.println("Elemento não encontrado!"); + } + return encontrado; + } + +/* + +A utilização de dois métodos sobrecarregados chamados "buscar" serve para ocultar a complexidade da busca recursiva e permitir que o usuário da classe "ArvoreBinaria" faça chamadas mais simples ao método público. + +O método público buscar(Object data) é a interface externa que os usuários da classe irão chamar. Ele permite que você inicie a busca a partir da raiz da árvore sem expor os detalhes da implementação. Este método é uma espécie de ponto de entrada para a busca na árvore binária. + +O método privado buscar(Node raiz, Object data) é o método de busca real que realiza a pesquisa recursiva na árvore. Ele é chamado a partir do método público e é responsável por navegar pela árvore, comparar valores e decidir se deve continuar a busca na subárvore esquerda ou direita. Este método é usado para manter o estado interno da recursão e é uma parte essencial da implementação da busca na árvore binária. + +Usando essa abordagem, você pode ocultar os detalhes da recursão e tornar a interface pública mais simples para os usuários da classe, que só precisam passar o elemento que desejam buscar. O método público inicia a busca a partir da raiz, enquanto o método privado realiza a busca recursiva em cada nó da árvore. + +Isso torna o código mais organizado e encapsulado, seguindo o princípio da ocultação de informações (encapsulamento) e tornando a implementação mais fácil de entender e manter. + +*/ + //classe para testar a classe ArvoreBinaria public static void main(String[] args) { @@ -70,39 +227,91 @@ public static void main(String[] args) { arvore.inserir(4); arvore.inserir(6); arvore.inserir(8); - System.out.println("Método exibir: "); - arvore.exibir(); - System.out.println("Método printTree: "); - TreeExibeTexto.printTree(arvore.raiz, 0); + System.out.println("Método exibir EM ORDEM : "); + arvore.exibirEmOrdem(); + System.out.println("Método exibeArvore: "); + imprimeArvore(arvore.raiz, 0); System.out.println(); System.out.println(); - System.out.println("Método exibirTexto: "); + /* + System.out.println("Método exibirTexto EM ORDEM : : "); arvore.exibirTexto(); System.out.println(); + */ + System.out.println("Método exibirTexto EM NÍVEL: : "); + arvore.exibirEmNivel(); + System.out.println(); + System.out.println(); + + /* System.out.println("Método exibirTextoInvertido: "); arvore.exibirTextoInvertido(); System.out.println(); + System.out.println(); +*/ + System.out.println("Método exibir em PRÉ-ORDEM : "); + arvore.exibirPreOrdem(); + System.out.println(); - ArvoreBinaria arvore2 = new ArvoreBinaria(); + System.out.println("Método exibir em PÓS-ORDEM : "); + arvore.exibirPosOrdem(); + System.out.println(); + + Node encontrado = arvore.buscarElemento(5); + Node encontrado1 = arvore.buscarElemento(10); + arvore.remover(7); + imprimeArvore(arvore.raiz, 0); + + + + // ArvoreBinaria arvore2 = new ArvoreBinaria(); //arvore2.inserir(0); - arvore2.inserir(4); + /* arvore2.inserir(4); arvore2.inserir(3); arvore2.inserir(5); arvore2.inserir(6); arvore2.inserir(1); - arvore2.inserir(2); - System.out.println("Método exibir: "); - arvore2.exibir(); + arvore2.inserir(2); */ + /* arvore2.inserir(200); + arvore2.inserir(150); + arvore2.inserir(100); + arvore2.inserir(170); + arvore2.inserir(350); + arvore2.inserir(250); + arvore2.inserir(500); + arvore2.inserir(400); + arvore2.inserir(600); + System.out.println(); + System.out.println("Método exibir EM ORDEM : : "); + arvore2.exibirEmOrdem(); System.out.println(); System.out.println("Método printTree: "); - TreeExibeTexto.printTree(arvore2.raiz, 0); + imprimeArvore(arvore2.raiz, 0); System.out.println(); - System.out.println("Método exibirTexto: "); + System.out.println("Método exibirTexto EM ORDEM : : "); arvore2.exibirTexto(); System.out.println(); System.out.println("Método exibirTextoInvertido: "); arvore2.exibirTextoInvertido(); System.out.println(); +*/ + + ArvoreBinaria arvore2 = new ArvoreBinaria(); + arvore2.inserir("João"); + arvore2.inserir("Bianca"); + arvore2.inserir("Danilo"); + arvore2.inserir("Marcelo"); + arvore2.inserir("Carlos"); + arvore2.inserir("Ana"); + arvore2.inserir("Pedro"); + //arvore2.exibirTexto(); + imprimeArvore(arvore2.raiz,0); + arvore2.exibirEmOrdem(); + + + } } + + diff --git a/UNP/ref/Java/#ED2-Java-BKP/arvores/Node.java b/UNP/ref/Java/#ED2-Java-BKP/arvores/Node.java index 3939b77..cbbd29f 100644 --- a/UNP/ref/Java/#ED2-Java-BKP/arvores/Node.java +++ b/UNP/ref/Java/#ED2-Java-BKP/arvores/Node.java @@ -16,6 +16,7 @@ public Node(Object data) { //comparador @Override public String toString() { + return String.valueOf(data); } diff --git a/UNP/ref/Java/#ED2-Java-BKP/arvores/TreeExibeTexto.java b/UNP/ref/Java/#ED2-Java-BKP/arvores/TreeExibeTexto.java index 0c356d7..4a141b3 100644 --- a/UNP/ref/Java/#ED2-Java-BKP/arvores/TreeExibeTexto.java +++ b/UNP/ref/Java/#ED2-Java-BKP/arvores/TreeExibeTexto.java @@ -9,7 +9,8 @@ public static void printTree(Node raiz, int level) { printTree(raiz.direita, level + 1); for (int i = 0; i < level; i++) { - System.out.print(" "); + //System.out.print(" "); + System.out.print(" "); } System.out.println(raiz.data); @@ -18,6 +19,7 @@ public static void printTree(Node raiz, int level) { } public static void main(String[] args) { + /* Node raiz = new Node('A'); raiz.esquerda = new Node('B'); raiz.direita = new Node('C'); @@ -25,7 +27,17 @@ public static void main(String[] args) { raiz.esquerda.direita = new Node('E'); raiz.direita.direita = new Node('F'); raiz.esquerda.esquerda.esquerda = new Node('G'); + */ - printTree(raiz, 0); + ArvoreBinaria arvore = new ArvoreBinaria(); + arvore.inserir('D'); + arvore.inserir('B'); + arvore.inserir('C'); + arvore.inserir('A'); + arvore.inserir('E'); + arvore.inserir('F'); + arvore.inserir('G'); + + printTree(arvore.raiz, 0); } } diff --git a/UNP/ref/Java/#ED2-Java-BKP/arvores/VisualTreeDisplay.java b/UNP/ref/Java/#ED2-Java-BKP/arvores/VisualTreeDisplay.java index f653b1f..0d0a58f 100644 --- a/UNP/ref/Java/#ED2-Java-BKP/arvores/VisualTreeDisplay.java +++ b/UNP/ref/Java/#ED2-Java-BKP/arvores/VisualTreeDisplay.java @@ -2,17 +2,103 @@ import javax.swing.*; import java.awt.*; +import java.util.Queue; +import java.util.LinkedList; class TreeNode { - char data; + Object data; TreeNode left; TreeNode right; - public TreeNode(char data) { + public TreeNode(Object data) { this.data = data; this.left = null; this.right = null; } + + public void insert(Object newData) { + if (compare(newData, this.data) < 0) { + if (left == null) { + left = new TreeNode(newData); + } else { + left.insert(newData); + } + } else if (compare(newData, this.data) > 0) { + if (right == null) { + right = new TreeNode(newData); + } else { + right.insert(newData); + } + } + } + + private int compare(Object obj1, Object obj2) { + if (obj1 instanceof Comparable && obj2 instanceof Comparable) { + Comparable compObj1 = (Comparable) obj1; + return compObj1.compareTo(obj2); + } + throw new IllegalArgumentException("Os objetos não são comparáveis."); + } + + public void inOrder() { + inOrder(this); + } + + private void inOrder(TreeNode node) { + if (node != null) { + inOrder(node.left); + System.out.print(node.data + " "); + inOrder(node.right); + } + } + + public void preOrder() { + preOrder(this); + } + + private void preOrder(TreeNode node) { + if (node != null) { + System.out.print(node.data + " "); + preOrder(node.left); + preOrder(node.right); + } + } + + public void postOrder() { + postOrder(this); + } + + private void postOrder(TreeNode node) { + if (node != null) { + postOrder(node.left); + postOrder(node.right); + System.out.print(node.data + " "); + } + } + + public void levelOrder() { + if (this.data == null) { + return; + } + + Queue queue = new LinkedList<>(); + queue.offer(this); + + while (!queue.isEmpty()) { + TreeNode node = queue.poll(); + System.out.print(node.data + " "); + + if (node.left != null) { + queue.offer(node.left); + } + + if (node.right != null) { + queue.offer(node.right); + } + } + } + + } public class VisualTreeDisplay extends JPanel { @@ -29,73 +115,77 @@ protected void paintComponent(Graphics g) { drawTree(g, getWidth() / 2, 30, root, getWidth() / 8); } - private void drawTree(Graphics g, int x, int y, TreeNode node, int xOffset) { - if (node == null) { + private void drawTree(Graphics g, int x, int y, TreeNode treeNode, int xOffset) { + if (treeNode == null) { return; } - int ovalWidth = 30; //aumentar ou diminuir essa variável, altera o tamanho dos ovais. Valor padrão é 30 + int ovalWidth = 30; //aumentar ou diminuir essa vari�vel, altera o tamanho dos ovais. Valor padr�o � 30 int ovalHeight = 30; int ovalTop = y - ovalHeight / 2; // Coordenada Y do topo do oval final int distAresta = 80; // Crie um objeto Font com o tamanho desejado - Font font = new Font("Arial", Font.PLAIN, 14); // Substitua "Arial" pelo nome da fonte que você deseja e ajuste o tamanho (12) + Font font = new Font("Arial", Font.PLAIN, 14); // Substitua "Arial" pelo nome da fonte que voc� deseja e ajuste o tamanho (12) // Configure a fonte g.setFont(font); - if (node.left != null) { + if (treeNode.left != null) { int childX = x - xOffset; int childY = y + distAresta; g.drawLine(x, ovalTop + ovalHeight, childX, childY - ovalHeight / 2); - drawTree(g, childX, childY, node.left, xOffset / 2); + drawTree(g, childX, childY, treeNode.left, xOffset / 2); } - if (node.right != null) { + if (treeNode.right != null) { int childX = x + xOffset; int childY = y + distAresta; g.drawLine(x, ovalTop + ovalHeight, childX, childY - ovalHeight / 2); - drawTree(g, childX, childY, node.right, xOffset / 2); + drawTree(g, childX, childY, treeNode.right, xOffset / 2); } g.drawOval(x - ovalWidth / 2, ovalTop, ovalWidth, ovalHeight); - g.drawString(String.valueOf(node.data), x - 5, ovalTop + ovalHeight / 2 + 5); + g.drawString(String.valueOf(treeNode.data), x - 5, ovalTop + ovalHeight / 2 + 5); } - - /* private void drawTree(Graphics g, int x, int y, TreeNode node, int xOffset) { - if (node == null) { - return; - } - - g.drawOval(x - 15, y - 15, 30, 30); - g.drawString(String.valueOf(node.data), x - 5, y + 5); - - if (node.left != null) { - g.drawLine(x, y, x - xOffset, y + 50); - drawTree(g, x - xOffset, y + 50, node.left, xOffset / 2); - } - - if (node.right != null) { - g.drawLine(x, y, x + xOffset, y + 50); - drawTree(g, x + xOffset, y + 50, node.right, xOffset / 2); - } - } -*/ public static void main(String[] args) { - TreeNode root = new TreeNode('A'); - root.left = new TreeNode('B'); + TreeNode root = new TreeNode('D'); + /*root.left = new TreeNode('B'); root.right = new TreeNode('C'); root.left.left = new TreeNode('D'); root.left.right = new TreeNode('E'); root.right.right = new TreeNode('F'); - root.left.left.left = new TreeNode('G'); - - JFrame frame = new JFrame("Visualização da árvore"); + root.left.left.left = new TreeNode('G');*/ + root.insert('B'); + root.insert('C'); + root.insert('F'); + root.insert('H'); + root.insert('I'); + root.insert('E'); + root.insert('G'); + root.insert('A'); + + System.out.println("In Order:"); + root.inOrder(); + System.out.println(); + + System.out.println("Pre Order:"); + root.preOrder(); + System.out.println(); + + System.out.println("Post Order :"); + root.postOrder(); + System.out.println(); + + System.out.println("Level Order :"); + root.levelOrder(); + System.out.println(); + + JFrame frame = new JFrame("Visualiza��o da �rvore"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setSize(800, 600); frame.add(new VisualTreeDisplay(root)); diff --git a/UNP/ref/Java/#ED2-Java-BKP/basico/IntegerToRoman.java b/UNP/ref/Java/#ED2-Java-BKP/basico/IntegerToRoman.java new file mode 100644 index 0000000..9e41626 --- /dev/null +++ b/UNP/ref/Java/#ED2-Java-BKP/basico/IntegerToRoman.java @@ -0,0 +1,70 @@ +package basico; + +/** + * Converting Integers into Roman Numerals + * + *

+ * ('I', 1); ('IV',4); ('V', 5); ('IX',9); ('X', 10); ('XL',40); ('L', 50); + * ('XC',90); ('C', 100); ('D', 500); ('M', 1000); + */ +public class IntegerToRoman { + + private static int[] allArabianRomanNumbers = new int[] { + 1000, + 900, + 500, + 400, + 100, + 90, + 50, + 40, + 10, + 9, + 5, + 4, + 1, + }; + private static String[] allRomanNumbers = new String[] { + "M", + "CM", + "D", + "CD", + "C", + "XC", + "L", + "XL", + "X", + "IX", + "V", + "IV", + "I", + }; + + // Value must be > 0 + public static String integerToRoman(int num) { + if (num <= 0) { + return ""; + } + + StringBuilder builder = new StringBuilder(); + + for (int a = 0; a < allArabianRomanNumbers.length; a++) { + int times = num / allArabianRomanNumbers[a]; + for (int b = 0; b < times; b++) { + builder.append(allRomanNumbers[a]); + } + + num -= times * allArabianRomanNumbers[a]; + } + + return builder.toString(); + } + + public static void main(String[] args) { + //System.out.println(IntegerToRoman.integerToRoman(2131)); + for (int i = 0; i < 5000; i++) { + System.out.println(i + "\t=\t " + IntegerToRoman.integerToRoman(i)); + + } + } +} \ No newline at end of file diff --git a/UNP/ref/Java/#ED2-Java-BKP/basico/VarargsExemplo.java b/UNP/ref/Java/#ED2-Java-BKP/basico/VarargsExemplo.java new file mode 100644 index 0000000..3093956 --- /dev/null +++ b/UNP/ref/Java/#ED2-Java-BKP/basico/VarargsExemplo.java @@ -0,0 +1,29 @@ +package basico; + +public class VarargsExemplo { + public static void main(String[] args) { + System.out.println(soma(1,2)); + System.out.println(soma(1,2,3,4,5,6,7,8,9,10)); + System.out.println(soma(1.1,1.2,1.3,1.4)); + } + + private static int soma(int a, int b) { + return a +b; + } + + private static int soma(Integer... vetor) { + int sum = 0; + for (int i = 0; i < vetor.length; i++) { + sum += vetor[i]; + } + return sum; + } + + private static double soma(Double... vetor) { + double sum = 0.0; + for (Double aDouble : vetor) { + sum += aDouble; + } + return sum; + } +} diff --git a/UNP/ref/Java/#ED2-Java-BKP/generics/ClasseGenerica.java b/UNP/ref/Java/#ED2-Java-BKP/generics/ClasseGenerica.java new file mode 100644 index 0000000..55adb4f --- /dev/null +++ b/UNP/ref/Java/#ED2-Java-BKP/generics/ClasseGenerica.java @@ -0,0 +1,37 @@ +package generics; + +public class ClasseGenerica { //Primeiro essa sintaxe aqui: usamos < > para especificar o tipo de parâmetro + //Um objeto do tipo T é declarado + T objeto; + + public ClasseGenerica(T objeto) { //construtor + this.objeto = objeto; + } + public T getObjeto() { + return this.objeto; + } + + public static void main(String[] args) { + //Instância de um tipo Inteiro + ClasseGenerica objetoInteiro = new ClasseGenerica(10); + System.out.println("Objeto Inteiro: " + objetoInteiro.getObjeto()); + + //Instância de um tipo String + ClasseGenerica objetoString = new ClasseGenerica("Estruturas de Dados"); + System.out.println("Objeto String: " + objetoString.getObjeto()); + + } +} +/* + Parâmetros em Java Generics + ============================ + As convenções de nomenclatura dos parâmetros de tipo são importantes para aprender + completamente os genéricos. Os parâmetros de tipo comuns são os seguintes: + + T – Tipo + E – Elemento + K – Chave + N – Número + V – Valor + +*/ diff --git a/UNP/ref/Java/#ED2-Java-BKP/generics/Multiplos.java b/UNP/ref/Java/#ED2-Java-BKP/generics/Multiplos.java new file mode 100644 index 0000000..75fc322 --- /dev/null +++ b/UNP/ref/Java/#ED2-Java-BKP/generics/Multiplos.java @@ -0,0 +1,29 @@ +package generics; + +// Programa Java para mostrar vários +// tipos de parâmetros com Java Generics +class Multiplos // usamos < > para especificar o tipo de parâmetro +{ + T obj1; // Um objeto do tipo T + U obj2; // Um objeto do tipo U + + // constructor + Multiplos(T obj1, U obj2) { + this.obj1 = obj1; + this.obj2 = obj2; + } + + + public void print() { + System.out.println(obj1); + System.out.println(obj2); + } + + public static void main(String[] args) { + Multiplos objeto = new Multiplos("Uma String", 15); + + objeto.print(); + } + + +} \ No newline at end of file diff --git a/UNP/ref/Java/#ED2-Java-BKP/generics/PrintGenerico.java b/UNP/ref/Java/#ED2-Java-BKP/generics/PrintGenerico.java new file mode 100644 index 0000000..900e958 --- /dev/null +++ b/UNP/ref/Java/#ED2-Java-BKP/generics/PrintGenerico.java @@ -0,0 +1,18 @@ +package generics; + +public class PrintGenerico { + + static void printGenerico(T element) + { + System.out.println(element.getClass().getName() + " = " + element); + } + + // Driver method + public static void main(String[] args) + { + + printGenerico(11); + printGenerico("Estruturas de Dados"); + printGenerico(1.0); + } +} \ No newline at end of file diff --git a/UNP/ref/Java/#ED2-Java-BKP/generics/ReusabilidadeOrdenacao.java b/UNP/ref/Java/#ED2-Java-BKP/generics/ReusabilidadeOrdenacao.java new file mode 100644 index 0000000..8321f19 --- /dev/null +++ b/UNP/ref/Java/#ED2-Java-BKP/generics/ReusabilidadeOrdenacao.java @@ -0,0 +1,54 @@ +package generics; + +public class ReusabilidadeOrdenacao { + + public static void main(String[] args) + { + + Integer[] a = { 100, 22, 58, 41, 6, 50 }; + + Character[] c = { 'v', 'g', 'a', 'c', 'x', 'd', 't' }; + + String[] s = { "Estados Unidos", "Irã", "Brasil", "Austrália","França", "Itália", "China" }; + + System.out.print("Array de Inteiros ordenado: : "); + ordena_generico(a); + + System.out.print("Array de Char ordenado : "); + ordena_generico(c); + + System.out.print("Array de Strings ordenado : "); + ordena_generico(s); + + } + + public static > void ordena_generico(T[] array) + { + + // Como estamos comparando os tipos de dados não primitivos + // precisamos usar a classe Comparable + + //Lógica de classificação por bolha + for (int i = 0; i < array.length - 1; i++) { + for (int j = 0; j < array.length - i - 1; j++) { + if (array[j].compareTo(array[j + 1]) > 0) { + troca(j, j + 1, array); + } + } + } + + //Imprimindo os elementos depois de ordenados + for (T i : array){ + System.out.print(i + ", "); + } + System.out.println(); + + } + + public static void troca(int i, int j, T[] a) + { + T t = a[i]; + a[i] = a[j]; + a[j] = t; + } +} diff --git a/UNP/ref/Java/#ED2-Java-BKP/grafos/GrafoListaAdjacencia.java b/UNP/ref/Java/#ED2-Java-BKP/grafos/GrafoListaAdjacencia.java new file mode 100644 index 0000000..eb15cbc --- /dev/null +++ b/UNP/ref/Java/#ED2-Java-BKP/grafos/GrafoListaAdjacencia.java @@ -0,0 +1,44 @@ +package grafos; + +import java.util.ArrayList; +import java.util.List; + +public class GrafoListaAdjacencia { + private int numVertices; + private List> listaAdjacencia; + + public GrafoListaAdjacencia(int numVertices) { + this.numVertices = numVertices; + listaAdjacencia = new ArrayList<>(numVertices); + for (int i = 0; i < numVertices; i++) { + listaAdjacencia.add(new ArrayList<>()); + } + } + + public void adicionarAresta(int vertice1, int vertice2) { + listaAdjacencia.get(vertice1).add(vertice2); + listaAdjacencia.get(vertice2).add(vertice1); + } + + public void mostrarGrafo() { + for (int i = 0; i < numVertices; i++) { + System.out.print("Vértice " + i + ": "); + for (Integer vizinho : listaAdjacencia.get(i)) { + System.out.print(vizinho + " "); + } + System.out.println(); + } + } + + public static void main(String[] args) { + int numVertices = 4; + GrafoListaAdjacencia grafo = new GrafoListaAdjacencia(numVertices); + + grafo.adicionarAresta(0, 1); + grafo.adicionarAresta(0, 2); + grafo.adicionarAresta(1, 2); + grafo.adicionarAresta(2, 3); + + grafo.mostrarGrafo(); + } +} diff --git a/UNP/ref/Java/#ED2-Java-BKP/grafos/GrafoMatrizAdjacencia.java b/UNP/ref/Java/#ED2-Java-BKP/grafos/GrafoMatrizAdjacencia.java new file mode 100644 index 0000000..c740544 --- /dev/null +++ b/UNP/ref/Java/#ED2-Java-BKP/grafos/GrafoMatrizAdjacencia.java @@ -0,0 +1,37 @@ +package grafos; + +public class GrafoMatrizAdjacencia { + private int numVertices; + private int[][] matrizAdjacencia; + + public GrafoMatrizAdjacencia(int numVertices) { + this.numVertices = numVertices; + this.matrizAdjacencia = new int[numVertices][numVertices]; + } + + public void adicionarAresta(int vertice1, int vertice2) { + matrizAdjacencia[vertice1][vertice2] = 1; + matrizAdjacencia[vertice2][vertice1] = 1; + } + + public void mostrarGrafo() { + for (int i = 0; i < numVertices; i++) { + for (int j = 0; j < numVertices; j++) { + System.out.print(matrizAdjacencia[i][j] + " "); + } + System.out.println(); + } + } + + public static void main(String[] args) { + int numVertices = 4; + GrafoMatrizAdjacencia grafo = new GrafoMatrizAdjacencia(numVertices); + + grafo.adicionarAresta(0, 1); + grafo.adicionarAresta(0, 2); + grafo.adicionarAresta(1, 2); + grafo.adicionarAresta(2, 3); + + grafo.mostrarGrafo(); + } +} diff --git a/UNP/ref/Java/#ED2-Java-BKP/grafos/GraphVisualization.java b/UNP/ref/Java/#ED2-Java-BKP/grafos/GraphVisualization.java new file mode 100644 index 0000000..8580ec9 --- /dev/null +++ b/UNP/ref/Java/#ED2-Java-BKP/grafos/GraphVisualization.java @@ -0,0 +1,46 @@ +package grafos; + +import edu.uci.ics.jung.algorithms.layout.CircleLayout; +import edu.uci.ics.jung.graph.Graph; +import edu.uci.ics.jung.graph.SparseGraph; +import edu.uci.ics.jung.visualization.VisualizationImageServer; + +import javax.swing.*; +import java.awt.*; +import java.awt.geom.AffineTransform; +import java.awt.geom.Rectangle2D; + +public class GraphVisualization { + public static void main(String[] args) { + // Crie um grafo com JUNG + Graph graph = new SparseGraph<>(); + graph.addVertex(1); + graph.addVertex(2); + graph.addVertex(3); + graph.addVertex(4); + graph.addEdge("Edge 1", 1, 2); + graph.addEdge("Edge 2", 3, 4); + graph.addEdge("Edge 3", 2, 4); + graph.addEdge("Edge 4", 1, 3); + + // Visualize o grafo com JUNG (apenas para fins de visualização) + VisualizationImageServer vs = + new VisualizationImageServer<>(new CircleLayout<>(graph), new Dimension(300, 200)); + + // Defina um transformador personalizado para exibir rótulos de vértices + vs.getRenderContext().setVertexLabelTransformer(vertex -> vertex.toString()); + + // Defina um transformador personalizado para ajustar o tamanho dos rótulos + vs.getRenderContext().setVertexShapeTransformer(vertex -> { + Rectangle2D shape = new Rectangle2D.Double(-20, -10, 40, 20); // Tamanho personalizado + return AffineTransform.getScaleInstance(1, 1).createTransformedShape(shape); + }); + + // Crie um JFrame para exibir o grafo visualizado + JFrame frame = new JFrame("Visualização de Grafo"); + frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + frame.getContentPane().add(vs); + frame.pack(); + frame.setVisible(true); + } +} diff --git a/UNP/ref/Java/#ED2-Java-BKP/grafos/VisualizeGraph.java b/UNP/ref/Java/#ED2-Java-BKP/grafos/VisualizeGraph.java new file mode 100644 index 0000000..0311d64 --- /dev/null +++ b/UNP/ref/Java/#ED2-Java-BKP/grafos/VisualizeGraph.java @@ -0,0 +1,41 @@ +package grafos; + +import edu.uci.ics.jung.algorithms.layout.CircleLayout; +import edu.uci.ics.jung.graph.Graph; +import edu.uci.ics.jung.graph.SparseGraph; +import edu.uci.ics.jung.visualization.VisualizationImageServer; + +import javax.swing.*; +import java.awt.*; +import java.awt.geom.AffineTransform; +import java.awt.geom.Rectangle2D; + +public class VisualizeGraph { + public static void main(String[] args) { + // Crie um grafo com JUNG + Graph graph = new SparseGraph<>(); + graph.addVertex(1); + graph.addVertex(2); + graph.addEdge("Edge 1", 1, 2); + + // Visualize o grafo com JUNG (apenas para fins de visualização) + VisualizationImageServer vs = + new VisualizationImageServer<>(new CircleLayout<>(graph), new Dimension(300, 200)); + + // Defina um transformador personalizado para exibir rótulos de vértices + vs.getRenderContext().setVertexLabelTransformer(vertex -> vertex.toString()); + + // Defina um transformador personalizado para ajustar o tamanho dos rótulos + vs.getRenderContext().setVertexShapeTransformer(vertex -> { + Rectangle2D shape = new Rectangle2D.Double(-20, -10, 40, 20); // Tamanho personalizado + return AffineTransform.getScaleInstance(1, 1).createTransformedShape(shape); + }); + + // Crie um JFrame para exibir o grafo visualizado + JFrame frame = new JFrame("Visualização de Grafo"); + frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + frame.getContentPane().add(vs); + frame.pack(); + frame.setVisible(true); + } +} diff --git a/UNP/ref/Java/#ED2-Java-BKP/ordenacao_busca/BuscaBinaria.java b/UNP/ref/Java/#ED2-Java-BKP/ordenacao_busca/BuscaBinaria.java index 13bdba0..9f1973e 100644 --- a/UNP/ref/Java/#ED2-Java-BKP/ordenacao_busca/BuscaBinaria.java +++ b/UNP/ref/Java/#ED2-Java-BKP/ordenacao_busca/BuscaBinaria.java @@ -10,15 +10,15 @@ public static int buscaBinaria(int[] array, int chave) { int mid = left + (right - left) / 2; if (array[mid] == chave) { - return mid; // Elemento encontrado, retorna o índice + return mid; // Elemento encontrado, retorna o índice } else if (array[mid] < chave) { - left = mid + 1; // O elemento está na metade direita do array + left = mid + 1; // O elemento está na metade direita do array } else { - right = mid - 1; // O elemento está na metade esquerda do array + right = mid - 1; // O elemento está na metade esquerda do array } } - return -1; // Elemento não encontrado + return -1; // Elemento não encontrado } public static void main(String[] args) { @@ -28,9 +28,9 @@ public static void main(String[] args) { int result = buscaBinaria(sortedArray, target); if (result != -1) { - System.out.println("Elemento encontrado no índice: " + result); + System.out.println("Elemento encontrado no índice: " + result); } else { - System.out.println("Elemento não encontrado."); + System.out.println("Elemento não encontrado."); } } } diff --git a/UNP/ref/Java/#ED2-Java-BKP/paradigmas/Sudoku.java b/UNP/ref/Java/#ED2-Java-BKP/paradigmas/Sudoku.java new file mode 100644 index 0000000..428a227 --- /dev/null +++ b/UNP/ref/Java/#ED2-Java-BKP/paradigmas/Sudoku.java @@ -0,0 +1,134 @@ +package paradigmas; + +class Sudoku { + + public static boolean isSafe(int[][] board, int row, int col, int num) { + // Linha tem números únicos (colisão da linha) + for (int d = 0; d < board.length; d++) { + // Verifica se o número que estamos tentando + // o local já está presente + // nessa linha, return false; + if (board[row][d] == num) { + return false; + } + } + + // A coluna contém os números únicos (colisão da coluna) + for (int r = 0; r < board.length; r++) { + // Verifica se o número que estamos tentando + // o local já está presente + // nessa linha, return false; + if (board[r][col] == num) { + return false; + } + } + + // O quadrado correspondente tem + // número único (colisão/confronto) + int sqrt = (int) Math.sqrt(board.length); + int boxRowStart = row - row % sqrt; + int boxColStart = col - col % sqrt; + + for (int r = boxRowStart; r < boxRowStart + sqrt; r++) { + for (int d = boxColStart; d < boxColStart + sqrt; d++) { + if (board[r][d] == num) { + return false; + } + } + } + + // se não há colisão/confronto então, tranquilo + return true; + } + + public static boolean solveSudoku(int[][] board, int n) { + int row = -1; + int col = -1; + boolean isEmpty = true; + for (int i = 0; i < n; i++) { + for (int j = 0; j < n; j++) { + if (board[i][j] == 0) { + row = i; + col = j; + + // Ainda temos alguns restantes + //valores ausentes no Sudoku + isEmpty = false; + break; + } + } + if (!isEmpty) { + break; + } + } + + //Não resta espaço vazio + if (isEmpty) { + return true; + } + + // Else para retrocesso/backtracking de cada linha + for (int num = 1; num <= n; num++) { + if (isSafe(board, row, col, num)) { + board[row][col] = num; + if (solveSudoku(board, n)) { + // print(board, n); + return true; + } else { + // replace it + board[row][col] = 0; + } + } + } + return false; + } + + public static void print(int[][] board, int N) { + // Temos a resposta, basta imprimi-la + for (int r = 0; r < N; r++) { + for (int d = 0; d < N; d++) { + System.out.print(board[r][d]); + System.out.print(" "); + } + System.out.print("\n"); + + if ((r + 1) % (int) Math.sqrt(N) == 0) { + System.out.print(""); + } + } + } + + // Código principal + public static void main(String[] args) { + /*int[][] board = new int[][] { + {3, 0, 6, 5, 0, 8, 4, 0, 0}, + {5, 2, 0, 0, 0, 0, 0, 0, 0}, + {0, 8, 7, 0, 0, 0, 0, 3, 1}, + {0, 0, 3, 0, 1, 0, 0, 8, 0}, + {9, 0, 0, 8, 6, 3, 0, 0, 5}, + {0, 5, 0, 0, 9, 0, 6, 0, 0}, + {1, 3, 0, 0, 0, 0, 2, 5, 0}, + {0, 0, 0, 0, 0, 0, 0, 7, 4}, + {0, 0, 5, 2, 0, 6, 3, 0, 0}, + };*/ + int[][] board = new int[][] { + {0, 0, 0, 7, 6, 8, 0, 0, 0}, + {6, 0, 5, 3, 0, 0, 7, 0, 2}, + {0, 9, 0, 1, 0, 0, 0, 3, 0}, + {0, 0, 0, 0, 0, 0, 3, 0, 4}, + {0, 6, 0, 0, 0, 0, 0, 5, 0}, + {2, 0, 9, 0, 0, 0, 0, 0, 0}, + {0, 2, 0, 0, 0, 1, 0, 7, 0}, + {8, 0, 1, 0, 0, 3, 4, 0, 6}, + {0, 0, 0, 4, 5, 9, 0, 0, 0}, + }; + int N = board.length; + + if (solveSudoku(board, N)) { + // print solution + print(board, N); + } else { + System.out.println("Sem solução!"); + } + } +} diff --git a/UNP/ref/Java/#ED2-Java-BKP/recursividade/CoeficientesPascal.java b/UNP/ref/Java/#ED2-Java-BKP/recursividade/CoeficientesPascal.java new file mode 100644 index 0000000..5c44ba5 --- /dev/null +++ b/UNP/ref/Java/#ED2-Java-BKP/recursividade/CoeficientesPascal.java @@ -0,0 +1,37 @@ +package recursividade; + +public class CoeficientesPascal { + + public static int coeficiente(int n, int p){ + if(p==0) return 1; + if(n==p) return 1; + return coeficiente(n-1, p-1) + coeficiente(n-1, p); + } + + public static void main(String[] args) { + int n = 10; + //exibePolinomio(n); + for (int i = 0; i < n; i++) { + exibePolinomio(i); + System.out.println(); + } + exibePascal(n); + } + + public static void exibePolinomio(int n){ + for (int i = n; i >= 0; i--) { + System.out.print(coeficiente(n, i) + "x^" + i + " + "); + } + } + + public static void exibePascal(int n) { + for (int i = 0; i < n; i++) { + for (int j = 0; j <= i; j++) { + System.out.print(coeficiente(i, j) + "\t"); + } + System.out.println(); + } + } + + +} diff --git a/UNP/ref/Java/#ED2-Java-BKP/recursividade/InverteS.java b/UNP/ref/Java/#ED2-Java-BKP/recursividade/InverteS.java new file mode 100644 index 0000000..642d962 --- /dev/null +++ b/UNP/ref/Java/#ED2-Java-BKP/recursividade/InverteS.java @@ -0,0 +1,31 @@ +package recursividade; + +public class InverteS { + + + public static void main(String[] args) { + + String original = "Estruturas de Dados"; + String invertida = inverterString(original); + System.out.println("String original: " + original); + System.out.println("String invertida: " + invertida); + + } + + public static String inverterString(String str) { + + if (str.isEmpty() + ) { + return str; + } else { + + char primeiroChar = str.charAt(0); + String restoDaString = str.substring(1); + String inversoDoResto = inverterString(restoDaString); + return inversoDoResto + primeiroChar; + + } + + } + +} diff --git a/UNP/ref/Java/#ED2-Java-BKP/recursividade/SomaQuadrados.java b/UNP/ref/Java/#ED2-Java-BKP/recursividade/SomaQuadrados.java new file mode 100644 index 0000000..fbfbdc3 --- /dev/null +++ b/UNP/ref/Java/#ED2-Java-BKP/recursividade/SomaQuadrados.java @@ -0,0 +1,31 @@ +package recursividade; + +public class SomaQuadrados{ + + + public static int somaQuadrados(int n) { + +// Caso base: quando n chega a 1, o quadrado é 1. + + if (n == 1) { + + return 1; + + } + + +// Caso geral: recursivamente, soma o quadrado de n com a chamada de somaQuadrados para n-1. + + return n * n + somaQuadrados(n - 1); + + } + + public static void main(String[] args) { + + int resultado = somaQuadrados(5); // Calcula a soma dos quadrados dos primeiros 5 inteiros positivos. + + System.out.println("Resultado: " + resultado); // Isso imprimirá 55 (5^2 + 4^2 + 3^2 + 2^2 + 1^2). + + } + +} diff --git a/UNP/ref/Java/#ED2-Java-BKP/recursividade/SomaRecursiva.java b/UNP/ref/Java/#ED2-Java-BKP/recursividade/SomaRecursiva.java new file mode 100644 index 0000000..82d0fe4 --- /dev/null +++ b/UNP/ref/Java/#ED2-Java-BKP/recursividade/SomaRecursiva.java @@ -0,0 +1,17 @@ +package recursividade; + +public class SomaRecursiva { + + public static int soma(int n) { + if (n <= 0) { + return 0; + } else { + return n + soma(n - 1); + } + } + + public static void main(String[] args) { + int resultado = soma(100); + System.out.println("A soma dos números de 1 a 100 é: " + resultado); + } +} diff --git a/UNP/ref/Java/#ED2-Java-BKP/recursividade/SomaSerie.java b/UNP/ref/Java/#ED2-Java-BKP/recursividade/SomaSerie.java new file mode 100644 index 0000000..761a553 --- /dev/null +++ b/UNP/ref/Java/#ED2-Java-BKP/recursividade/SomaSerie.java @@ -0,0 +1,23 @@ +package recursividade; + +public class SomaSerie { + + public static double calculateSum(int n) { + + if (n == 1) { + return 1.0; + } else { + return calculateSum(n - 1) + 1.0 / n; + } + + } + + public static void main(String[] args) { + + int n = 5; // Change this value to the desired number of terms + double sum = calculateSum(n); + System.out.println("Sum of the series: " + sum); + } + + +}