이진탐색트리 - Java

Parent가 있는 이진탐색트리.

public class MyBST {
    public static class Node<T> {
        T data;

        Node<T> parent;
        Node<T> left;
        Node<T> right;

        public Node(T data) {
            this.data = data;
        }

        public void replaceChild(Node<T> org, Node<T> replace){
            if(left == org) left = replace;
            else if(right == org) right = replace;
            else return;

            org.parent = null;

            if(replace != null)
                replace.parent = this;
        }

        public void release(){
            this.data = null;
            this.parent = null;
            this.left = null;
            this.right = null;
        }

        public String toString(){
            return "N " + data;
        }
    }

    public static class Tree<T extends Comparable> {
        Node<T> root;

        public void insert(T data) {
            Node<T> insert = new Node<T>(data);
            if(root == null) root = insert;
            else insert(root, insert);
        }

        public void insert(Node<T> node, Node<T> insert){
            if(insert.data.compareTo(node.data) < 0){
                if(node.left == null){
                    node.left = insert;
                    insert.parent = node;
                }else{
                    insert(node.left, insert);
                }
            }else{
                if(node.right == null){
                    node.right = insert;
                    insert.parent = node;
                }else{
                    insert(node.right, insert);
                }
            }
        }

        private Node<T> getMinNode(Node<T> from){
            if(from == null) return null;
            while(from.left != null) from = from.left;
            return from;
        }

        public void remove(T data){
            Node<T> node = find(data);
            if(node == null) return;

            Node<T> replace = null;

            if(node.left != null && node.right != null){
                replace = getMinNode(node.right);
                if(replace.right != null){
                    replace.parent.replaceChild(replace, replace.right);
                }
                node.left.parent = replace;
                node.right.parent = replace;

                replace.parent = node.parent;
                replace.left = node.left;
                replace.right = node.right;
            }else{
                replace = node.left != null ? node.left : node.right;
            }

            if(node.parent != null)
                node.parent.replaceChild(node, replace);

            if(node == root) root = replace;

            node.release();
        }

        public void traversal(Consumer<T> consumer) {
            traversal(root, consumer);
        }

        public void print(){
            System.out.print("tree : ");
            traversal(data->System.out.print(data + ", "));
            System.out.println(" end");
        }

        private void traversal(Node<T> node, Consumer<T> consumer) {
            if (node != null) {
                traversal(node.left, consumer);
                consumer.accept(node.data);
                traversal(node.right, consumer);
            }
        }

        private Node<T> find(T data) {
            if (root == null) return null;

            Node<T> node = root;
            while (node != null) {
                int compare = data.compareTo(node.data);
                if (compare == 0) break;
                else if (compare > 0) node = node.right;
                else if (compare < 0) node = node.left;
            }

            return node;
        }
    }
}