Estruturas de dados em Java - Como fazer a travessia de uma árvore binária de busca em Java usando o percurso em-ordem (in-order, In-ordem ou ordem simétrica)

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package arvore_binaria;

public class No {
  private int valor; // valor armazenado no nó
  private No esquerdo; // filho esquerdo
  private No direito; // filho direito
 
  // construtor do nó
  public No(int valor){
    this.valor = valor;
    this.esquerdo = null;
    this.direito = null;
  }

  public int getValor() {
    return valor;
  }

  public void setValor(int valor) {
    this.valor = valor;
  }

  public No getEsquerdo() {
    return esquerdo;
  }

  public void setEsquerdo(No esquerdo) {
    this.esquerdo = esquerdo;
  }

  public No getDireito() {
    return direito;
  }

  public void setDireito(No direito) {
    this.direito = direito;
  }
}

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package arvore_binaria;

public class ArvoreBinariaBusca {
  private No raiz; // referência para a raiz da árvore
   
  // método usado para inserir um novo nó na árvore
  // retorna true se o nó for inserido com sucesso e false
  // se o elemento
  // não puder ser inserido (no caso de já existir um 
  // elemento igual)
  public boolean inserir(int valor){
    // a árvore ainda está vazia?
    if(raiz == null){
      // vamos criar o primeiro nó e definí-lo como a raiz da árvore
      raiz = new No(valor); // cria um novo nó
    }
    else{
      // localiza o nó pai do novo nó
      No pai = null;
      No noAtual = raiz; // começa a busca pela raiz
  
      // enquanto o nó atual for diferente de null
      while(noAtual != null){
        // o valor sendo inserido é menor que o nó atual?
        if(valor < noAtual.getValor()) {
          pai = noAtual;
          // vamos inserir do lado esquerdo
          noAtual = noAtual.getEsquerdo();
        }
        // o valor sendo inserido é maior que o nó atual
        else if(valor > noAtual.getValor()){
          pai = noAtual;
          // vamos inserir do lado direito
          noAtual = noAtual.getDireito();
        }
        else{
          return false; // um nó com este valor foi encontrado
        }
      }
        
      // cria o novo nó e o adiciona como filho do nó pai
      if(valor < pai.getValor()){
         pai.setEsquerdo(new No(valor));
      }
      else{
        pai.setDireito(new No(valor));
      }
    }
 
    return true; // retorna true para indicar que o novo nó foi inserido
  }
   
  // método que permite disparar a travessia em-ordem
  public void emOrdem(){
    emOrdem(raiz);
  }
 
  // sobrecarga do método emOrdem com uma parâmetro (esta é a versão 
  // recursiva do método)
  private void emOrdem(No raiz){
    if(raiz == null){ // condição de parada
      return;
    }
     
    // visita a sub-árvore da esquerda
    emOrdem(raiz.getEsquerdo());
    // visita o nó atual
    System.out.print(raiz.getValor() + " ");
    // visita a sub-árvore da direita
    emOrdem(raiz.getDireito());
  }
}

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package arvore_binaria;

import java.util.Scanner;

public class ArvoreBinariaTeste {
  public static void main(String[] args) {
    Scanner entrada = new Scanner(System.in);  
       
    // vamos criar um novo objeto da classe ArvoreBinariaBusca
    ArvoreBinariaBusca arvore = new ArvoreBinariaBusca();
    
    // vamos inserir 9 valores na árvore
    for(int i = 0; i < 9; i++){
      System.out.print("Informe um valor inteiro: ");
      int valor = Integer.parseInt(entrada.nextLine());
       
      // vamos inserir o nó e verificar o sucesso da operação
      if(!arvore.inserir(valor)){
        System.out.println("Não foi possível inserir." +
          " Um elemento já contém este valor.");  
      }
    }
     
    // vamos exibir os nós da árvore usando o percurso in-order
    System.out.println("\nPercurso in-order:");
    arvore.emOrdem();
     
    System.out.println("\n");
  }
}

Informe um valor inteiro: 8
Informe um valor inteiro: 3
Informe um valor inteiro: 10
Informe um valor inteiro: 1
Informe um valor inteiro: 6
Informe um valor inteiro: 14
Informe um valor inteiro: 4
Informe um valor inteiro: 7
Informe um valor inteiro: 13

Percurso in-order:
1 3 4 6 7 8 10 13 14