Falsche Augabe

[Veghana]

[Java]class BinaerBaum {
BinaerBaum links; //linker Teilbaum
BinaerBaum rechts; //rechter Teilbaum
int wert;
String result;
BinaerBaum (int wert){
this.wert=wert;

}
public void add(int zahl){
if(zahl<= wert){
if(links==null){
links= new BinaerBaum(zahl);
}
else links.add(zahl);
}
else {
if (rechts==null){
rechts= new BinaerBaum(zahl);
}
else rechts.add(zahl);
}
}
public String toString(){

if (links != null){
result+=links.toString();
}
result+=wert;
if (rechts !=null){
result+=rechts.toString();
}
return result;
}
}
public class TestBaum{
public static void main(String[] args) {
BinaerBaum eins=new BinaerBaum(10);
eins.add(3);
eins.add(2);
eins.add(1);
eins.add(11);
eins.add(12);
System.out.println("<" +eins.toString()+ ">");
}
}[/Java]

Das sind meine beiden Klassen. Wenn ich jetzt TestBaum ausführe, bekomme ich die Ausgabe "nullnullnullnull12310null11null12" obwohl ich doch ausdrücklich definiert habe, es soll die Werte von links und rechts nur in result speichern wenn sie ungleich null sind. Wo liegt da der Fehler?

 

[SlaterB]

erkennst du deinen Fehler in folgendem Programm?:

public class Test
{

    public static void main(String[] args)
        throws Exception
    {

        Object a = new Object();
        String aToString = null;

        String c = null;
        if (a != null)
        {
            c += aToString;
        }
        System.out.println(c);
    }


}

Ausgabe:
nullnull

 

[Veghana]

Mmh,
also ich verstehe noch nicht ganz warum zweimal null ausgegeben wird. Du sagst doch falls a != null ist, soll er a dazu addieren. Das ist nicht der fall, also bleibt c wie es ist, und c ist nunmal null. Warum wird also 2mal null ausgegeben?

 

[SlaterB]

a ist nicht null so wie die Blätter in deinen Bäumen, a ist hier new Object()

von nicht-null Objeken wird das toString() zusammenaddiert, das toString() ist aber meistens null

edit:
oder doch nicht, die Blätter sind wohl ok, aber weiter oben wird immer null+String gerechnet, und da kann aben null1 rauskommen

 

[Veghana]

Ok, hab das Problem gelöst. Der Fehler war, dass result als Null definiert war. mit Änderung der Zeile
String result; in String result=""; ist alles in Ordnung.

Danke für deine Hilfe

 

[Veghana]

Ok, ich hab nochmal ein weiteres Problem mit dem Quellcode.

Jetzt will ich die Methode countNode() einführen, welche mir die Anzahl der Knoten wiedergibt:

class BinaerBaum {
	BinaerBaum links; //linker Teilbaum
	BinaerBaum rechts; //rechter Teilbaum
	int wert;
	int anzahl=1;
	String result ="";
	BinaerBaum (int wert){
		this.wert=wert;
		
	}
	public void add(int zahl){
		if(zahl<= wert){
			if(links==null){
				links= new BinaerBaum(zahl);
			}
		else links.add(zahl);
	}
	else {
		if (rechts==null){
			rechts= new BinaerBaum(zahl);
		}
		else rechts.add(zahl);
	}
}
	public String toString(){
		
		if (links != null){
			result+=links.toString();
			}
			result+=wert;
		if (rechts !=null){
			result+=rechts.toString();
		}
		return result;
	}
	public int countNode(){
		if (links!=null){
			anzahl+=1;
			links.countNode();
		}
		if (rechts!=null){
			anzahl+=1;
			rechts.countNode();
		}
		return anzahl;
	}
}
public class TestBaum{
	public static void main(String[] args) {
		BinaerBaum eins=new BinaerBaum(10);
		eins.add(3);
		eins.add(2);
		eins.add(1);
		eins.add(11);
		eins.add(12);
		System.out.println("<" +eins.toString()+ ">");
		System.out.println("Knotenanzahl: " +eins.countNode());
	}
}

Wenn ich die jetzt aber ausgebe, sagt er mir ich hab 3 Knoten, und nicht wie es sein sollte sechs. Dabei sollte er mir doch durch die Rekursion alle Knoten angeben, warum funktioniert das trotzdem nicht?

 

[Leroy42]

Ich würde keine statische Variable "anzahl" verwenden, da sie dein
gesamtes Konzept verändert und eine Instanzvariable zu nehmen
ist noch chaotischer!

Schreib' deine Methode doch einfach rein-rekursiv!

    public int countNode() {
      return 1 + (links==null ? 0:links.countNode()) + (rechts==null ? 0:rechts.countNode())
    }
}

 

[SlaterB]

anzahl ist hier ja auch nicht statisch,
Problem ist, dass der Rückgabewert von z.B. links.countNode(); nicht berücksichtigt wird,
der muss zur Anzahl dazu, dafür kann das
anzahl+=1;
im Falle von links/ rechts != null weg, das ist bei links.countNode(); usw. schon mit drin

 

[Leroy42]

Nochmal erklärt wieso deine Lösung falsch war:

1. werden Instanzvariablen durch Aufruf von countNode() verändert.
Dadurch würden weitere Aufrufe von countNode() diese Variable(n) auch
mehrfach erhöhen.

2. wird pro Instanz eine neue Variable "anzahl" erzeugt was nun wirklich unnötig ist

3. wird auf jeder Rekursionsstufe eine andere Variable erhöht

 

[Leroy42]

anzahl ist hier ja auch nicht statisch

Stimmt! Ich hatte das erst fälschlicherweise angenommen,
weil eine Instanzvariable (wie auch im zweiten Teil meines Postings
erwähnt) noch sinnlosere Ergebnisse zur Folge hätte.

 

[Veghana]

Ok, funktioniert, besten Dank.

 

[Veghana]

Ok, hab noch eine weitere Frage. Ich hab das Programm jetzt auf Generics umgeschrieben. dabei gibt er mir aber nicht die Knoten aus, sondern nur leere Klammern, kann mir jemand sagen warum?

[Java]class BinaerBaum <T extends Comparable> {

BinaerBaum links; //linker Teilbaum
BinaerBaum rechts; //rechter Teilbaum
T wert;
String result ="";
int res;
BinaerBaum (T wert){
this.wert=wert;

}
public void add(T element){
res=this.wert.compareTo(element);
if(result<=0){
if(links==null){
links= new BinaerBaum(element);
}
else links.add(element);
}
if(result>0){
if (rechts==null){
rechts= new BinaerBaum(element);
}
else rechts.add(element);
}
}

public String toString(){
if (links != null){
result+=links.toString();
}
result+=wert;
if (rechts !=null){
result+=rechts.toString();
}
return result;
}
public int countNode(){
return 1 + (links==null ? 0:links.countNode()) + (rechts==null ? 0:rechts.countNode());
}
}
public class TestBaum <T>{
public static void main(String[] args) {
String c=new String ("");
String a=new String ("");
String b=new String ("");
BinaerBaum eins=new BinaerBaum(c);
eins.add(a);
eins.add(b);
System.out.println("<" +eins.toString()+ ">");
System.out.println("Knotenanzahl: " +eins.countNode());
}
}[/Java]

 

[Gelöschtes Mitglied 5909]

weil "" nunmal leer ist?

und mach

BinaerBaum<T> links; //linker Teilbaum
    BinaerBaum<T> rechts; //rechter Teilbaum

 

[Veghana]

Na, da hätte ich ja auch wirklich selber drauf kommen können.

Jetzt gibt der mir zwar Werte aus, aber immer wiederholende und dann noch in der falschen Reihenfolge. Ich will alle die kleiner oder gleich sind, nach links einordnen, alle die größer sind (oder wie hier später im alphabet kommen) rechts.

Wenn ich jetzt aber diese Klassen habe:
[Java]class BinaerBaum <T extends Comparable> {

BinaerBaum<T> links; //linker Teilbaum
BinaerBaum<T> rechts; //rechter Teilbaum
T wert; //wurzel
int res=wert.compareTo(element);
BinaerBaum (T wert){
this.wert=wert;

}

public void add(T element){

if(res<=0){
if(links==null){
links= new BinaerBaum<T> (element);
}
else links.add(element);
}
if(res>0){
if (rechts==null){
rechts= new BinaerBaum<T> (element);
}
else rechts.add(element);
}
}

public String toString(){
String result=new String ("");
if (links != null){
result+=links.toString();
}
result+=wert;
if (rechts !=null){
result+=rechts.toString();
}
return result;
}
public int countNode(){
return 1 + (links==null ? 0:links.countNode()) + (rechts==null ? 0:rechts.countNode());
}
}
´public class TestBaum <T>{
public static void main(String[] args) {
String a=new String ("a");
String b=new String ("b");
String c=new String ("c");
BinaerBaum eins=new BinaerBaum(b);
System.out.println("<" +eins.toString()+ ">");
eins.add(c);
System.out.println("<" +eins.toString()+ ">");
eins.add(a);
System.out.println("<" +eins.toString()+ ">");

}
}[/Java]

Dann bekomm ich die Ausgabe:
<b>
<bcb>
<bcbcba>

Irgendwie scheint das an meiner Ausgabe Variablen zu liegen, die verändert wird, obwohl ich nicht verstehe, warum die Sortierung (bzw. die Ausgabe Reihenfolge) nicht funktioniert.

Kann mir da jemand helfen?

 

[SlaterB]

dein Code stimmt so nicht, Zeile 6
> int res=wert.compareTo(element);
passt da überhaupt nicht, element gibt es nicht, wert ist noch null,

wenn diese Zeile nach Zeile 13 verschoben wird, ist das ganze bei mir kompilierbar und die Ausgabe ist
<b>
<cb>
<cba>

sehe auch keine Möglichkeit zur Verdopplung in diesem Code

------

die Testklasse TestBaum <T> braucht keinen generischen Parameter

> BinaerBaum eins=new BinaerBaum(b);
sollte dagegen generisch sein
BinaerBaum<String> eins=new BinaerBaum<String>(b);
damit du später nur String adden kannst

statt
> class BinaerBaum <T extends Comparable> {
nimmt man besser
class BinaerBaum <T extends Comparable<T>> {

 

[Veghana]

Mmh, das mit der res Variablen stimmt natürlich, damit ist dann auch die Verdopplung weg (obwohl ich nicht weiß wo die herkam).

Trotzdem sortiert er noch nicht richtig oder gibt nicht richtig aus. Er sollte alle die Größer sind, wo also res.compareTo(element)>0 ist nach rechts einordnen und alle die kleiner oder gleich sind nach links und dann Inorder <links, wert, rechts> ausgeben. Demnach müsste die Ausgabe also <abc> sein und nicht <cba>...

Edit: Ok, hat sich erledigt. Einfach die Bedingung für Res umgedreht, schon war alles klar.

Danke für eure Hilfe, jetzt steht mein Programm.

 

[Leroy42]

War ja wirklich mal 'ne Zangengeburt? :shock:

D)