Introdução
Uma árvore de pesquisa binária (BST) é um tipo de árvore binária em que cada nó tem no máximo dois filhos, chamados de filho esquerdo e filho direito. Para cada nó, a subárvore esquerda contém apenas nós com valores menores que o valor do nó, e a subárvore direita contém apenas nós com valores maiores que o valor do nó. BSTs são usados ​​para operações eficientes de pesquisa, inserção e exclusão.

Por que usar uma árvore de pesquisa binária?
BSTs oferecem várias vantagens:

Pesquisa eficiente: a complexidade média do tempo é O(log n) para pesquisa, inserção e exclusão.
Conjunto Dinâmico de Itens: Suporta operações dinâmicas, diferentemente de matrizes estáticas.
Elementos ordenados: a travessia em ordem de um BST produz elementos em uma ordem classificada.
Guia passo a passo para construir um BST
Etapa 1: Definir a estrutura do nó
O primeiro passo é definir a estrutura de um nó na árvore. Cada nó terá três atributos: um valor, uma referência ao filho esquerdo e uma referência ao filho direito.

public class TreeNode {
    int value;
    TreeNode left;
    TreeNode right;

    TreeNode(int value) {
        this.value = value;
        this.left = null;
        this.right = null;
    }
}

Etapa 2: Crie a classe BST com construtor
A seguir, criamos a classe BST que contém uma referência à raiz da árvore e os métodos de inserção de elementos.

public class BinarySearchTree {
    TreeNode root;

    public BinarySearchTree() {
        this.root = null;
    }
}

Etapa 3: Implementar o método de inserção
Para inserir um elemento no BST, precisamos encontrar a posição correta do novo nó. O método de inserção geralmente é implementado como uma função recursiva.

public void insert(int value) {
    root = insertRec(root, value);
}

private TreeNode insertRec(TreeNode root, int value) {
    // Base case: if the tree is empty, return a new node
    if (root == null) {
        root = new TreeNode(value);
        return root;
    }

    // Otherwise, recur down the tree
    if (value  root.value) {
        root.right = insertRec(root.right, value);
    }

    // Return the (unchanged) node pointer
    return root;
}

Visualização
Para entender melhor como funciona a inserção, vamos considerar um exemplo. Suponha que queiramos inserir a seguinte sequência de números no BST: 50, 30, 70, 20, 40, 60, 80.

50

  50
 /
30

  50
 /  \
30  70

50
 /  \
30  70
/

Inserir 40:

  50
 /  \
30  70
/ \

Inserir 60

  50
 /  \
30  70
/ \  /

Inserir 80:

  50
 /  \
30  70
/ \  / \

Código Completo
Aqui está o código completo para criar um BST e inserir elementos:

public class BinarySearchTree {
    TreeNode root;

    public BinarySearchTree() {
        this.root = null;
    }

    public void insert(int value) {
        root = insertRec(root, value);
    }

    private TreeNode insertRec(TreeNode root, int value) {
        if (root == null) {
            root = new TreeNode(value);
            return root;
        }

        if (value  root.value) {
            root.right = insertRec(root.right, value);
        }

        return root;
    }

    // Additional methods for traversal, search, and delete can be added here

    public static void main(String[] args) {
        BinarySearchTree bst = new BinarySearchTree();
        int[] values = {50, 30, 70, 20, 40, 60, 80};
        for (int value : values) {
            bst.insert(value);
        }

        // Add code to print or traverse the tree
    }
}

class TreeNode {
    int value;
    TreeNode left;
    TreeNode right;

    TreeNode(int value) {
        this.value = value;
        this.left = null;
        this.right = null;
    }
}