Riešenia (skupina D, 4. týždeň)

import java.util.*;

public class Osoba {
        private String meno;
        private List<Osoba> deti = new ArrayList<Osoba>();

        public Osoba(String meno) {
                this.meno = meno;
        }


        public void pridajDieta(Osoba dieta) {
                deti.add(dieta);
        }

        public int pocetGeneracii() {
                int vysledok = 1;

                for (Osoba dieta : deti) {
                        vysledok = Math.max(vysledok, 1+dieta.pocetGeneracii());
                }

                return vysledok;
        }

        public void pridajDoZoznamu(List<Osoba> zoznam){
                zoznam.add(this);

                for(Osoba dieta: deti){
                        dieta.pridajDoZoznamu(zoznam);
                }

        }

        public static void main(String[] args) {
                Osoba janko = new Osoba("Janko");
                Osoba jozko = new Osoba("Jozko");
                Osoba maria = new Osoba("Maria");
                Osoba karol = new Osoba("Karol");
                Osoba lucia = new Osoba("Lucia");
                Osoba petra = new Osoba("Petra");
                janko.pridajDieta(jozko);
                janko.pridajDieta(maria);
                janko.pridajDieta(karol);
                karol.pridajDieta(lucia);
                karol.pridajDieta(petra);

                List<Osoba> zoznam = new ArrayList<>();
                maria.pridajDoZoznamu(zoznam);

                for (int i = 0; i < zoznam.size(); i++) {
                        System.out.println(zoznam.get(i).meno);

                }

                System.out.println(janko.pocetGeneracii());
        }
}

/**
 * Trieda reprezentujuca uzol binarneho stromu
 */
public class Uzol {
        /**
         * Hodnota ulozena v uzle stromu
         */
        private int hodnota;

        /**
         * Referencia na laveho syna uzla (koren laveho podstromu)
         */
        private Uzol lavy;

        /**
         * Referencia na praveho syna uzla (koren praveho podstromu)
         */
        private Uzol pravy;

        /**
         * Konstruktor uzla binarneho stromu
         *
         * @param hodnota
         * @param lavy
         * @param pravy
         */
        public Uzol(int hodnota, Uzol lavy, Uzol pravy) {
                this.hodnota = hodnota;
                this.lavy = lavy;
                this.pravy = pravy;
        }

        /**
         * Vypise obsah uzlov stromu, ktoreho korenom je tento vrchol. Realizuje
         * preorder prechod.
         */
        public void vypis() {
                // Vypiseme hodnotu
                System.out.println(hodnota);

                // Ak je lavy syn, poziadame ho o vypis hodnot laveho podstromu
                if (lavy != null)
                        lavy.vypis();

                // Ak je pravy syn, poziadame ho o vypis hodnot praveho podstromu
                if (pravy != null)
                        pravy.vypis();
        }

        /**
         * Vrati maximum v strome, ktoreho je tento uzol korenom
         */
        public int maximum() {
                // Predpokladame, ze maximum je hodnota v tomto uzle
                int vysledok = hodnota;

                // Ak je lavy syn, vyberieme bud maximum z laveho podstromu
                // alebo hodnotu v tomto uzle - podla toho, co je vacsie
                if (lavy != null)
                        vysledok = Math.max(vysledok, lavy.maximum());

                // Ak je pravy syn, skusime, ci maximum v pravom podstrome nie je
                // vacsie
                if (pravy != null)
                        vysledok = Math.max(vysledok, pravy.maximum());

                return vysledok;
        }

        /**
         * Zisti, ci sa zadana hodnota nachadza v strome, ktoreho je tento uzol
         * korenom
         *
         * @param hladany
         *            hladana hodnota
         */
        public boolean obsahuje(int hladany) {
                // Ak je hladana hodnota v tomto uzle, koncime ihned
                if (hodnota == hladany)
                        return true;

                // Ak je lavy syn, skusime, ci hladana hodnota nie je v podstrome,
                // ktoreho je lavy syn korenom
                if (lavy != null)
                        if (lavy.obsahuje(hladany))
                                return true;

                // Ak je pravy syn, skusime, ci hladana hodnota nie je v podstrome,
                // ktoreho je pravy syn korenom
                if (pravy != null)
                        if (pravy.obsahuje(hladany))
                                return true;

                return false;
        }

        public int getHodnota() {
                return hodnota;
        }

        public void setHodnota(int hodnota) {
                this.hodnota = hodnota;
        }

        public static Uzol stromZRetazca(String opisStromu) {

                opisStromu.trim();

                if (opisStromu == null) {
                         return null;
                }

                int pocetZatvoriek = 0;
                int lavyZacIdx = 0;
                int lavyKonIdx = 0;
                int pravyZacIdx = 0;
                int pravyKonIdx = opisStromu.length() - 1;
                int korenZacIdx = 0;
                int korenKonIdx = 0;

                for (int i = 0; i < opisStromu.length(); i++) {
                        if (opisStromu.charAt(i) == '(') {
                                pocetZatvoriek++;

                        }
                        if (opisStromu.charAt(i) == ')') {
                                pocetZatvoriek--;

                        }
                        if (pocetZatvoriek == 0) {
                                lavyKonIdx = i;
                                break;
                        }

                }
                korenZacIdx = lavyKonIdx+1;

                pocetZatvoriek =0;

                for (int i = opisStromu.length()-1; i >0 ; i--) {
                        if (opisStromu.charAt(i) == ')') {
                                pocetZatvoriek++;

                        }
                        if (opisStromu.charAt(i) == '(') {
                                pocetZatvoriek--;

                        }
                        if (pocetZatvoriek == 0) {
                                pravyZacIdx = i;
                                break;
                        }

                }

                korenKonIdx = pravyZacIdx-1;

                System.out.println("koren: "+korenZacIdx +" "+korenKonIdx);
                int hodnota = Integer.parseInt(opisStromu.substring(korenZacIdx, korenKonIdx+1).trim());

                String opisLavehoPodstromu = odstranZatvorky(opisStromu.substring(lavyZacIdx,
                                lavyKonIdx + 1).trim());
                String opisPravehoPodstromu = odstranZatvorky(opisStromu.substring(pravyZacIdx + 1,
                                pravyKonIdx).trim());

                System.out.println(opisStromu);
                System.out.println(opisLavehoPodstromu);
                System.out.println(opisPravehoPodstromu);
                System.out.println(hodnota);

                Uzol lavyUzol = stromZRetazca(opisLavehoPodstromu);
                Uzol pravyUzol = stromZRetazca(opisPravehoPodstromu);

                return new Uzol(hodnota, lavyUzol, pravyUzol);

        }

        private static String odstranZatvorky(String opisStromu) {
                opisStromu = opisStromu.trim();
                if (opisStromu.length() == 0)
                        return opisStromu;

                return opisStromu.substring(1, opisStromu.length() - 1);
        }

        public static void main(String[] args) {

                stromZRetazca("((2) 7 ((5) 6 (11))) 2345 (5 ((4) 9))");

        }



}