# Binärbaum grafisch darstellen



## Guest (27. Okt 2003)

Hallo
und zwar habe ich mich bis jetzt nur mit einigen Java-anfänger sachen beschäftigt, daraufhin habe ich folgende Klassen programmiert um einen Binärbaum zu erhalten:

Nun suche ich eine möglichkeit die es mir ermöglicht ihn als applet(oder irgendwie anders grafisch) darzustellen, hat jemand einen rat für mich??????????

und eine andere Frage die ich mir stelle ist es wie ich aus diesem Baum einen Binärbaum für Objekte mache, denn im Moment ist er ja nur für int zu gebrauchen? hat da jemand eine idee?




```
import java.io.*;

public class Binärbaum 
{
protected String Knoten;
protected int index = 0;
protected int w;
protected int Wert;
Binärbaum vater, links, rechts;


/************************Konstruktor für den Binärbaum, der einen Eingegebenen Wert erwartet***********************/
Binärbaum(int w)
{ 
Wert = w;
vater = null;
links = null;
rechts = null;
index++;
hinzufuegen(w);

} 


/* 
public String toString() 
{
String s = (NamedesKnotens+" :"+Knoten);
return s; 
}
*/ 
/************************Eingabe der hinzuzufügenden einzelnen Werte*******************************/
public int eingabe()
{ 

System.out.print("Eingabe des Wertes: ");
try
{
BufferedReader buffer = new BufferedReader(new InputStreamReader(System.in));
Knoten = buffer.readLine();
w = Integer.parseInt(Knoten);
hinzufuegen(w); //Startet den Vorgang hinzufügen mit dem Eingegebenen Wert
} 
catch (IOException ioe)
{
System.out.print("Fehler: " + ioe);
System.exit(1);
}
return w;

} 
/********************************Hinzufuegen des eingegebenen Wertes zum Binärbaum*******************************/ 
public void hinzufuegen(int w)
{ 

if (w != Wert)
{
if (w < Wert) 
{
if (links == null) //Ist der linke Sohn frei?
{
links = new Binärbaum(w);
links.vater = this;
index++;
System.out.println(w + " links von :" + Wert + " eingehangen"); //Ausgabe wo der Wert angehängt wird
}// Ende if (links == null)
else links.hinzufuegen(w); //nicht frei, dann starte funktion hinzufuegen am nächsten Knoten neu

}// Ende if (w < Wert)
else
{
if (rechts == null) // Ist der rechte Sohn frei?
{
rechts = new Binärbaum(w);
rechts.vater = this;
index++;
System.out.println(w + " rechts von :" + Wert + " eingehangen"); //Ausgabe wo der Wert angehängt wird
}// Ende if (rechts == null)
else rechts.hinzufuegen(w); //nicht frei, dann starte funktion hinzufuegen am nächsten Knoten neu
}//Ende Else (w < Wert)
}// Ende (w != Wert)


}
/*******************************Suchfunktion für einen angegebenen Wert ******************************/ 
public void search(int Gesucht)
{
if (Gesucht == Wert){
System.out.println("Der von ihnen gesuchte Wert("+Gesucht+") ist vorhanden");
}
else
{
if (links != null && Gesucht < Wert)
{
links.search(Gesucht);
}
else
{
if (rechts != null && Gesucht > Wert)
{
rechts.search(Gesucht);
}
else
{
System.out.println("Der von ihnen gesuchte Wert("+Gesucht+") ist nicht vorhanden");
}
}
}
} 
/ **********************************************Ausg
abe des gesamten Baums**************************/ 
public void ausgabe()
{
if(links != null )
{
System.out.println(links.Wert+" ist ein linker Wert von: "+links.vater.Wert);
links.ausgabe();
}

if(rechts != null)
{
System.out.println(rechts.Wert+" ist ein rechter Wert von: "+rechts.vater.Wert);
rechts.ausgabe(); 
}

}
/*************************************Löschen eines eingegebenen Wertes********************************************
/ 
public void löschen(int w)
{
{
if (w == this.Wert)
{
if ( this.links == null && this.rechts == null)
{
if ( this.vater.links == this)
{
this.vater.links = null;
System.out.println(w + " Gelöscht!");
}
if ( this.vater.rechts == this)
{
this.vater.rechts = null;
System.out.println(w + " Gelöscht!");
}
}
else
{
if (this.links != null && this.rechts == null)
{
this.links.vater = this.vater;
if ( this.vater.links == this)
{
this.vater.links = this.links;
System.out.println(w + " Gelöscht!");

}
if ( this.vater.rechts == this)
{
this.vater.rechts = this.links;
System.out.println(w + " Gelöscht!");
}
}
else
{
if (this.rechts != null && this.links == null)
{
this.rechts.vater = this.vater;
if ( this.vater.links == this)
{
this.vater.links = this.rechts;
System.out.println(w + " Gelöscht!");

}
if ( this.vater.rechts == this)
{
this.vater.rechts = this.rechts;
System.out.println(w + " Gelöscht!");
}
}
else
{
if (this.rechts.links == null)
{
this.links.vater = this.rechts;
this.rechts.vater = this.vater;
if ( this.vater.links == this)
{
this.vater.links = this.rechts;
System.out.println(w + " Gelöscht!");

}
if ( this.vater.rechts == this)
{
this.vater.rechts = this.rechts;
System.out.println(w + " Gelöscht!");
}

}
else
{
this.Wert = this.rechts.getlastleftwert();
}

}
}


}
}
else
{
if (w < this.Wert)
{
if (this.links != null)
{
this.links.löschen(w);
}
else
{
System.out.println(w + " ist nicht vorhanden");
}
}
if (w > this.Wert)
{
if (this.rechts != null)
{
this.rechts.löschen(w);
}
else
{
System.out.println(w + " ist nicht vorhanden");
}
}
}

return;

}
} 
private int getlastleftwert()
{


int Hilf;
if(this.links != null)
{
return this.links.getlastleftwert();
}
else
{
this.vater.links = null;
return this.Wert;
}


}
}

Generiert wird er durch folgendes:


public class Binärausführen {

public static void main(String[] args) {

Binärbaum aloha = new Binärbaum(12);
aloha.eingabe();
aloha.eingabe();
aloha.eingabe();
aloha.eingabe();
aloha.eingabe();
aloha.eingabe();
aloha.eingabe();
```

bitte code-tags nutzen, mfg mariopetr


----------



## gustav (27. Okt 2003)

Schau mal bei Google nach OpenJGraph oder VGJ in Verbindung mit Java. Bei Beiden kann man sich Graphen visualisieren lassen und die Bibliotheken nehmen einem dabei noch eine Menge von Skalierungsarbeiten ab. VGJ hat hierbei das komfortablere Benutzerinterface, allerdings wird noch das Java 1.1 AWT Message Konzept verwendet was wiederum zu Warnungen des Compilers führt. 
Zur Darstellung mußt Du allerdings immer noch gesondertet Routinen schreiben, also z.B. eine Tiefensuche die dann alle Knoten in die entsprechenden Datenstrukturen einpackt. Falls Du Interesse hast, kann ich mal nachschauen, ob ich noch irgendwo Sourcen habe. Dann fällt die Einarbeitung hoffentlich leichter.....

2.Frage :
Deine Klassenvariable 

```
protected int Binarbaum.Wert
```
brauchst Du einfach nur nach Object umbennnen. Danach noch alle Routinen, in denen Du mit diesem Wert handierst. Oder warte bis Java 1.5, dann sollen ja die Templates kommen....


----------



## Amberstar (28. Okt 2003)

Also ich habe jetzt folgende änderungen vorgenommen um den Baum abstarct zu machen:


```
import java.io.*;

public abstract class Binärbaum 
{
	


	protected Object Knoten;
	protected int index = 0;
	protected Object w;
	protected Object Wert;
	Binärbaum vater, links, rechts;
	
	
/************************Konstruktor für den Binärbaum, der einen Eingegebenen Wert erwartet***********************/
	Binärbaum(Object w)
	{	
				Wert = w;
				vater = null;
				links = null;
				rechts = null;
				index++;
				hinzufuegen(w);
		
	}		
			
	
/*	
public String toString()				
		{
			String s = (NamedesKnotens+" :"+Knoten);
			return s;	
		}
*/	
/************************Eingabe der hinzuzufügenden einzelnen Werte*******************************/
public Object eingabe()
{	

			System.out.print("Eingabe des Wertes: ");
		try
		{
			BufferedReader buffer = new BufferedReader(new InputStreamReader(System.in));
			Knoten = buffer.readLine();
			w = Knoten;
			hinzufuegen(w);   //Startet den Vorgang hinzufügen mit dem Eingegebenen Wert
		}	
		catch (IOException ioe)
		{
			System.out.print("Fehler: " + ioe);
			System.exit(1);
		}
		return w;
		
}	
/********************************Hinzufuegen des eingegebenen Wertes zum Binärbaum*******************************/	
public void hinzufuegen(Object w)
	{	
		
		if (gleich(Wert,w))
			{
				if (w == kleiner(w,Wert))
				{
					if (links == null)   //Ist der linke Sohn frei?
					{
						links = new Binärbaum(w);
						links.vater = this;
						index++;
						System.out.println(w + " links von :" + Wert + " eingehangen");  //Ausgabe wo der Wert angehängt wird
					}// Ende if (links == null)
					else links.hinzufuegen(w); //nicht frei, dann starte funktion hinzufuegen am nächsten Knoten neu
				
				}// Ende if (w < Wert)
				else
				{
					if (rechts == null)  // Ist der rechte Sohn frei?
					{
						rechts = new Binärbaum(w);
						rechts.vater = this;
						index++;
						System.out.println(w + " rechts von :" + Wert + " eingehangen"); //Ausgabe wo der Wert angehängt wird
					}// Ende if (rechts == null)
					else rechts.hinzufuegen(w);  //nicht frei, dann starte funktion hinzufuegen am nächsten Knoten neu
				}//Ende Else (w < Wert)
			}// Ende (w != Wert)
			
		
	}
/*******************************Suchfunktion für einen angegebenen Wert ******************************/	
public void search(Object Gesucht)
	{
		if (Gesucht == Wert){
			System.out.println("Der von ihnen gesuchte Wert("+Gesucht+") ist vorhanden");
		}
		else
		{
			if (links != null && ( Gesucht == kleiner(Gesucht,Wert)))
			{
				links.search(Gesucht);
			}
			else
			{
				if (rechts != null && (Gesucht == grösser(Gesucht,Wert)))
				{
					rechts.search(Gesucht);
				}
				else
				{
					System.out.println("Der von ihnen gesuchte Wert("+Gesucht+") ist nicht vorhanden");
				}
			}
		}
	}	
/**********************************************Ausgabe des gesamten Baums**************************/	
public  void ausgabe()
	{
		if(links != null )
		{
			System.out.println(links.Wert+" ist ein linker Wert von: "+links.vater.Wert);
			links.ausgabe();
		}
		
		if(rechts != null)
		{
			System.out.println(rechts.Wert+" ist ein rechter Wert von: "+rechts.vater.Wert);
			rechts.ausgabe();	
		}
			
	}
/*************************************Löschen eines eingegebenen Wertes********************************************/	
public void löschen(Object w)
	{
		{
		if (w == this.Wert)
		{
			if ( this.links == null && this.rechts == null)
			{
				if ( this.vater.links == this)
				{
					this.vater.links = null;
					System.out.println(w + " Gelöscht!");
				}
				if ( this.vater.rechts == this)
				{
					this.vater.rechts = null;
					System.out.println(w + " Gelöscht!");
				}
			}
			else
			{
				if (this.links != null && this.rechts == null)
				{
					this.links.vater = this.vater;
					if ( this.vater.links == this)
					{
						this.vater.links = this.links;
						System.out.println(w + " Gelöscht!");
						
					}
					if ( this.vater.rechts == this)
					{
						this.vater.rechts = this.links;
						System.out.println(w + " Gelöscht!");
					}
				}
				else
				{
					if (this.rechts != null && this.links == null)
					{
						this.rechts.vater = this.vater;
						if ( this.vater.links == this)
						{
							this.vater.links = this.rechts;
							System.out.println(w + " Gelöscht!");
		
						}
						if ( this.vater.rechts == this)
						{
							this.vater.rechts = this.rechts;
							System.out.println(w + " Gelöscht!");
						}
					}
					else
					{
						if (this.rechts.links == null)
						{
							this.links.vater = this.rechts;
							this.rechts.vater = this.vater;
							if ( this.vater.links == this)
							{
								this.vater.links = this.rechts;
								System.out.println(w + " Gelöscht!");

							}
							if ( this.vater.rechts == this)
							{
								this.vater.rechts = this.rechts;
								System.out.println(w + " Gelöscht!");
							}
							
						}
						else
						{
							this.Wert = this.rechts.getlastleftwert();
						}
						
					}
				}
				
				
			}
		}
		else
		{
			if (w == kleiner(w,this.Wert))
			{
				if (this.links != null)
				{
					this.links.löschen(w);
				}
				else
				{
					System.out.println(w + " ist nicht vorhanden");
				}
			}
			if (w == grösser(w,this.Wert))
			{
				if (this.rechts != null)
				{
					this.rechts.löschen(w);
				}
				else
				{
					System.out.println(w + " ist nicht vorhanden");
				}
			}
		}
		
	return;
		
	}
	}	
private Object getlastleftwert()
	{

	
		Object Hilf;
		if(this.links != null)
		{
			return this.links.getlastleftwert();
		}
		else
		{
			this.vater.links = null;
			return this.Wert;
		}
		
	
	}

public abstract boolean gleich(Object Wert1, Object Wert2);
	
public abstract Object grösser(Object Wert1, Object Wert2);
			
public abstract Object kleiner(Object Wert1, Object Wert2);
			
}
```
Nur bei folgenden Zeilen habe ich jetzt noch Probleme es umzustellen:


```
if (links == null)   //Ist der linke Sohn frei?
					{
						links = new Binärbaum(w);
						links.vater = this;
```


```
rechts = new Binärbaum(w);					rechts.vater = this;
```
in diesen Codezeilen hat er ein Problem mit new Binärbaum!!!
Hierbei zeigt er mir immer noch einen compiler fehler an, wer weiss rat????


----------



## Amberstar (28. Okt 2003)

Habe das Problem jetzt geknackt. Habe ihn nun abstract generiert und mit int´s getestet.
Aber das Problem ihn grafisch darzustellen habe ich immer noch, also würde ich mich über die Sourcen sehr freuen Gustav. Auch für andere Tips wäre ich sehr dankbar.

MfG
Amberstar


----------



## Amberstar (29. Okt 2003)

Ich würde die Ausgabe jetzt gerne mit JTree realisieren, hat da jemand ne idee?


----------

