TreeNode Again

[Trümmermacher]

Hi Leute ,
ich frag mich ob meine getMaxValue funktion so richtig funktioniert ???
hier mein code :

package treeNodeKlausur;

public class TreeNode {

    private float info;
    private TreeNode left, right;
   
    public TreeNode(float c, TreeNode left, TreeNode right){
        info = c;
        this.left = left;
        this.right = right;
    }
    public void setLeftNode(TreeNode child){
        left = child;
    }
    public void setRightNode(TreeNode child){
        right = child;
    }
    public void setInfo(float c){
        info = c;
    }
    public TreeNode getLeftNode(){
        return left;
    } 
    public TreeNode getRightNode(){
        return right;
    }
    public float getInfo(){
        return info;
    }
    private float max(float a, float b){
        return a<b ? b : a;                        //wenn a kleiner b, return b, sonst a
    }
    private float min(float a, float b){
        return a>b ? b : a;
    }
   
    public float getMaxValue(){
        float maxValue=getInfo();
       
        if(getLeftNode()!=null)
            maxValue=max(getLeftNode().getMaxValue(), maxValue);
       
        if(getRightNode()!=null)
            maxValue=max(getRightNode().getMaxValue(), maxValue);
       
        return maxValue;
    }
   
    public float getMinValue (){
        float minValue=getInfo();
       
        if(getLeftNode()!=null)        // Nimm den kleineren Wert von dem aktuellen oder vom linken Node
            minValue=min(getLeftNode().getMinValue(), minValue);
       
        if(getRightNode()!=null)    // Nimm den kleineren Wert von dem aktuellen oder vom rechten Node
            minValue=min(getRightNode().getMinValue(), minValue);
       
        return minValue;   
    }

 

[Tarrew]

Ja das sollte klappen. Am einfachsten ist es das einfach zu testen Sieht aber richtig aus.

 

[Trümmermacher]

jetzt will ich eine methode schreiben die testen soll ob eine zahl im baum enthalten ist und wenn ja true zurück liefert ...ich tue mich nur irgendwie schwer damit .

Könnte mir einer sagen wie ich am besten vorgehen kann
Der methoden körper steht mir zur verfügung :

public boolean enthaelt(int c){

         
 }

 

[Bitfehler]

Was spricht denn dagegen es so zu machen, wie du es bei MinValue oder MaxValue auch tust?
Du durchläufst deinen Baum, bis du einen Knoten gefunden hast, der deinem Vergleichswert enthält. Ein Unterschied ist, dass du das Ablaufen deines Baums abbrechen kannst, wenn du eine Übereinstimmung gefunden hast. Ob du nun noch einen weiteren findest oder nicht, ist egal.

 

[Xyz1]

Hier ist die Lösung nach kneitzel:

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")
                    })
                });
        System.out.println(nodes.getHeight());
        System.out.println(nodes.getNumLeafNodes());
        System.out.println(nodes.find("Ebene 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() {
        if (children.length == 0) {
            return 1;
        }
        int i = 0; // oder 1
        for (TreeNode tn : children) {
            int j = tn.getHeight();
            if (j > i) {
                i = j;
            }
        }
        return i + 1;
    }

    public int getNumLeafNodes() {
        if (children.length == 0) {
            return 1;
        }
        int i = 0;
        for (TreeNode tn : children) {
            i += tn.getNumLeafNodes();
        }
        return i;
    }

    public ArrayList find(String name) {
        ArrayList list = new ArrayList();
        if (this.name.contains(name)) {
            list.add(this);
        }
        for (TreeNode tn : children) {
            list.addAll(tn.find(name));
        }
        return list;
    }

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

i + 1 ärgert mich schon die ganze Zeit.

 

[Trümmermacher]

In der Aufgabenstellung ist Arraylist aber diesmal nicht vorgegeben deswegen wollte ich es ohne lösen nur ich weiss nicht ganz wie ich die vergleiche machen kann.

 

[Trümmermacher]

das übergebene int c irritiert mich ansonsten könnte ich es ja fast 1 zu 1 wie bei getminvalue machen

 

[Xyz1]

Wenn das int gefunden wurde, musst du true zurückliefern.

 

[Trümmermacher]

jo das weiss ich aber ich weiss nicht wie ich den ersten vergleich anfangen kann nur das muss ich als kleien sntoß wissen

so würde ich es lösen wenn ich die funktion ändern könnte :

public Treenode enthaelt(Treenode cur ,int c){

    Treenode result = null;
    if(cur.left != null)
        result = enthaelt(cur.left,c);


    if(cur.info == c)
        return cur;
    if(result ==null && cur.right != null)
        result = enthaelt(cur.right,c);

    return result;

}

 

[Xyz1]

Hier bitte:

    public boolean enthaelt(int c) {
        if (Integer.parseInt(name) == c) { // oder String.valueOf(c) ;)
            return true;
        }
        if (children.length == 0) {
            return false;
        }
        for (TreeNode tn : children) {
            if (tn.enthaelt(c)) {
                return true; // gibt true zurueck
            }
        }
        return false;
    }

 

[Trümmermacher]

ich danke dir

aber das passt nicht zu der jetztigen aufgabe da ich nicht children habe sonder left and right node und nicht name sondern info also ein int und nicht ein String

hier nochmal mein code :

package treenodeübungsaugaben;

public class Treenode {
private int info ;
private Treenode left, right;



Treenode (int c , Treenode left, Treenode right){
    info=c;
    this.left=left;
    this.right=right;
   
}
public void setLeftNode(Treenode child){
    left=child;
}
public void setRightNode(Treenode child){
    right=child;
}
public void setInfo(int c){
    info=c;
}
public Treenode getLeftNode(){
    return left;
}
public Treenode getRightNode(){
    return right;
}
public int getInfo(){
    return info;
}
private int max(int a, int b){
    return a<b ? b: a;
}
public int getMaxinfo(){
   
        int maxValue=getInfo();
       
        if(getLeftNode()!=null)
            maxValue=max(getLeftNode().getMaxinfo(), maxValue);
       
        if(getRightNode()!=null)
            maxValue=max(getRightNode().getMaxinfo(), maxValue);
       
        return maxValue;
    }

 

[Xyz1]

Ascho int info... ja dachte das ist klar.

Genauso vorgehen, parseInt ist nicht nötig, schauen ob, ob c im linken/rechten Tree enthalten ist.

 

[Trümmermacher]

nur wie mach ich den vergleich ich hab ja keine node so wie beim anderen beispiel und kann auf ein int nicht einfach left und right anwenden

 

[Meniskusschaden]

nur wie mach ich den vergleich ich hab ja keine node so wie beim anderen beispiel und kann auf ein int nicht einfach left und right anwenden

"enthaelt" soll doch eine Methode von TreeNode werden, oder? Dann hast du left und right doch zur Verfügung.

 

[Trümmermacher]

jo mir wurde von dem wissenden schon geholfen
hier das end ergebnis :

public boolean enthaelt(int c) {
    if (info == c)
        return true;

        if (left.enthaelt(c) || right.enthaelt(c))
        return true;

        return false;
}

 

[Meniskusschaden]

Müsstest du left und right nicht noch auf null prüfen?