Dataset-Netflix-Java/BST.java

public class BST {
    private Node root;
    // necessario para verificacao de quantos nos visitados pela funcao search
    // (desempenho)
    private int count = 0;

    // Construtor
    public BST() {
        this.root = null;
    }

    public int getCount() {
        return count;
    }

    // Métodos de inserção e busca
    public void insert(ProgramaNetflix programa) {
        root = insertRec(root, programa);
    }

    // Método para encontrar o valor mínimo na árvore
    public ProgramaNetflix minValue() {
        return minValue(root);
    }

    public void cleanup() {
        cleanupRec(root);
        root = null;
    }

    private void cleanupRec(Node node) {
        if (node != null) {
            cleanupRec(node.left);
            cleanupRec(node.right);
            remove(node.programa.getId());
        }
    }

    private Node insertRec(Node root, ProgramaNetflix programa) {
        if (root == null) {
            root = new Node(programa);
            return root;
        }

        // Adicione a lógica de comparação para decidir em qual subárvore inserir
        if (programa.getId().compareTo(root.programa.getId()) < 0) {
            root.left = insertRec(root.left, programa);
        } else if (programa.getId().compareTo(root.programa.getId()) > 0) {
            root.right = insertRec(root.right, programa);
        }

        return root;
    }

    public String search(String id) {
        count = 1;
        ProgramaNetflix programa = searchRec(root, id);

        if (programa != null) {
            return programa.getTitulo();
        } else {
            return "";
        }
    }

    private ProgramaNetflix searchRec(Node root, String id) {
        count++;
        // Caso base: a árvore ou subárvore está vazia ou encontramos o nó com o ID
        // correspondente
        if (root == null || root.programa.getId().equals(id)) {
            return (root != null) ? root.programa : null;
        }

        // Se o ID a ser pesquisado for menor que o ID do nó atual, busca na subárvore
        // esquerda
        if (id.compareTo(root.programa.getId()) < 0) {
            return searchRec(root.left, id);
        }

        // Se o ID a ser pesquisado for maior que o ID do nó atual, busca na subárvore
        // direita
        return searchRec(root.right, id);
    }

    // Método para calcular a altura da árvore
    public int height() {
        return height(root);
    }

    // Método privado para calcular a altura da árvore
    private int height(Node root) {
        if (root == null) {
            return -1; // Árvore vazia tem altura -1
        }

        int leftHeight = height(root.left);
        int rightHeight = height(root.right);

        // A altura da árvore é o máximo entre as alturas das subárvores esquerda e
        // direita
        return Math.max(leftHeight, rightHeight) + 1;
    }

    public boolean remove(String id) {
        if (search(id).isEmpty()) {
            return false;
        }
        root = removeRec(root, id);
        return true;
    }

    private Node removeRec(Node root, String id) {
        // Caso base: árvore ou subárvore está vazia
        if (root == null) {
            return root;
        }

        // Encontra o nó a ser removido
        if (id.compareTo(root.programa.getId()) < 0) {
            root.left = removeRec(root.left, id);
        } else if (id.compareTo(root.programa.getId()) > 0) {
            root.right = removeRec(root.right, id);
        } else {
            // Nó com um filho ou sem filhos
            if (root.left == null) {
                return root.right;
            } else if (root.right == null) {
                return root.left;
            }
            // Nó com dois filhos: encontra o sucessor in-order (menor nó na subárvore
            // direit)
            root.programa = minValue(root.right);

            // Remove o sucessor in-order
            root.right = removeRec(root.right, root.programa.getId());
        }

        return root;
    }

    private ProgramaNetflix minValue(Node root) {
        // O valor mínimo é o nó mais à esquerda na árvore
        while (root.left != null) {
            root = root.left;
        }
        return root.programa;
    }

    // Classe interna Node para representar os nós da árvore
    private class Node {
        private ProgramaNetflix programa;
        private Node left;
        private Node right;

        public Node(ProgramaNetflix programa) {
            this.programa = programa;
            this.left = null;
            this.right = null;
        }
    }
}