Como criar uma árvore binária de busca em Java a partir dos elementos de um vetor de inteiros - Desafio de Programação Resolvido em Java

// vamos declarar um vetor de 10 inteiros
// sem repetição
int valores[] = {5, 1, 19, 7, 25, 8, 3, 40, 2, 6};

Valores do array: [5, 1, 19, 7, 25, 8, 3, 40, 2, 6]
Valores na árvores binária: 1 2 3 5 6 7 8 19 25 40

----------------------------------------------------------------------
Precisa de ajuda? Chama no WhatsApp +55 (62) 98553-6711 (Osmar)

Este código foi útil? Paga um cafezinho pra mim :-(
PIX: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

package estudos;

import java.util.Arrays;

// classe interna para representar os nós da
// árvore binária
class No {
  int valor; // valor armazenado no nó
  No esquerdo; // filho esquerdo
  No direito; // filho direito
  
  // construtor do nó
  public No(int valor){
    this.valor = valor;
    this.esquerdo = null;
    this.direito = null;
  }
}

public class Estudos { 
  // referência para a raiz da árvore
  static No raiz;
  
  public static void main(String args[]){
    // vamos declarar um vetor de 10 inteiros
    // sem repetição
    int valores[] = {5, 1, 19, 7, 25, 8, 3, 40, 2, 6};
    
    // vamos mostrar os valores do vetor
    System.out.println("Valores do array: " + 
      Arrays.toString(valores));
    
    // vamos percorrer os valores do vetor e adicioná-los
    // à arvore binária
    for (int i = 0; i < valores.length; i++) {
      inserir(valores[i]);
    }
    
    // agora vamos exibir os valores já inseridos na
    // árvore binária usando o percurso "Em Ordem", que
    // devolve os nós da árvore ordenados em ordem
    // crescente
    System.out.print("Valores na árvores binária: ");
    em_ordem();
    System.out.println();
  }
  
  // função usada 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 static 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 no_atual = raiz; // começa a busca pela raiz
   
      // enquanto o nó atual for diferente de null
      while(no_atual != null){
        // o valor sendo inserido é menor que o nó atual?
        if(valor < no_atual.valor) {
          pai = no_atual;
          // vamos inserir do lado esquerdo
          no_atual = no_atual.esquerdo;
        }
        // o valor sendo inserido é maior que o nó atual
        else if(valor > no_atual.valor){
          pai = no_atual;
          // vamos inserir do lado direito
          no_atual = no_atual.direito;
        }
        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.valor){
         pai.esquerdo = new No(valor);
      }
      else{
        pai.direito = new No(valor);
      }
    }
  
    // retorna true para indicar que o novo nó foi inserido
    return true; 
  }

  // função que permite disparar a travessia em-ordem
  public static void em_ordem(){
    em_ordem(raiz);
  }
  
  // sobrecarga da função em ordem com uma parâmetro (esta é a versão 
  // recursiva da função)
  private static void em_ordem(No raiz){
    if(raiz == null){ // condição de parada
      return;
    }
      
    // visita a sub-árvore da esquerda
    em_ordem(raiz.esquerdo);
    // visita o nó atual
    System.out.print(raiz.valor + " ");
    // visita a sub-árvore da direita
    em_ordem(raiz.direito);
  }
}