import java.util.Random;

/**
 * Implementierungen der drei Traversierungsarten auf
 * Binärbäumen mit Zahl-Inhalten.
 */
public class Traversierungen {

    private BinaryTree<Integer> root;

    public Traversierungen() {
        // Erstellen eines Integer-Baumes mit
        // 15 Knoten
        // 0.5 Prozent der Knoten werden im linken Teilbaum generiert
        // wobei zufällig ca. 20 Prozent der Knoten doch rechts einsortiert werden
        root = Trees.generateIntegerTree(3, 0.5, 10);
    }

    /**
     * Aufruf für die Preorder-Traversierung.
     *
     * @see #preorder(BinaryTree)
     */
    public void preorder() {
        preorder(root);
    }

    /**
     * Rekursive Methode für die Preorder-Traversierung.
     * @param pRoot Der Wurzelknoten des aktuellen Teilbaumes.
     */
    public void preorder( BinaryTree<Integer> pRoot ) {
        // TODO: Ausgabe das Baumes auf der Kommandozeile in Preorder
    }
    
    public void printHirarchical() {
        printHirarchical(root, 0);
    }
    
    public void printHirarchical(BinaryTree<Integer> pRoot, int xOff) {
        if (pRoot.getContent() == null) {
            xOff--;
            return;
        }
        if (pRoot.getLeftTree() != null) {
            printOffset(xOff);
            System.out.println(pRoot.getContent());
            xOff++;
            printHirarchical(pRoot.getLeftTree(), xOff);
        }
        if (pRoot.getRightTree() != null) {
            printOffset(xOff);
            System.out.println(pRoot.getContent());
            xOff++;
            printHirarchical(pRoot.getRightTree(), xOff);
        }
    }
    
    private void printOffset(int off) {
        for (int i = 0; i < off; i++) {
            if (i == off - 1) {
                System.out.print("|> ");
            } else {
                System.out.print("|  ");
            }
        }
    }

    /**
     * Aufruf für die Postorder-Traversierung.
     *
     * @see #postorder(BinaryTree)
     */
    public void postorder() {
        postorder(root);
    }

    /**
     * Rekursive Methode für die Postorder-Traversierung.
     * @param pRoot Der Wurzelknoten des aktuellen Teilbaumes.
     */
    public void postorder( BinaryTree<Integer> pRoot ) {
        // TODO: Ausgabe das Baumes auf der Kommandozeile in Postorder
    }

    /**
     * Aufruf für die Inorder-Traversierung.
     *
     * @see #inorder(BinaryTree)
     */
    public void inorder() {
        inorder(root);
    }

    /**
     * Rekursive Methode für die Inorder-Traversierung.
     * @param pRoot Der Wurzelknoten des aktuellen Teilbaumes.
     */
    public void inorder( BinaryTree<Integer> pRoot ) {
        // TODO: Ausgabe das Baumes auf der Kommandozeile in Inorder
    }
    
    /**
     * Findet das Maximum im Baum.
     */
    public int findMax() {
        return 0;
    }
    
    /**
     * Addiert pNum zu jedem Wert im Binärbaum.
     */
    public void add( int pNum ) {

    }
}