A Binary Tree implementation in Java (recursive with basic functions (insert, remove))

BinaryTree.java

// javac BinaryTree.java
// java BinaryTree

/**
 * Created by Dewes on 13/09/2016.
 */
public class BinaryTree {

    // Nosso nó pai
    private Node node;

    public BinaryTree() {
        // Se o nó pai estiver nulo, inicia-o.
        if (node == null)
            node = new Node(1);
    }

    // Chamadas públicas para os métodos da árvore
    public void insert(int key) {
        insert(this.node, key);
    }

    public Node remove(int key) {
        return remove(this.node, key);
    }

    public void prettyPrinter() {
        prettyPrinter(this.node);
    }

    // Nossa classe Nó, na qual vai possuir seus filhos a esquerda e direita.
    // Cada filho podera possuir mais filhos a esquerda e direita infinitamente.
    static class Node {
        int key;
        Node left;
        Node right;
        public Node() {}
        public Node(int key) {
            this.key = key;
        }

    }

    /*
     * @description Insere um Nó de forma recursiva
     */
    private void insert(Node node, int key) {
        if (node != null) {

            // Se a chave for menor que a chave do nó pai
            if (key < node.key) {

                // Se o nó da esquerda não estiver nulo
                if (node.left != null) {

                    // Chamada recursivo do método, inserir no nó esquerdo a chave desejada
                    insert(node.left, key);
                }
                // Nó esquerdo está nulo
                else {

                    // Insere diretamente na esquerda, iniciando novo nó.
                    System.out.println("_> Insert node "+ key +" at the left of "+ node.key);
                    // Nó pai -> nó esquerdo = novo Nó
                    node.left = new Node(key);
                }
            }
            // Chave é maior que a chave do nó pai
            else if (key > node.key) {

                // se o nó direito não está nulo
                if (node.right != null) {

                    // Chamada recursiva do método para inserir a chave no nó direito do pai
                    insert(node.right, key);
                }
                // Nó direito nulo
                else {

                    // Insere diretamente no nó direito do nó pai.
                    System.out.println("_> Insert node "+ key +" at the right of "+ node.key);
                    node.right = new Node(key);
                }
            }
            // Se a chave a inserir for igual a chave do pai, aborta
            else if (node.key == key) {
                System.out.println("! The children can't have the same key of the father!");
            }
        }
        // Nó pai nulo, não acontece porque iniciamos ele no construtor.
        else {
            System.out.println("! The node can't be null.");
        }
    }

    /*
     * @description Remove um nó de forma recursiva
     *
     */
    private Node remove(Node node, int key) {
        if (node != null) {

            // Se a chave for menor que a chave do pai
            if (key < node.key) {

                // Nó esquerdo do pai recebe a chamada recursiva do método,
                // onde irá reposicionar todos filhos da esquerda
                node.left = remove(node.left, key);
            }

            // Chave maior que a do nó pai
            else if (key > node.key) {

                // Nó direito do pai recebe a chamada recursiva do metodo,
                // onde irá reposicionar todos nós do lado direito.
                node.right = remove(node.right, key);
            }

            // Se a arvore tiver filhos a esquerda e a direita
            else if (node.left != null && node.right != null) {

                // A chave do nó pai recebe a menor chave encontrada nos filhos da esquerda do filho da direita
                System.out.println("_> Remove Node "+ node.key);
                node.key = findMin(node.right).key;

                // Assim depois de reposicionar todos filhos, podemos remover o que sobrou
                node.right = removeMin(node.right);
            }
            else {
                System.out.println("_> Remove Node " + node.key);
                // Caso só exista o nó pai e filhos a esquerda ou direita,
                // a raiz se torna um desses dois.
                // Nó esquerdo nulo ? pai recebe nó esquerdo, se não recebe nó direito.
                node = (node.left != null) ? node.left : node.right;
            }
            return node;
        }
        // Nó nulo, não encontrou a chave.
        else {
            System.out.println("! Don't find any node with key "+ key);
        }
        return null;
    }

    private Node findMin(Node node) {
        if (node != null) {
            while (node.left != null) {
                node = node.left;
            }
        }
        return node;
    }

    private Node removeMin(Node node) {
        if (node != null) {
            if (node.left != null) {
                node.left = removeMin(node.left);
                return node;
            }
            else {
                return node.right;
            }
        }
        return null;
    }

    private void prettyPrinter(Node node) {
        if (node != null) {
            System.out.println("Nó: " + node.key);
            if(node.left != null){
                prettyPrinter(node.left);
            }
            if (node.right != null){
                prettyPrinter(node.right);
            }
        }
        else {
            System.out.println("! Can't print a null or empty node!");
        }
    }

    public static void main(String[] args) {
        BinaryTree bt = new BinaryTree();
        bt.insert(3);
        bt.insert(10);
        bt.insert(9);
        bt.insert(13);
        bt.insert(1);
        bt.prettyPrinter();
        bt.remove(3);
        bt.remove(10);
        bt.remove(13);
        bt.remove(22);
        bt.prettyPrinter();
    }

}