Introducción
Un árbol de búsqueda binaria (BST) es un tipo de árbol binario donde cada nodo tiene como máximo dos hijos, denominados hijo izquierdo y hijo derecho. Para cada nodo, el subárbol izquierdo contiene solo nodos con valores menores que el valor del nodo, y el subárbol derecho contiene solo nodos con valores mayores que el valor del nodo. Los BST se utilizan para operaciones eficientes de búsqueda, inserción y eliminación.

¿Por qué utilizar un árbol de búsqueda binario?
Los BST ofrecen varias ventajas:

Búsqueda eficiente: la complejidad del tiempo promedio es O(log n) para búsqueda, inserción y eliminación.
Conjunto dinámico de elementos: admite operaciones dinámicas, a diferencia de las matrices estáticas.
Elementos ordenados: el recorrido en orden de un BST produce elementos en un orden ordenado.
Guía paso a paso para crear un BST
Paso 1: Definir la estructura del nodo
El primer paso es definir la estructura de un nodo en el árbol. Cada nodo tendrá tres atributos: un valor, una referencia al hijo izquierdo y una referencia al hijo derecho.

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

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

Paso 2: Crear la clase BST con Constructor
A continuación, creamos la clase BST que contiene una referencia a la raíz del árbol y los métodos para insertar elementos.

public class BinarySearchTree {
    TreeNode root;

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

Paso 3: Implementar el método de inserción
Para insertar un elemento en el BST, necesitamos encontrar la posición correcta para el nuevo nodo. El método de inserción generalmente se implementa como una función 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;
}

Visualización
Para comprender mejor cómo funciona la inserción, consideremos un ejemplo. Supongamos que queremos insertar la siguiente secuencia de números en el BST: 50, 30, 70, 20, 40, 60, 80.

50

  50
 /
30

  50
 /  \
30  70

50
 /  \
30  70
/

Insertar 40:

  50
 /  \
30  70
/ \

Insertar 60

  50
 /  \
30  70
/ \  /

Insertar 80:

  50
 /  \
30  70
/ \  / \

Código completo
Aquí está el código completo para crear un BST e insertar 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;
    }
}