9. 이진트리 구현 - 패스트캠퍼스 백엔드 부트캠프 3기

public class TreeNode<E> {
    E data;
    TreeNode left;
    TreeNode right;
}

public class BinaryTree {
    private TreeNode root;

    public TreeNode makeBinaryTree(TreeNode rootNode) {
        root = rootNode;
        root.left = null;
        root.right = null;

        return root;
    }

    public TreeNode insertLeftChildNodeBT(TreeNode parentNode, TreeNode element) {

        if (parentNode != null && parentNode.left == null) {
            parentNode.left = element;
            parentNode.left.left = null;
            parentNode.left.right = null;

            return parentNode.left;
        }
        else return null;
    }

    public TreeNode insertRightChildNodeBT(TreeNode parentNode, TreeNode element) {

        if (parentNode != null && parentNode.right == null) {
            parentNode.right = element;
            parentNode.right.left = null;
            parentNode.right.right = null;

            return parentNode.right;
        }
        else return null;
    }

    public TreeNode getRootNodeBT() {return root;}

    public TreeNode getLeftChildNodeBT(TreeNode node) {
        if (node != null) {
            return node.left;
        }
        return null;
    }

    public TreeNode getRightChildNodeBT(TreeNode node) {
        if (node != null) {
            return node.right;
        }
        return null;
    }

    public void preorder(TreeNode root) {
        if (root != null) {
            System.out.print(root.data);
            preorder(root.left);
            preorder(root.right);
        }
    }
    public void inorder(TreeNode root) {
        if (root != null) {
            inorder(root.left);
            System.out.print(root.data);
            inorder(root.right);
        }
    }
    public void postorder(TreeNode root) {
        if (root != null) {
            postorder(root.left);
            postorder(root.right);
            System.out.print(root.data);
        }
    }
}

public class BinaryTreeTest {
    public static void main(String[] args) {

        TreeNode<String> nodeA = new TreeNode();
        TreeNode<String> nodeB = new TreeNode();
        TreeNode<String> nodeC = new TreeNode();
        TreeNode<String> nodeD = new TreeNode();
        TreeNode<String> nodeE = new TreeNode();
        TreeNode<String> nodeF = new TreeNode();
        TreeNode<String> nodeG = new TreeNode();
        TreeNode<String> nodeH = new TreeNode();
        TreeNode<String> nodeI = new TreeNode();
        TreeNode<String> nodeJ = new TreeNode();
        TreeNode<String> nodeK = new TreeNode();
        TreeNode<String> nodeL = new TreeNode();
        TreeNode<String> nodeM = new TreeNode();

        BinaryTree binaryTree = new BinaryTree();

        nodeA.data = "A";
        nodeA = binaryTree.makeBinaryTree(nodeA);

        if (nodeA != null) {
            nodeB.data = "B";
            nodeB = binaryTree.insertLeftChildNodeBT(nodeA, nodeB);
            nodeC.data = "C";
            nodeC = binaryTree.insertRightChildNodeBT(nodeA, nodeC);
        }
        if (nodeB != null) {
            nodeD.data = "D";
            nodeD = binaryTree.insertLeftChildNodeBT(nodeB, nodeD);
            nodeE.data = "E";
            nodeE = binaryTree.insertRightChildNodeBT(nodeB, nodeE);
        }
        if (nodeC != null) {
            nodeF.data = "F";
            nodeF = binaryTree.insertLeftChildNodeBT(nodeC, nodeF);
            nodeG.data = "G";
            nodeG = binaryTree.insertRightChildNodeBT(nodeC, nodeG);
        }
        if (nodeD != null) {
            nodeH.data = "H";
            nodeH = binaryTree.insertLeftChildNodeBT(nodeD, nodeH);
            nodeI.data = "I";
            nodeI = binaryTree.insertRightChildNodeBT(nodeD, nodeI);
        }
        if (nodeE != null) {
            nodeJ.data = "J";
            nodeJ = binaryTree.insertLeftChildNodeBT(nodeE, nodeJ);
        }
        if (nodeF != null) {
            nodeK.data = "K";
            nodeK = binaryTree.insertRightChildNodeBT(nodeF, nodeK);
        }
        if (nodeG != null) {
            nodeL.data = "L";
            nodeL = binaryTree.insertLeftChildNodeBT(nodeG, nodeL);
            nodeM.data = "M";
            nodeM = binaryTree.insertRightChildNodeBT(nodeG, nodeM);
        }

        binaryTree.preorder(nodeA);
        System.out.println();
        binaryTree.inorder(nodeA);
        System.out.println();
        binaryTree.postorder(nodeA);
    }
}