darlan DNYZARTH

package facema.aulas.arvores; /** * * @author Gian Carlos */ public class ArvoreBin<T>{ private No<T> raiz; private No<T> esq; private No<T> dir; public No<T> inserir(T valor) { return inserir(new No<>(valor), raiz); } private No<T> inserir(No<T> novo, No<T> anterior){ if (raiz == null) { raiz = novo; return raiz; } if (anterior != null){ if (novo.compareTo(anterior) <= 0){ No<T> esq = inserir(novo, anterior.getEsq()); anterior.setEsq(esq); } else if (novo.compareTo(anterior) > 0){ No<T> dir = inserir(novo, anterior.getDir()); anterior.setDir(dir); } else { return null; } } else { anterior = novo; } return anterior; } public int contagem(No<T> no){ if(no == null) { return 0; } return (1 + contagem(no.getEsq()) + contagem(no.getDir())); } // Raiz - Esquerda - Direita public void preOrdem(){ preOrdem(raiz); } public void preOrdem(No<T> no){ if (no != null){ System.out.println(no.getConteudo()); preOrdem(no.getEsq()); preOrdem(no.getDir()); } } // Esquerda - Direita - Raiz public void posOrdem(){ posOrdem(raiz); } public void posOrdem(No<T> no){ if (no != null) { posOrdem(no.getEsq()); posOrdem(no.getDir()); System.out.println(no.getConteudo()); } } // Esquerda - Raiz - Direita public void emOrdem(){ preOrdem(raiz); } public void emOrdem(No<T> no){ if (no != null) { emOrdem(no.getEsq()); System.out.println(no.getConteudo()); emOrdem(no.getDir()); } } public T buscar(T procurado){ No node = new No(procurado); return buscar(node, raiz); } private T buscar(No procurado, No<T> pai){ No no = procurado; No<T> aux = pai; if(raiz == null){ throw new RuntimeException("Arvore vazia!"); }else{ if(aux == null){ throw new RuntimeException("Valor não encontrado!"); }else if( aux.compareTo(no) == 0){ return (T) aux.getConteudo(); }else if(no.compareTo(aux) <= 0){ T temp = buscar(procurado, aux.getEsq()); return temp; }else if(no.compareTo(aux) > 0){ T temp = buscar(procurado, aux.getDir()); return temp; } } return null; } } package facema.aulas.arvores; /** * * @author Gian Carlos */ public class No <T> { private T conteudo; private No<T> esq; private No<T> dir; public No(T conteudo,No<T> esq, No<T> dir) { this.conteudo = conteudo; this.dir = dir; this.esq = dir; } public No(T conteudo){ this.conteudo = conteudo; } public T getConteudo() { return conteudo; } public void setConteudo(T conteudo) { this.conteudo = conteudo; } public No<T> getEsq() { return esq; } public void setEsq(No<T> esq) { this.esq = esq; } public No<T> getDir() { return dir; } public void setDir(No<T> dir) { this.dir = dir; } public int compareTo(No<T> o) { Professor p = (Professor) conteudo; Professor p1 = (Professor) o.getConteudo(); return p.compareTo(p1); } } package facema.aulas.arvores; /** * * @author Gian Carlos */ public class Professor implements Comparable<Professor>{ private String nome; private double salario; public Professor(Professor prof){ } public Professor(String nome, double salario) { // TODO Auto-generated constructor stub this.nome = nome; this.salario = salario; } public String getNome() { return nome; } public void setNome(String nome) { this.nome = nome; } public double getSalario() { return salario; } public void setSalario(double salario) { this.salario = salario; } @Override public String toString() { return "(" + nome + ", " + salario + ")"; } @Override public int compareTo(Professor o) { // TODO Auto-generated method stub return nome.compareTo(o.getNome()); } } package facema.aulas.arvores; /** * * @author Gian Carlos */ public class TesteArvore { public static void main(String[] args) { ArvoreBin<Professor> a = new ArvoreBin<>(); Professor p1 = new Professor("Helio", 10000), p2 = new Professor("Marcelo", 9999), p3 = new Professor("Leoncio", 9000), p4 = new Professor("Italo", 4000); a.inserir(p1); a.inserir(p2); a.inserir(p3); a.inserir(p4); /* * * Helio * \ * Marcelo * / * Leoncio * / * Italo * */ // Raiz - Esquera - Direita: Helio, Marcelo, Leoncio, Italo System.out.println("PreOrdem"); a.preOrdem(); // Esquerda - Direita - Raiz: Italo, Leoncio, Marcelo, Helio System.out.println("PosOrdem"); a.posOrdem(); // Esquerda - Raiz - Direita: Italo, Leoncio, Marcelo, Helio System.out.println("EmOrdem"); a.posOrdem(); System.out.println("Buscar Professor:"); System.out.println(a.buscar(p2)); } } Boa tarde estou desenvolvendo um trabalho de arvores e estou com dificuldade de desenvolver o método de remover e gostaria de ajuda

function ArvoreBinaria() { this.noRaiz = null; } ArvoreBinaria.prototype = { constructor: ArvoreBinaria, // Adiciona um novo valor adicionar: function(valor) { // Cria um novo objeto para armazenar o valor atual var novoNo = { valor: valor, esq: null, dir: null }; var noAtual; if (this.noRaiz == null) { // Caso a árvore esteja vazia this.noRaiz = novoNo; } else { noAtual = this.noRaiz; while (true) { if (valor < noAtual.valor) { // Atribuímos um novo nó a esquerda caso não exista // ou seguimos adiante usando o nó da esquerda como nó atual if (noAtual.esq == null) { noAtual.esq = novoNo; break; } else { noAtual = noAtual.esq; } } else if (valor > noAtual.valor) { // Atribuímos um novo nó a direita caso não exista // ou seguimos adiante usando o nó da direita como nó atual if (noAtual.dir == null) { noAtual.dir = novoNo; break; } else { noAtual = noAtual.dir; } } else { break; } } } }, // Verifica se o valor existe ou não na árvore contem: function(valor) { var encontrado = false, noAtual = this.noRaiz; while (!encontrado && noAtual) { // Se o valor é menor que o do nó atual, atribua o nó da esquerda if (valor < noAtual.valor) { noAtual = noAtual.esq; } // Se o valor é maior que o do nó atual, atribua o nó da direita else if (valor > noAtual.valor) { noAtual = noAtual.dir; } // Valor do nó atual é igual ao valor passado como parâmetro else { encontrado = true; } } return encontrado; }, // Retorna o número de níveis entre o nó atual e o descendente // mais afastado, seguindo o caminho mais longo altura: function(no) { if (!no) return 0; var alturaEsq = this.altura(no.esq); var alturaDir = this.altura(no.dir); return Math.max(alturaEsq, alturaDir) + 1; }, // Percorre a árvore e exibe os valores em ordem crescente no console percorrer: function(no) { if (no) { this.percorrer(no.esq); console.log(no.valor); this.percorrer(no.dir); } }, // O menor é o nó do mais baixo nível a esquerda menorNo: function(no) { if (!no) { return 0; } if (no.esq) { return this.menorNo(no.esq); } return no.valor; }, // O maior é o nó do mais baixo nível a direita maiorNo: function(no) { if (!no) { return 0; } if (no.dir) { return this.maiorNo(no.dir); } return no.valor; } }; boa noite gostaria de um código de Implementação dos seguintes algoritmos de pesquisa: busca sequencial busca aleatória busca com salto busca binária pois estou a dias tentando fazer esse código e não estou conseguindo se alguém pode me ajuda ficaria muito grato por sua ajudar . <>