Olá a todos, vou postar o codigo se alguem puder me esclarecer agradeço, nesse ultimo metodo para retornar o maior valor e o menor valor seria dessa forma que fiz? mais quando vou chamar no principal na main nao consigo.
[code]package Arvore;
public class arvore {
private No raiz;// somente a classe vaiter acesso
public int maior = 0;// inicializa o atributo maior
public int menor = 99999;// inicializao do menor
// construtor
public arvore() {
raiz = null;
}
// metodo para altura
public int altura(No raizLocal) {
if (raizLocal == null)
return 0;// a altura de 'nada' é zero
int he = altura(raizLocal.filhoEsquerda);
int hd = altura(raizLocal.filhoDireita);
if (he < hd)
return hd + 1;
else
return he + 1;
}
// metodo insere
/**
* este metodo insere na arvore os no
*/
public void inserir(No novoNo) {
if (raiz == null) {// se raiz for igual null nao tem nenhum no
raiz = novoNo;// cria umnovo no
} else {
No atual = raiz;// atual e onde estou, armazena raiz
No pai;// e o no pai e para saber onde vaiser inserido um outro no
while (true) {// enquando a posicao do valor for verdadeira
pai = atual;// guarda a variavel anterior, guarda a raiz que
// esta a raiz
// if para saber para onde eu vou, esquerda
if (novoNo.chave < atual.chave) {// chave e por onde vai ser
// organizado
atual = atual.filhoEsquerda;// meu no atual acessa filho a
// esquerda
if (atual == null) {// se caso meu filho a esquerda da raiz
// for null
pai.filhoEsquerda = novoNo;// a variavel pai que
// armazenou a raiz cria um
// novo no
return;
}
} else {// else para direita
atual = atual.filhoDireita;
if (atual == null) {
pai.filhoDireita = novoNo;
return;
}
}
}
}
}
/**
* metodo travessia nos permite escolher qual a forma que usaremos para
* percorrer todos os nós da arvore
*/
public void travessia(int tipoTravessia) {
switch (tipoTravessia) {
case 1:
System.out.println("\n Travessia usando preOrder: ");
preOrder(raiz);
break;
case 2:
System.out.println("\n Travessia usando inOrder ");
inOrder(raiz);
break;
case 3:
System.out.println("\n Travessia usando posOrder: ");
posOrder(raiz);
break;
}// fim do switch
}// fim do metodo travessia()
/**
* todos os nós sao visitados em ordem crescente metodo para inserir em
* Ordem
*
* @param raizLocal
*/
public void inOrder(No raizLocal) {
if (raizLocal != null) {// se raizLocal nao for igual a null
inOrder(raizLocal.filhoEsquerda);// metodo inOrder aponta para
// filho
// a esquerda
raizLocal.imprimirNo();// metodo acessa ou chama o metodo imprime
inOrder(raizLocal.filhoDireita);// filho a direita
}
}// fimdometodo
/**
* visita o nó chama a si mesmo para percorrer a subarvore a esquerda do
* nó chama a si mesmo para percorrer a subarvore a direita do nó
*/
private void preOrder(No raizLocal) {
if (raizLocal != null) {// se raizLocal nao for igual a null
preOrder(raizLocal.filhoEsquerda);// metodo inOrder aponta para
// filho
// a esquerda
raizLocal.imprimirNo();// metodo acessa ou chama o metodo imprime
preOrder(raizLocal.filhoDireita);// filho a direita
}
}
// metodo posOrder
private void posOrder(No raizLocal) {
if (raizLocal != null) {
posOrder(raizLocal.filhoEsquerda);
posOrder(raizLocal.filhoDireita);
raizLocal.imprimirNo();
}
}
public boolean Deletar(int chave) {
No atual = raiz;
No pai = raiz;
boolean eFilhoEsquerda = true;
// o laco while e usado para encontrar o no a ser apagado
// caso nao exista o nó,o laco retorna falso
while (atual.chave != chave) {
pai = atual;
if (chave < atual.chave) {// vai para esquerda ou
eFilhoEsquerda = true;
atual = atual.filhoEsquerda;
} else {// vai para direita
eFilhoEsquerda = false;
atual = atual.filhoDireita;
}
if (atual == null) {// fim dalinha ?
return false; // nao encontrou valor da arvore
}
}
// se o no a ser apagado nao possui filhos, simplesmente
// o eliminado
if (atual.filhoDireita == null && atual.filhoEsquerda == null) {
// se elenao tem nenhum filho
if (atual == raiz) {
raiz = null;
}
// entra nesse lado o no esquerdo e apagado
else if (eFilhoEsquerda) {
pai.filhoEsquerda = null;
// se entrar no else aqui o no apagado esta a direita
} else {
pai.filhoDireita = null;
}
}
// se o nó a ser apagado possuir um filho direita
else if (atual.filhoDireita == null) {
if (atual == raiz) {
raiz = atual.filhoDireita;
} else if (eFilhoEsquerda) {
pai.filhoDireita = atual.filhoEsquerda;
} else {
pai.filhoDireita = atual.filhoDireita;
}
}
// se o no a ser apagado possuir umfilho a esquerda
// substitui pela subarvore á direita
else if (atual.filhoEsquerda == null) {
if (atual == raiz) {
raiz = atual.filhoDireita;
} else if (eFilhoEsquerda) {
// filho a esquerda do pai
pai.filhoEsquerda = atual.filhoDireita;
} else {
// filho a direita do pai
pai.filhoDireita = atual.filhoDireita;
}
}
// se o no a ser apagado possuir dois filhos,
// substituimos o no a ser apagado pelo seu seu sucessor
// sucessor inOrder
else {
No sucessor = getSucessor(atual);
// conectar o pai atual ao sucessor
if (atual == raiz) {
raiz = sucessor;
} else if (eFilhoEsquerda) {
pai.filhoEsquerda = sucessor;
} else {
pai.filhoDireita = sucessor;
}
// conecta o sucessor ao filho a direita
sucessor.filhoDireita = atual.filhoDireita;
}// fim do else dois filhos
return true;
}// fim do metodo deletar
/**
*
* @param atual
* @return o sucessor do Nó (atual) que queremos apagar
*/
private No getSucessor(No atual) {// apagar o no atual
No sucessorPai = atual;
No sucessor = atual;
while (atual != null) {
sucessorPai = sucessor;
sucessor = atual;
atual = atual.filhoEsquerda;// vai para filho a esquerda
}
// se o sucesor nao e filho a direita faz conexao
if (sucessor != atual.filhoDireita) {
sucessorPai.filhoDireita = sucessor.filhoDireita;
sucessor.filhoDireita = atual.filhoDireita;
}
return sucessor;
}
// metodo para que retorna resultado da subtracao do maior pelo menor
// elementos de uma árvore binária.
public int SubDaArvore(No locaraiz ) {
if (locaraiz != null) {
//se a raiz local for diferente de nulo, continua
SubDaArvore(locaraiz.filhoEsquerda);
//anda para o lado esquerdo da arvore,
if (maior < locaraiz.chave) {
//se o maior for menor que o valor do Nó
maior = locaraiz.chave;
//o maior irá receber o valor que tem nesse Nó,caso
//seje maior que maior.
}
if(menor > locaraiz.chave){
//se menor for maior que o valor do Nó atual
menor = locaraiz.chave;
//menor recebe o valor do Nó atual.
}
//passos para o lado direito
if(locaraiz != null){
//se raiz locar nao for nulo
SubDaArvore(locaraiz.filhoDireita);
//caminha para lado direito da arvore
}
if(maior < locaraiz.chave){
//se o maior for menor que o valor do No locar
maior = locaraiz.chave;//armazena o valor
}
if(menor > locaraiz.chave){
//se menor for maior que o valor do Nó atual
menor = locaraiz.chave;
//o menor armazena este valor
}
}
return maior - menor;
}
}
[/code]
[code]package Arvore;
public class TesteArvore {
public static void main(String[] args) {
arvore arvore1 = new arvore();
// arvore1.inOrder(no2);
System.out.println("Subtracao do maior pelo menor valor da arvore:" );
arvore1.SubDaArvore(locaraiz);
}
}
[/code]
qual é o meu erro ?
