Timo

Stunden-Protokoll für den 21.03.2011
Als allererstes haben wir das UML-Diagramm des Binärbaumes besprochen und sind zu
folgendem Ergebnis gekommen:
Man sieht zwischen den Klassen nur Assoziationen, da keine Vererbung auftritt und keine
Klasse aus einer anderen besteht.
Anschließend haben wir besprochen, wie die einfuege- und finde-Operation aussieht.
Meine Lösung dazu:
Im Binärbaum:
public void einfuegen (int v) {
if(wurzel==null){
// Sollte der Baum leer sein wird ein neuer Knoten
// erstellt und zur Wurzel gemacht
wurzel=new Knoten(v);
laenge++;
return;
}
// Andernfalls wird der Wurzel das Einfügen übergeben
wurzel.einfuegen(v);
laenge++;
}
Im Knoten:
public void einfuegen(int v){
//Ist der neue Wert größer/gleich des eigenen Werts
if(value<=v){
if(right==null){
//Und der rechte Teilbaum leer
//So wird ein neuer Knoten erstellt
Knoten newK=new Knoten(v);
right=newK;
//und zum rechten TB gemacht
return;
}else{
//Ist der rechte TB vorhanden, wird ihm das
//Einfügen befohlen
right.einfuegen(v);
}
// Ist der neue Wert kleiner des eigenen Werts
}else{
if(left==null){
//Und der linke Teilbaum leer
//So wird ein neuer Knoten erstellt
Knoten newK=new Knoten(v);
left=newK;
//und zum linken TB gemacht
return;
}else{
//Ist der rechte TB vorhanden, wird ihm das
//Einfügen befohlen
left.einfuegen(v);
}
}
}
Die Einfüge-Operation ist fast dieselbe. Mann muss nur an den Stellen, an denen ein neuer
Knoten erstellt wird, return false schreiben und an den Stellen, an denen einfuegen der
Teilbäume ausgeführt wird, return teilbaum.finden(v) schreiben.
Dann haben wir uns den Syntax für inorder überlegt:
existiert linker Nachfolger?
Ja: liefere links.inorder
Nein: erstelle Array mit 0 Elementen
existiert rechter Nachfolger?
Ja: liefere rechts.inorder
Nein: erstelle Array mit 0 Elementen
Neues Array
Länge= arrayL + 1 + arrayR
Als Quellcode sieht es dann so aus:
Im Binärbaum:
public int[] inorder(){
if(wurzel==null){
int n[]=new int[0];
return n;
}
//Ansonsten die Ausgabe
return wurzel.inorder();
}
//Falls der Baum leer ist
//Array mit 0 Elementen erstellen
// Und zurückgeben
der Wurzel zurückgeben
Im Knoten:
public int[] inorder(){
int index=0; //Index der nächsten freien Stelle im Array
int l[];
if(left==null){ //Falls der linke Teilbaum leer ist
l=new int[0]; //Einen Array mit 0 Elementen erstellen
}else{
//Ansonsten die Reihenfolge des linken TB speichern
l=left.inorder();
}
int r[];
//Das gleiche wird mit dem rechtem TB wiederholt
if(right==null){
r=new int[0];
}else{
r=right.inorder();
}
//Ein neues Array erstellen
int n[]=new int[l.length+1+r.length];
//Und alle Elemente der linken Reihenfolge
for(int i=0; i<l.length; i++){
n[index]=l[i];//In den neuen Array schreiben
index++;
//Und den Index aktualisieren
}
n[index]=value; //Wurzel in der Mitte speichern
index++;
//Und die rechte Reihenfolge hintendran hängen
for(int i=0; i<r.length; i++){
n[index]=r[i];
index++;
}
return n; //Anschließend den neuen Array zurückgeben
}
Es folgte aufgrund vermehrter Fehler eine Wiederholung zum Sichtbarkeitsbereich von
Variabeln:
public class Test{
public void test(){
If(links!=null){
int l[]=links.gibInorder();
}
l[x]=wurzel.wert; //Error, int l[] nicht bekannt
}
}
Eine Variable ist nur innerhalb ihres Befehlsblockes(markiert durch geschweifte Klammern)
bekannt. In diesem fall existiert die Variable l[] ab der } vor der Zeile, in der sie benutzt wird,
nicht mehr.
public class Test{
public void test(){
int l[];
If(links!=null){
l=links.gibInorder();
}
//Error, int l[] möglicherweise nicht initialisiert
l[x]=wurzel.wert;
}
}
Diese Version funktioniert so lange, wie links ungleich null ist, weil sonst der Array zwar
deklariert, aber nicht initialisiert wäre.
int l[]=new int[0];
Kann dort Abhilfe verschaffen.