aufgabe3 4real

import java.util.ArrayList;
import java.util.List;

/**
 * ## Binärbäume rekursiv verarbeiten
 *
 * Gegeben sei die Klasse `Node` mit der Binärbäume gebildet werden können, die
 * Zeichenketten als Werte speichern können.
 *
 * Entwickeln Sie nun bitte die folgenden Methoden:
 *
 * - `serialize()`: Erzeugt eine Liste in dem der Baum inorder durchlaufen wird.
 * - `count()`: Liefert die Anzahl an Knoten in einem Baum. - `depth()`: Liefert
 * die maximale Tiefe eines Baums. - `longest()`: Findet das längste (im Baum am
 * tiefsten rechts stehende) Wort.
 *
 * Sie finden Aufrufbeispiele in der `main()`-Methode.
 *
 * __Hinweis__:
 *
 * - Sehen Sie sich noch einmal die Inhalte zu rekursiven Datenstrukturen der
 * Unit 05 an.
 *
 * __Verbote__:
 *
 * - Sie sollen rekursiv programmieren, d.h. Schleifen aller Art sind verboten.
 *
 */
class Main {

    public static void main(String[] args) {
        Node tree = new Node("f", new Node("o", new Node("C", new Node("tasty"), null), new Node("F")),
                new Node("E", null, new Node("e")));
        // Hinweis, der Evaluator wird diesen Baum in folgender
        // Notation ausgeben (Pattern: %value[%left,%right])
        // <f[o[C[tasty,null],F],E[null,e]]>

        List<String> serialized = serialize(tree);
        System.out.println(serialized); // => [tasty, C, o, F, f, E, e]
        System.out.println(count(tree)); // => 7
        System.out.println(longest(tree)); // => tasty
        System.out.println(depth(tree)); // => 4
    }

    public static int depth(Node tree) {
        if (tree == null)
            return 0;
        return 1 + Math.max(depth(tree.left), depth(tree.right));
    }

    public static String longest(Node tree) {
        if (tree == null)
            return "";

        String s = tree.value;

        if (tree.left != null) {
            if (tree.left.value.length() >= s.length()) {
                s = longest(tree.left);
            }
        }
        if (tree.right != null) {
            if (tree.right.value.length() >= s.length()) {
                s = longest(tree.right);
            }
        }
        return s;

    }

    public static int count(Node tree) {
        if (tree == null)
            return 0;
        return 1 + count(tree.left) + count(tree.right);
    }

    public static List<String> serialize(Node tree) {

        List<String> treeList = new ArrayList<>();
        if (tree == null)
            return treeList;
        if (tree.left == null && tree.right == null) {
            treeList.add(tree.value);
            return treeList;
        }
        if (tree.left != null)
            treeList.addAll(serialize(tree.left));

        treeList.add(tree.value);
        if (tree.right != null)
            treeList.addAll(serialize(tree.right));

        return treeList;
    }
}