TreeNode

[Trümmermacher]

Hi Leute das ist eine Klausuraufgabe ich weiss nicht wie ich sie lösen soll ohne left oder right treenode einzubauen dabei weiß ich nicht ob das erlaubt ist.



Daher meine Frage ist es möglich die methoden (die Höhe eines Knoten )getheight und (die Zahl der Blätter) getNumOfLeafNodes zu schrieben ohne left oder right TreeNode einzubauen

Zusätzlich dürfen keine anderen Methoden benutzt werden ausser arraylist

Vielen Dank für eure Hilfe weiss einfach nicht wie ich da ran gehen soll

import java.util.ArrayList;
    public class TreeNode {
    private String name;
    private TreeNode children[];
    TreeNode (String name) {
    this.name = name;
    this.children = new TreeNode[0];
}
TreeNode (String name, TreeNode children[]) {
this.name = name;
this.children = children;
}
public void setName(String name) {
this.name = name;
} public String getName() {
return name;
}
public int getHeight() { < zu implementieren > }
public int getNumLeafNodes() { < zu implementieren > }
public ArrayList find(String name) { < zu implementieren > } }

 

[Tarrew]

Wofür möchtest du denn left- bzw right Node einfügen? Der Unterschied ist doch, dass du bei diesem Baum nicht nur einen linken und einen rechten Knoten hast sondern unter Umständen deutlich mehr als zwei.

Auf Anhieb würde ich versuchen das rekursiv zu lösen. Also rekursiv das Maximum der TreeNodes in deinem Array suchen und dann jeweils 1 (für den eigenen Knoten) + max (maximale Höhe) der Children zurückgeben.
Habs nicht gestestet dürfte aber in etwa so gehen:

    public int getHeight() {
        int max = 0;
        for (TreeNode node : children) {
            max = node.getHeight() > max ? node.getHeight() : max;
        }
        return 1 + max;
    }

 

[Trümmermacher]

Ich tue mich was schwer mit rekursion könntest du mir dein ansatz vielleicht genauer erklären

 

[kneitzel]

Rekursion bedeutet hier, dass Du die Funktion auf jedem Child erneut aufrufst.
Um die Höhe zu bekommen, muss man einfach die Höhe des höchsten Child-Treenodes nehmen und 1 addieren.
Bei der Anzahl der Blätter ist es ähnlich. Wenn ein TreeNode keine Children hat, dann ist es 1 Blatt.

 

[Trümmermacher]

ok alles klar hab ich verstanden aber die aufgaben stellung war das man die höhes eines knoten mit der methode bestimmen soll und nicht die des gesamten baums

 

[Tarrew]

Die Höhe des Baumes wird nur ausgegeben wenn du die Methode am Wurzelknoten aufrufst.
Wenn du die Methode an einem Kindknoten aufrufst wird nur die Höhe ab dem Kind berechnet.

 

[kneitzel]

Die höhe eines Knotens ist doch die Höhe des Teilbaumes. Wenn Du die Funktion auf einem Knoten aufrufst bekommst Du ja genau diese Höhe.

 

[Trümmermacher]

sorry für die blöden fragen aber wie würde ich die methode am wurzeknoten aufrufen müsste ich nicht dafür ein parent einbauen

 

[Tarrew]

TreeNode wurzel = new TreeNode("Wurzel");

und aufrufen dementpsrechend mit:

wurzel.getHeight();

Den Knoten den du am Ende als Wurzel nimmst, kannst du ja selbst festlegen.

 

[Trümmermacher]

super ich dank euch für eure hilfe werde später mal meinen code posten

 

[Trümmermacher]

Hi Leute irgendwie bin ich immernoch nicht dahinter gekommen wie ich die zweite FUnktion getNumOfLeafs hinbekomme

KANN MIR JEMAND WEITERHELFEN???

 

[Trümmermacher]

Ich habe es so gemacht aber das ist ganz bestimmt falsch oder ???Er soll jedes mal leaf erhöhen wenn ein node ein child hat aber ich frage mich ob das dann auch immer die blatt knoten sind

public int leafs(){
int leaf=0;
for(TreeNode node : children){
    leaf=children!=null ?leaf++:leaf;
}
return leaf;
}

 

[kneitzel]

Mal Dir einen Beispielbaum auf. Wie gehst Du vor, wenn Du das machen musst? So kann man meist auf einen Algorithmus kommen.

oder Du gehst ganz Abstrakt ran und malst Dir nur ein oder zwei Knoten auf (Zwei, damit man alle Fälle hat: Einmal ohne Children und einmal mit Children). Was ist die Anzahl der Blätter bei den Fällen?

 

[kneitzel]

Was sind denn in einem Baum Blätter? Blätter sind Nodes ohne Children. Ein Node mit Children ist kein Blatt sondern ein Ast.

Also wenn children null ist oder leer, dann ist es ein Blatt und damit ist die Anzahl der Leafs eins;
Wenn Children da sind, dann ist die Anzahl der Blätter die Anzahl der Blätter von allen Children.

 

[Trümmermacher]

also muss ich jede fragen welche nodes keine children haben und für jedes node das keine children hat meinen count erhöhen oder ???

 

[kneitzel]

So in der Art, aber versuch es doch rekursiv zu sehen. Ich habe ja versucht, es rekursiv wieder zu geben. Du hast die Abbruchbedingung (children null oder leer) und die Berechnung, wenn children vorhanden sind.

 

[Trümmermacher]

also die abruchbedingung wär dann in dem fall

public int getNumOfLeafs(){
int leaf= 0;
if(children==null){
leaf =1;
}
return leaf

und wie dann weiter mit ner for each schleife oder ner for schleife die children durchläuft und zusammen zählt??

 

[kneitzel]

Du musst noch sicher stellen, dass children null ist, wenn es keine children gibt. Nicht dass da auch eine leere Liste sein könnte. Ich würde da auf jeden Fall die Größe von children mit prüfen.

Und ja - mit einer for each Schleife könnte man im else-Zweig die getNumOfLeaf der Children erfragen und zusammen zählen.

 

[Trümmermacher]

könnte ich es so machen also bis auf das children == null oben

public int leafs(){
int leaf=0;

if(children ==null) {
    
    return 1;
}
for(TreeNode node : children){
    leaf++;
}
return leaf;

}

 

[kneitzel]

Das würde ja bedeuten, dass jedes Children nur ein Blatt haben kann? Das hört sich nicht korrekt an (Und hat ja auch keine Rekursion).

 

[Trümmermacher]

wollte ich gerade schreiben das da ja keine rekursion drin ist könntest du mir vielleicht zeigen wie ich es richitg mache..wär super cool

 

[Tarrew]

Du musst für jedes child wieder die getNumLeafNodes() Methode aufrufen und das auf deine leaf-Variable addieren.

 

[kneitzel]

Ich hatte es ja bereits geschrieben: Für jeden children Eintrag musst Du die Funktion neu aufrufen. Die Lösung würde ich also so schreiben:

public int getLeafNumber(){

  if(children ==null || children.length == 0) {
    return 1;
  }

  int leafNumber=0;
  for(Treenode child: children){
    leafNumber += child.getLeafNumber();
  }

  return leafNumber;
}

Ich bin jetzt davon ausgegangen, dass children ein array von Treenode ist. Und im Konstruktor hast Du bereits ein setzen auf ein Array mit Größe 0. Somit wird es wohl nie null sein. Aber die Länge kann man ja auf Länge 0 prüfen.

Und wenn es nicht null und auch nicht auf Länge 0 ist, wird einfach die Anzahl der Blätter aller children zusammen addiert.

 

[Trümmermacher]

Ich danke dir für die Hilfe für mich war nicht ganz klar wie ich den rekursions schritt gehe

letzendlich besteht die rekursion immer darin das die funktion sich selbst aufruft bis die babruchbedingung erreicht wird oder???

oder in diesem fall bis jedes children abgefragt wurde

 

[kneitzel]

Ja genau. Rekursion ist über den Selbstaufruf + Abbruchbedingung definiert und kann eigentlich immer wie folgt dargestellt werden:

<FunktionsKopf> {
  <Prüfen der Abbruchbedingung>
  <Rekursiver Aufruf>
}

um es mal als reinen Pseudocode aufzuschreiben.

 

[Xyz1]

Ja genau. Rekursion ist über den Selbstaufruf + Abbruchbedingung definiert und kann eigentlich immer wie folgt dargestellt werden:

Etwas zu den Parametern zu sagen, hast du noch vergessen.

 

[kneitzel]

Das sollte ja ganz allgemein sein und es muss weder Parameter noch einen Rückgabewert geben. So wäre es denkbar, eine Rekursion auf Basis eines Eingabestreams zu bauen. Abbruchbedinung wäre dann evtl. das Ende des Streams oder ein spezieller, gelesener Wert.

 

[Trümmermacher]

ICh weiss ich gehöre zu den ganz dämlichen ich wollte jetzt ne main für das ganze schreiben aber ich weiss nicht genau wie ich das array children befülle um dann getLeafnumber auszuführen

public static void main (String [] args){  
    TreeNode x = new TreeNode("Fred",<WAS  KOMMT HIER REIN >);
    TreeNode x1 = new TreeNode("miriam");  
    System.out.println(x.getLeafNumber());
}}

 

[Xyz1]

Oh, Namen hast du ja schon drin, miriam, dann noch eine Liste mit subnodes.

Dabei müssen die Blätter zuerst erstellt werden.

 

[Trümmermacher]

wie würde das in code aussehen ????


also das array children mit anderen nodes füllen und das array dann als 2ten konstruktor angeben neben dem namen angeben ???

 

[kneitzel]

Also die Nutzung eines Arrays ist nicht ganz so optimal. Ich würde da ein ArrayList<TreeNode> statt TreeNode[] für children nutzen. Im Konstruktor wird dann children = new ArrayList<>(); initialisiert. Wenn da ein Array von children übergeben wird, dann kann man children.addAll(...) aufrufen um die children der ArrayList hinzuzufügen.

Und dann würde ich eine Funktion addChild oder so einfügen. Dann hätte man als Code sowas wie:

TreeNode root = new TreeNode("Fred");
TreeNode leaf = new TreeNode("Miriam");
root.addChild(leaf);

Aber Du kannst mit der aktuellen Implementation natürlich etwas machen wie:

    TreeNode x1 = new TreeNode("Miriam");
    TreeNode x = new TreeNode("Fred", new TreeNode[] { x1 });

 

[Joose]

@Trümmermacher Deinen Code bitte in Code-Tags schreiben, danke
[java] .. dein code [/java]

 

[Xyz1]

Das kann ich dir sagen, wenn du einmal alles in [code=Java][/code] postest. So wie jetzt kann es nicht bleiben, das kann ich gar nicht lesen.

 

[Trümmermacher]

es ist in der aufgabe nicht erlaubt neue methoden zu verwenden auser denen die in der arraylist klasse vorhanden sind. daher könnte ich z.b addchild nicht verwenden.

Aber gut in der Aufgabe war auch nicht nach ner main gefragt die wollte ich zur kontrolle schreiben

 

[Trümmermacher]

Das ist der Code zur Aufgabe:

import java.util.ArrayList; 
public class TreeNode { 
 private String name; 
 private TreeNode children[]; 

 TreeNode (String name) {
 this.name = name; 
 this.children = new TreeNode[0]; 
 }

 TreeNode (String name, TreeNode children[]) {
 this.name = name; 
 this.children = children; 
 }

 public void setName(String name) {
 this.name = name; 
} 
 public String getName() { 

return name; 
} 
 public int getHeight() { < zu implementieren > } 
 public int getNumLeafNodes() { < zu implementieren > } 
 public ArrayList find(String name) { < zu implementieren > } }

Und das ist die aufgabe:
Sie dürfen in dieser Aufgabe zusätzlich nur die Klasse ArrayList aus dem Java API verwenden. Sie dürfen keine weiteren Methoden definieren.
a) Implementieren Sie die Methode getHeight(), die die Höhe eines Knoten bestimmt.
b) Implementieren Sie die Methode getNumLeafNodes(), die die Anzahl der Blattknoten bestimmt.
c) Implementieren Sie die Methode find(). Die Methode soll alle Knoten des Baumes zurückgeben, deren Instanzvariable name dem übergebenen String entsprechen.

 

[Trümmermacher]

damit ihr wisst worüber ich rede

 

[Trümmermacher]

Und das ist mein bisheriger Code

import java.util.ArrayList;


public class TreeNode {
 private String name;
 private TreeNode children[];


 TreeNode (String name) {
 this.name = name;
 this.children = new TreeNode[0];
 }
 TreeNode (String name, TreeNode children[]) {
 this.name = name;
 this.children = children;

 }
 public void setName(String name) { this.name = name; }
 public String getName() { return name; }

 public int getHeight() {
     int max = 0;
     for (TreeNode node : children) {
         max = node.getHeight() > max ? node.getHeight() : max;
     }
     return 1 + max;
 }



public int getLeafNumber(){ 

  if(children ==null || children.length == 0) {
    return 1;
  }

  int leafNumber=0;
  for(TreeNode child: children){
    leafNumber += child.getLeafNumber();
  }

  return leafNumber;
}




public static void main (String [] args){
   
    TreeNode x = new TreeNode("Fred");
    TreeNode x1 = new TreeNode("miriam",new TreeNode[]{x});
   
    System.out.println(x1.getLeafNumber());
   
   
   
}}

 

[Xyz1]

Ok, ich könnte dir Höhe, Anzahl Blätter und suchen schreiben, aber das ist wieder eine Komplettlösung.

Wie man zwei Elemente zusammenbaut, weißt du doch schon?! Bei mir ist das schon etwas länger her.
Die anderen werden auch so zusammengebaut. Melde dich noch mal.

Grüße
T.

 

[Trümmermacher]

höhe und anzahl der blätter hab ich ja schon werde mich jetzt noch um die find kümmern aber hab halt noch nicht viel mit arraylist gearbeitet

 

[Xyz1]

Jetzt dachte ich, schreibste was schlaues, dann crasht mir Netbeans, den Fehler konnte ich lokalisieren, kann mir jemand sagen, woran es liegt ? :

import java.util.*;

public class TreeNode {

    public static void main(String[] args) {
        TreeNode nodes = new TreeNode("Ebene 1_1", new TreeNode[]{
            new TreeNode("Ebene 2_1", new TreeNode[]{
                new TreeNode("Ebene 3_1"),
                new TreeNode("Ebene 3_2"),
                new TreeNode("Ebene 3_3"),
                new TreeNode("Ebene 3_4"),
                new TreeNode("Ebene 3_5")
            }),
            new TreeNode("Ebene 2_2", new TreeNode[]{
                new TreeNode("Ebene 3_6"),
                new TreeNode("Ebene 3_7"),
                new TreeNode("Ebene 3_8"),
                new TreeNode("Ebene 3_9")
            })
        });
        // and so...
    }

    private String name;
    private TreeNode children[];

    TreeNode(String name) {
        this.name = name;
        this.children = new TreeNode[0];
    }

    TreeNode(String name, TreeNode children[]) {
        this.name = name;
        this.children = children;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public int getHeight() {
        new TreeNodeTraverser() {
            private int i = 0;

            @Override
            public void enter(TreeNode tn) {
                System.out.println("tn = " + tn);
                i++;
            }

            @Override
            public void exit(TreeNode tn) {
            }
        }.deep(this); // ... crash!! ...
        return 0;
    }

    public int getNumLeafNodes() {
        return 0;
    }

    public ArrayList find(String name) {
        return null;
    }

    public static abstract class TreeNodeTraverser {

        private static final ArrayList<TreeNode> nodes = new ArrayList<TreeNode>();

        public void deep(TreeNode tn) {
            enter(tn);
            if (tn.children != null) {
                for (TreeNode c : tn.children) {
                    deep(c);
                }
            }
            exit(tn);
        }

        public void brit(TreeNode tn) {
            // geheim
        }

        public abstract void enter(TreeNode tn);

        public abstract void exit(TreeNode tn);
    }
}

tnt ist öffentlich-statisch-abstrakte innere Klasse.

Nodes werden so erstellt:

        TreeNode nodes = new TreeNode("Ebene 1_1", new TreeNode[]{
            new TreeNode("Ebene 2_1", new TreeNode[]{
                new TreeNode("Ebene 3_1"),
                new TreeNode("Ebene 3_2"),
                new TreeNode("Ebene 3_3"),
                new TreeNode("Ebene 3_4"),
                new TreeNode("Ebene 3_5")
            }),
            new TreeNode("Ebene 2_2", new TreeNode[]{
                new TreeNode("Ebene 3_6"),
                new TreeNode("Ebene 3_7"),
                new TreeNode("Ebene 3_8"),
                new TreeNode("Ebene 3_9")
            })
        });

lg

 

[kneitzel]

Also ich habe da auf den erzeugten Baum einmal entsprechend einen Aufruf ergänzt:

System.out.println(nodes.getHeight());

Kommt natürlich 0 raus, denn da ein private i hochzuzählen bringt natürlich nicht viel. Und dieses i wird auch nicht die Höhe sein, wenn ich Deinen Code richtig verstanden habe.

Das Ganze läuft bei mir dann auch sauber durch - was für einen Crash siehst Du? Was passiert genau?
Die Ausgabe bei mir war:

tn = TreeNode@74a14482
tn = TreeNode@1540e19d
tn = TreeNode@677327b6
tn = TreeNode@14ae5a5
tn = TreeNode@7f31245a
tn = TreeNode@6d6f6e28
tn = TreeNode@135fbaa4
tn = TreeNode@45ee12a7
tn = TreeNode@330bedb4
tn = TreeNode@2503dbd3
tn = TreeNode@4b67cf4d
tn = TreeNode@7ea987ac
0

 

[Xyz1]

Netbeans kommt mit öffentlich-statisch-abstrakte innere Klasse nicht klar, ich vermute, dass es da Überschneidungen oder Konflikte mit den Attributen der Klasse TreeNode gibt (bei Eclipse läuft es durch?). Aber alles nur geraten. Ich schreibe das gleich noch mal sauber. Ich möchte ja TE helfen.

Edit: Vielleicht auch ein Bug entdeckt.

 

[Xyz1]

Läuft jetzt, hier ist das KD:

public class TreeNode {

    public static void main(String[] args) {
        TreeNode nodes
                = new TreeNode("Ebene 1_1", new TreeNode[]{
                    new TreeNode("Ebene 2_1", new TreeNode[]{
                        new TreeNode("Ebene 3_1"),
                        new TreeNode("Ebene 3_2"),
                        new TreeNode("Ebene 3_3"),
                        new TreeNode("Ebene 3_4"),
                        new TreeNode("Ebene 3_5")
                    }),
                    new TreeNode("Ebene 2_2", new TreeNode[]{
                        new TreeNode("Ebene 3_6"),
                        new TreeNode("Ebene 3_7"),
                        new TreeNode("Ebene 3_8"),
                        new TreeNode("Ebene 3_9")
                    })
                });
        System.out.println(nodes.getHeight()); // 3
        System.out.println(nodes.getNumLeafNodes()); // 9
        System.out.println(nodes.find("Ebene 3_2")); // 3_2...
    }

    private String name;
    private TreeNode children[];

    TreeNode(String name) {
        this.name = name;
        this.children = new TreeNode[0];
    }

    TreeNode(String name, TreeNode children[]) {
        this.name = name;
        this.children = children;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public TreeNode[] getChildren() {
        return children;
    }

    public int getHeight() {
        TreeNodeTraverser tnt = new TreeNodeTraverserHeight();
        tnt.deep(this);
        return tnt.getNum();
    }

    public int getNumLeafNodes() {
        TreeNodeTraverser tnt = new TreeNodeTraverserNumLeafNodes();
        tnt.deep(this);
        return tnt.getNum();
    }

    public ArrayList find(String name) {
        TreeNodeTraverser tnt = new TreeNodeTraverserFind(name);
        tnt.deep(this);
        return tnt.getArrayList();
    }

    @Override
    public String toString() {
        return "TreeNode{" + "name=" + name + '}';
    }
}

tn = TreeNode{name=Ebene 1_1}
tn = TreeNode{name=Ebene 2_1}
tn = TreeNode{name=Ebene 3_1}
tn = TreeNode{name=Ebene 3_2}
tn = TreeNode{name=Ebene 3_3}
tn = TreeNode{name=Ebene 3_4}
tn = TreeNode{name=Ebene 3_5}
tn = TreeNode{name=Ebene 2_2}
tn = TreeNode{name=Ebene 3_6}
tn = TreeNode{name=Ebene 3_7}
tn = TreeNode{name=Ebene 3_8}
tn = TreeNode{name=Ebene 3_9}
3
tn = TreeNode{name=Ebene 1_1} // brit
tn = TreeNode{name=Ebene 2_1}
tn = TreeNode{name=Ebene 2_2}
tn = TreeNode{name=Ebene 3_1}
tn = TreeNode{name=Ebene 3_2}
tn = TreeNode{name=Ebene 3_3}
tn = TreeNode{name=Ebene 3_4}
tn = TreeNode{name=Ebene 3_5}
tn = TreeNode{name=Ebene 3_6}
tn = TreeNode{name=Ebene 3_7}
tn = TreeNode{name=Ebene 3_8}
tn = TreeNode{name=Ebene 3_9}
9
tn = TreeNode{name=Ebene 1_1}
tn = TreeNode{name=Ebene 2_1}
tn = TreeNode{name=Ebene 3_1}
tn = TreeNode{name=Ebene 3_2}
tn = TreeNode{name=Ebene 3_3}
tn = TreeNode{name=Ebene 3_4}
tn = TreeNode{name=Ebene 3_5}
tn = TreeNode{name=Ebene 2_2}
tn = TreeNode{name=Ebene 3_6}
tn = TreeNode{name=Ebene 3_7}
tn = TreeNode{name=Ebene 3_8}
tn = TreeNode{name=Ebene 3_9}
[TreeNode{name=Ebene 3_2}]

Ok, tnt hat sie ja schon selber geschrieben, deswegen Thema erst mal durch.

 

[kneitzel]

Also ich verstehe nicht, wieso Du meinst so eine innere Klasse verwenden zu müssen. Die notwendigen Funktionen konnten wir ja auch schon teilweise korrekt schreiben ohne eben genau diese innere Klasse und das find ist ebenso einfach schreibbar. Daher stehe ich etwas auf dem Schlauch, wieso Du das für notwendig gehalten hast.

 

[Xyz1]

Also ich verstehe nicht, wieso Du meinst so eine innere Klasse verwenden zu müssen.

Weil es keinen Getter für Subnodes gab. Keiner kann/konnte darauf zugreifen.

innere Klassen dürfen auf (private) Attribute der "darumliegenden" Klasse zugreifen,
statische innere Klassen dürfen auf statische Attribute zugreifen,

statische innere Klassen mit einer Referenz auf die "darumliegende" Klasse, dürfen auf (private) Attribute der Klasse zugreifen <-> Konflikt irgendwo, weißt du wo?

Summa summarum: TreeNode ist nicht ausgefeilt; Getter für Subnodes würde bedeuten, ich kann die Subnodes auch ändern;

außerdem: Es gibt design patterns für Multitrees; Vererbungs"hierarchie" ist ein eigenes langes Kapitel in einem langen Buch.

Vorgaben:

1. diese Klasse,
2. ArrayList,
3. nicht Generics,
4. rekursive Prozedur?,

zu tun:

1. Klasse um Getter erweitern?,
2. sinnvoll befüllen, das meine ich Ernst,
3. iterieren aller Baumknoten und -Blätter,
4. ausgabe,
5. Tests,
6. ????

Jetzt bin ich offline.

Grüße

 

[kneitzel]

Also es gibt eine klare Aufgabenstellung und die ist zu implementieren. Und dabei kann man es so simpel wie möglich halten. Vieles, das Du da machen willst ist ja gut und schön und es mag Gründe für das eine oder andere geben - aber doch nicht im Rahmen der eigentlichen Aufgabe. Und ich bezweifle etwas, das dieser Code dem TE groß helfen wird.

Vorgegeben war:

import java.util.ArrayList;
public class TreeNode {
    private String name;
    private TreeNode children[];
    TreeNode (String name) {
        this.name = name;
        this.children = new TreeNode[0];
    }
    TreeNode (String name, TreeNode children[]) {
        this.name = name;
        this.children = children;
    }
    public void setName(String name) {
        this.name = name;
    } public String getName() {
        return name;
    }
    public int getHeight() { < zu implementieren > }
    public int getNumLeafNodes() { < zu implementieren > }
    public ArrayList find(String name) { < zu implementieren > } 
}

Zusammen mit der Aussage:

Sie dürfen in dieser Aufgabe zusätzlich nur die Klasse ArrayList aus dem Java API verwenden. Sie dürfen keine weiteren Methoden definieren.
a) Implementieren Sie die Methode getHeight(), die die Höhe eines Knoten bestimmt.
b) Implementieren Sie die Methode getNumLeafNodes(), die die Anzahl der Blattknoten bestimmt.
c) Implementieren Sie die Methode find(). Die Methode soll alle Knoten des Baumes zurückgeben, deren Instanzvariable name dem übergebenen String entsprechen.

Und dann wäre die Lösung aus meiner Sicht:

import java.util.ArrayList;

public class TreeNode {

    private String name;
    private TreeNode children[];

    TreeNode (String name) {
        this.name = name;
        this.children = new TreeNode[0];
    }

    TreeNode (String name, TreeNode children[]) {
        this.name = name;
        this.children = children;
    }

    public void setName(String name) {
        this.name = name;
    } public String getName() {
        return name;
    }

    public int getHeight() {
        if (children == null || children.length == 0) {
            return 1;
        }

        int maxHeight = 0;
        for (TreeNode child: children) {
            int childHeight = child.getHeight();
            maxHeight = childHeight > maxHeight ? childHeight : maxHeight;
        }
        return maxHeight + 1;
    }

    public int getNumLeafNodes() {
        if (children == null || children.length == 0) {
            return 1;
        }

        int leafs = 0;
        for (TreeNode child: children) {
            leafs += child.getNumLeafNodes();
        }
        
        return leafs;
    }

    public ArrayList find(String name) {
        ArrayList result = new ArrayList();

        if (name.equals(this.name))
            result.add(this);
        
        if (children == null) 
            return result;
        
        for (TreeNode child: children) {
            result.addAll(child.find(name));
        }
        
        return result;
    }
}

Bis auf find sind ja schon alle Methoden besprochen worden. Find ist ähnlich aufgebaut, lediglich der Umgang mit ArrayList ist hier jetzt neu hinzu gekommen. Offen wäre hier evtl. noch die Behandlung von null als name - das müsste man ggf. abfangen oder im Code unterstützen. Aber das ist derzeit erst einmal egal.

 

[Xyz1]

Hier kommt wieder mein TL;DR ins Spiel. Ich hab deinen Beitrag vollständig gelesen, aber die Aufgabenstellung nicht.

Ja, dann braucht man den ganzen Quatsch mit tnt und Getter gar nicht.

Danke erst mal, und tschaui.

 

[Trümmermacher]

Hey Leute dank euch allen für die Hilfe
war seit gestern noch mit anderen Aufgaben beschäftigt und konnte garnicht mehr rein schauen.