Java Binary Tree

Node.java

public class Node {
    private Ty Data;
    private Node right_Child;
    private Node left_Child;
    private Node parent;

    Node(Ty data)
    {
        Data=data;
        right_Child=null;
        left_Child=null;
        parent=null;
    }

    public Node getParent() {
        return parent;
    }

    public void setParent(Node parent) {
        this.parent = parent;
    }
    public Node getRight()
    {
        return right_Child;
    }
    public Node getLeft()
    {
        return left_Child;
    }

    public Ty getData()
    {
        return Data;
    }
    public void setRight(Node node)
    {
        right_Child=node;
    }
    public void setLeft(Node node)
    {
        left_Child=node;
    }

    public void setData(Ty data)
    {
        Data = data;
    }

}

BinSearchTree.java

import java.util.*;

public class BinSearchTree  {

    public int compare(Ty o1, Ty o2) {

        return o1.compareTo(o2);
    }
    private Node ROOT;
    private Node NullNode = new Node(null);

    BinSearchTree() {
        ROOT = NullNode;
    }

    public boolean insert(Ty data) {

        if (ROOT == NullNode) {
            ROOT = makeNode(data,NullNode);
            return true;
        } else {
            Node nextNode = ROOT;
            while (true) {

                if (compare(nextNode.getData(), data) > 0) {
                    if (nextNode.getLeft() == NullNode) {
                        nextNode.setLeft(makeNode(data,nextNode));
                        return true;
                    }
                    nextNode = nextNode.getLeft();

                } else if (compare(nextNode.getData(), data) < 0) {
                    if (nextNode.getRight() == NullNode) {
                        nextNode.setRight(makeNode(data,nextNode));
                        return true;
                    }
                    nextNode = nextNode.getRight();
                } else {
                    Show("중복되는 데이터 입니다.");
                    return false;
                }
            }
        }

    }

    public boolean delete(Ty data) {
        if(ROOT==NullNode)
        {
            Show("트리가 비어 있습니다.");
            return false;
        }
        Node nextNode = ROOT;
        while (true) {
            if (compare(nextNode.getData(), data) > 0) {
                if (nextNode.getLeft() == NullNode) {
                    Show("삭제할 값이 없습니다.");
                    return false;
                }
                nextNode = nextNode.getLeft();

            } else if (compare(nextNode.getData(), data) < 0) {
                if (nextNode.getRight() == NullNode) {
                    Show("삭제할 값이 없습니다.");
                    return false;
                }
                nextNode = nextNode.getRight();
            } else {
                if( nextNode.getLeft()==NullNode && nextNode.getRight()==NullNode)
                {
                    // When Target Node is  Leaf Node.
                    if(nextNode.getParent().getRight()==nextNode) {
                        nextNode.getParent().setRight(NullNode);
                        return true;
                    } else {
                        nextNode.getParent().setLeft(NullNode);
                        return true;
                    }
                } else if(nextNode.getLeft()!=NullNode && nextNode.getRight()!=NullNode){
                    // When Target Node has Two Children.
                    Node exchangeNode = nextNode.getLeft();
                    while(exchangeNode.getRight()!=NullNode){
                        exchangeNode= exchangeNode.getRight();
                    }
                    delete(exchangeNode.getData());
                    nextNode.setData(exchangeNode.getData());
                    return true;
                }else {
                    // When Target Node has a Child.
                    if(nextNode.getLeft()==NullNode && nextNode.getRight()!=NullNode)  {
                        if(nextNode.getParent().getRight()==nextNode){
                        nextNode.getParent().setRight(nextNode.getRight());
                        } else nextNode.getParent().setLeft(nextNode.getRight());
                        nextNode.getRight().setParent(nextNode.getParent());
                        return true;
                    } else {
                        if(nextNode.getParent().getLeft()==nextNode){
                        nextNode.getParent().setLeft(nextNode.getLeft());
                        } else nextNode.getParent().setRight(nextNode.getLeft());
                        nextNode.getLeft().setParent(nextNode.getParent());
                        return true;
                    }

                }
            }
        }
    }

    public void preorder(Node node) {
        if (node == NullNode) {
            return;
        } else {
            System.out.print(node.getData() + " ");
            preorder(node.getLeft());
            preorder(node.getRight());
        }
    }

    public void inorder(Node node) {
        if (node == NullNode) {
            return;
        } else {
            inorder(node.getLeft());
            System.out.print(node.getData() + " ");
            inorder(node.getRight());
        }
    }

    public void postorder(Node node) {
        if (node == NullNode) {
            return;
        } else {
            postorder(node.getLeft());
            postorder(node.getRight());
            System.out.print(node.getData() + " ");
        }
    }

    public Node getRoot() {
        return ROOT;
    }

    public void Show(String s)
    {

    }

    public Node makeNode(Ty data,Node parent) {
        Node n = new Node(data);
        n.setLeft(NullNode);
        n.setRight(NullNode);
        n.setParent(parent);
        return n;
    }
}