package labBST;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

class Node {
    int val;
    Node left;
    Node right;
    Node parent;
}

public class Assignment {
    public enum TraversalOrder {
        InOrderTrav, PreOrderTrav, PostOrderTrav
    }

    public static class BST {
        private Node root;

        public BST() {
            root = null;
        }

        public void insert(int toInsert) {
            // Insert the provided element into the tree
            Node newNode = new Node();
            newNode.val = toInsert;
            if (root == null) {
                root = newNode;
                return;
            }
            Node parent = root;
            while (newNode.parent == null) {
                if (toInsert < parent.val) {
                    if (parent.left == null) {
                        parent.left = newNode;
                        newNode.parent = parent;
                    } else {
                        parent = parent.left;
                    }
                } else {
                    if (parent.right == null) {
                        parent.right = newNode;
                        newNode.parent = parent;
                    } else {
                        parent = parent.right;
                    }
                }
            }
        }

        public void delete(int toDelete) {
            // Delete the provided element from the tree
            Node toDeleteNode = root;

            while (toDeleteNode != null && toDeleteNode.val != toDelete) {
                if (toDelete < toDeleteNode.val) {
                    toDeleteNode = toDeleteNode.left;
                } else {
                    toDeleteNode = toDeleteNode.right;
                }
            }
            // case 0: Node not found or tree is empty
            if (toDeleteNode == null) {
                return;
            }

            // case 1: Node has no children
            if (toDeleteNode.left == null && toDeleteNode.right == null) {
                if (toDeleteNode.parent == null) {
                    root = null;
                } else if (toDeleteNode.parent.left == toDeleteNode) {
                    toDeleteNode.parent.left = null;
                } else {
                    toDeleteNode.parent.right = null;
                }
                return;
            }

            // case 2: Node has one child
            if (toDeleteNode.left == null || toDeleteNode.right == null) {
                Node child = toDeleteNode.left == null ? toDeleteNode.right : toDeleteNode.left;
                if (toDeleteNode.parent == null) {
                    root = child;
                } else if (toDeleteNode.parent.left == toDeleteNode) {
                    toDeleteNode.parent.left = child;
                } else {
                    toDeleteNode.parent.right = child;
                }
                return;
            }

            // case 3: Node has two children
            Node successor = toDeleteNode.right;
            while (successor.left != null) {
                successor = successor.left;
            }
            // remove successor from its current position
            if (successor.parent.left == successor) {
                successor.parent.left = successor.right;
            } else {
                successor.parent.right = successor.right;
            }
            // replace toDeleteNode with successor
            successor.parent = toDeleteNode.parent;
            successor.left = toDeleteNode.left;
            successor.right = toDeleteNode.right;
            if (toDeleteNode.parent == null) {
                root = successor;
            } else if (toDeleteNode.parent.left == toDeleteNode) {
                toDeleteNode.parent.left = successor;
            } else {
                toDeleteNode.parent.right = successor;
            }
        }


        public void print(TraversalOrder order) {
            switch (order) {
            case InOrderTrav:
                inOrder(root);
                break;
            case PreOrderTrav:
                preOrder(root);
                break;
            case PostOrderTrav:
                postOrder(root);
                break;
            }
        }

        private void inOrder(Node curr) {
            // Print the elements in the tree one on each line
            if (curr == null) {
                return;
            }
            inOrder(curr.left);
            System.out.println(curr.val);
            inOrder(curr.right);
        }

        private void preOrder(Node curr) {
            // Print the elements in the tree one on each line
            if (curr == null) {
                return;
            }
            System.out.println(curr.val);
            preOrder(curr.left);
            preOrder(curr.right);
        }

        private void postOrder(Node curr) {
            // Print the elements in the tree one on each line
            if (curr == null) {
                return;
            }
            postOrder(curr.left);
            postOrder(curr.right);
            System.out.println(curr.val);
        }
    }

    public static void run(String inputPath) {
        try (BufferedReader br = new BufferedReader(new FileReader(inputPath))) {

            BST bst = new BST();
            while (true) {
                String instruction = br.readLine().trim();
                if (instruction.length() < 1 || instruction.charAt(0) == 'e') {
                    break;
                } else if (instruction.charAt(0) == 'i') {
                    int element = Integer.parseInt(instruction.substring(1));
                    bst.insert(element);
                } else if (instruction.charAt(0) == 'd') {
                    int element = Integer.parseInt(instruction.substring(1));
                    bst.delete(element);
                } else if (instruction.charAt(0) == 'o') {
                    String orderType = instruction.substring(1);
                    if (orderType.equals("in")) {
                        bst.print(TraversalOrder.InOrderTrav);
                    } else if (orderType.equals("pre")) {
                        bst.print(TraversalOrder.PreOrderTrav);
                    } else if (orderType.equals("post")) {
                        bst.print(TraversalOrder.PostOrderTrav);
                    } else {
                        System.out.println("Unknown Traversal Type: " + orderType);
                    }
                } else {
                    System.out.println("Unknown instruction: " + instruction);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        run("");
    }
}