[Resolvido] Duvida, ao retornar valor da subtracao da arvore

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

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

	}

}