You are not logged in.

  • Login

1

Friday, December 7th 2007, 1:00am

Klasse Baum

Ich hab hier mal wieder eine ganz interessante Aufgabe. WÄr ganz nett wenn wir hier ein paar Ideen zusammenbekommen könnten. Weil so ganz alleine krieg ich das wohl nicht hin...Danke schonmal für die Tipps.

Implementieren Sie eine Klasse BinaerBaum. In den Knoten sollen Zeichenketten verwaltet
werden können. Folgende Methoden sollen enthalten sein:
void fuegeEinSortiert(String neu):
Einfügen einer neuen Zeichenkette in den Baum nach dem Prinzip:
Falls Neu < Inhalt des Knotens dann in den linken Unterbaum, sonst in den
rechten Unterbaum.
void ausgabeLWR(): Ausgabe des Baumes in der Reihenfolge Links-Wurzel-Rechts:
das führt zu einer aufsteigend sortierten Folge
void ausgabeRWL(): Ausgabe des Baumes in der Reihenfolge Rechts-Wurzel-Links:
das führt zu einer absteigend sortierten Folge
int anzahl(): Ermittelt die Anzahl der Knoten im Baum (rekursiv)
Nutzen Sie für die Darstellung eines Baumes die Methode ausgabe() (siehe Datei
baumausgabe.txt) Wie sind die Methoden ausgabeLWR() bzw. ausgabeRWL() zu ändern,
damit im Ergebnis eine Folge sortierter Zeichenketten entsteht, die auch weiter verarbeitet
werden kann? (Hinweis: String-Array oder ArrayList)

a) Entwickeln Sie für die Klasse BinaerBaum eine Methode, die für den Baum die Tiefe
bestimmt.
b) Wenn Bäume sehr ungleich sind, versucht man diese mittels Rotationen auszugleichen.
Machen Sie sich mit den Rotationsoperationen auf Bäumen vertraut und implementieren Sie
die Methoden rotiereLinks() sowie rotiereRechts():

2

Friday, December 7th 2007, 2:28am

Hast du schon angefangen? Das Grundgerüst kannst du ja schon mal machen...

3

Sunday, December 9th 2007, 3:14pm

Ich schließe mich mal der Frage bzw. Aufgabe an....

Würde persönlich erstmal so anfangen.

Java Quellcode

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
class BinBaum  // ------------------------------------------------
{ BinBaum links;   // linker Teilbaum
  BinBaum rechts;  // rechter Teilbaum
  String inhalt;   // Inhalt soll String sein.
 
  // Konstruktor
  BinBaum (String neu)
  { this.links  = null;
	this.rechts = null;
	this.inhalt = neu;
  }
 
  void fuegeEinSortiert (String neu)
  { if (inhalt == neu)
     	{ // in linken Teilbaum einfuegen
       	if (links == null)
            	links = new BinBaum(inhalt);
       	else links.fuegeEinSortiert(inhalt);
     	}
	else { // in rechten Teilbaum einfuegen
       	if (rechts == null)
            	rechts = new BinBaum(inhalt);
       	else rechts.fuegeEinSortiert(inhalt);
     	}
  } // fuegeEinSortiert
 
  void ausgabeLWR()
  {};
  void ausgabeRWL()
	{};
  int anzahl()
	{return 6;}
 
  void ausgabe ()
  {  if (links != null) links.ausgabe();
 	System.out.print(inhalt); System.out.println();
 	if (rechts != null) rechts.ausgabe();
  } // laufeDurch
} // class BinBaum


Wobei das erstmal das Gerüst wäre... Die Methode fuegeEinSortiert ist aber auch noch nicht richtig... Wäre nun auch für weitere Hilfe dankbar.

4

Sunday, December 9th 2007, 4:09pm

Ich schließe mich mal der Frage bzw. Aufgabe an....

Würde persönlich erstmal so anfangen.

Java Quellcode

1
class BinBaum  // ------------------------------------------------ { BinBaum links;   // linker Teilbaum   BinBaum rechts;  // rechter Teilbaum   String inhalt;   // Inhalt soll String sein.     // Konstruktor   BinBaum (String neu)   { this.links  = null; this.rechts = null; this.inhalt = neu;   }     void fuegeEinSortiert (String neu)   { if (inhalt == neu)      { // in linken Teilbaum einfuegen        if (links == null)             links = new BinBaum(inhalt);        else links.fuegeEinSortiert(inhalt);      } else { // in rechten Teilbaum einfuegen        if (rechts == null)             rechts = new BinBaum(inhalt);        else rechts.fuegeEinSortiert(inhalt);      }   } // fuegeEinSortiert     void ausgabeLWR()   {};   void ausgabeRWL() {};   int anzahl() {return 6;}     void ausgabe ()   {  if (links != null) links.ausgabe();  System.out.print(inhalt); System.out.println();  if (rechts != null) rechts.ausgabe();   } // laufeDurch } // class BinBaum



Wobei das erstmal das Gerüst wäre... Die Methode fuegeEinSortiert ist aber auch noch nicht richtig... Wäre nun auch für weitere Hilfe dankbar.

5

Monday, December 10th 2007, 6:24pm

Hey Blane, ich hab grade folgendes gefunden zu der Aufgabe...

Quoted

Schauen Sie doch einmal unter Wikipedia und binärem Suchbaum:
<img src="https://studip.hs-wismar.de/assets/images/link_extern.gif" border="0" />[url]http://de.wikipedia.org/wiki/Bin%C3%A4rer_Suchbaum[/url]
Dort wird die Rotation erklärt.
Bei einer Rotation nach rechts passiert folgendes:
<code>


A B

+---+---+ Rotation rechts: +---+---+

B baum3 ==================> baum1 A

+---+---+ +---+---+

baum1 baum2 baum2 baum3


</code>
  • Der linke Nachfolger der Wurzel wird zum neuen Wurzelknoten
  • Die alte Wurzel(A) wird zum rechten Nachfolger der neuen Wurzel(B)
  • Der alte rechte Unterbaum (b3) der Wurzel(A) bleibt rechter Unterbaum von A
  • Der alte linke Unterbaum (b1) von B bleibt linker Unterbaum von B
  • Der alte rechte Unterbaum(b2) von B wird linker Unterbaum von A
Kann uns da mal jemand bitte weiterhelfen?

6

Monday, December 10th 2007, 7:56pm

Achja und Hier ist der Bauplan der Klasse StringTree zu sehen, der neben den
Zugriffsmethoden, die Methoden zum Einfügen und zum Ausgeben enthält.
Die Anwendung dieser Klasse ist der Klasse TestTree zu entnehmen.

Java Quellcode

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
/**
* Ein binärer Suchbaum für Zeichenketten.
* 
* Generell können beliebige Objekte in einem Baum verwaltet werden.
* Ein binärer Suchbaum kann nur Objekte verwalten, die vergleichbar
* sind, d.h. auf denen eine Ordnung existiert.
* Programmtechnisch müssen diese Objekte das Interface Comparable
* implementieren.
* 
* @author Uwe Lämmel
* @version 04.12.2007
*/
public class StringTree {
 
//-- Bauplan ----------------------------------------------------
String obj; // Inhalt des Knoten
StringTree left; // linker Teilbaum
StringTree right; // rechter Teilbaum
 
//-- Konstruktor new --------------------------------------------
public StringTree(String x,StringTree l,StringTree r)
{ obj=x; left=l; right=r; }
public StringTree(String x) { obj=x; left= right=null;}
public StringTree() { obj=null; left= right=null;}
 
//-- getLeft,getRight, getRoot ----------------------------------
public StringTree getLeft () { return left; }
public StringTree getRight () { return right; }
public String getObject () { return obj; } 
 
//-- setLeft, setRight, setRoot ---------------------------------
public void setLeft (StringTree l) { left =l; }
public void setRight (StringTree r) { right=r; }
public void setObject(String x) { obj =x; }
 
 
//-- Einfügen eines neuen Elementes 
public void insert(String x){
// Vergleich ob in den linken oder rechten Unterbaum
if(getObject().compareTo(x)>0){
// Wenn Unterbaum leer, dann neues Element einfügen 
if(getLeft()==null) {
// Erzeugen eines neuen Knotens mit x als Inhalt 
StringTree st = new StringTree(x); 
setLeft(st);
}/if
// Sonst rekursives Einfügen im Unterbaum:
else getLeft().insert(x);
}
else{ // wie links, siehe oben
if(getRight()==null){
// Erzeugen eines neuen Knotens mit x als Inhalt 
StringTree st = new StringTree(x); 
setRight(st);
}//if
else getRight().insert(x);
}
}//insert
 
//-- Ausgabe des Baumes in sortierter Reihenfolge
//-- aufsteigend: Links-Wurzel-Rechts 
public String ausgabeLWR(){
String s="";
if(getLeft()!=null) s += getLeft().ausgabeLWR();
s += " "+getObject();
if(getRight()!=null) s += getRight().ausgabeLWR();
return s;
}//LWR
 
 
 
//-- ShowBranches -----------------------------------------------
//-- Hilfsmethode zur formatierten Ausgabe auf der Konsole
private void showBranches(int level) {
IntIO io = new IntIO();
if (getRight()!=null) getRight().showBranches(level+1);
for(int i=0; i<level;i++) io.write(" "); io.writeln("+-> "+getObject());
if (getLeft()!=null) getLeft().showBranches(level+1);
}//showBranches 
 
//-- ausgabe ----------------------------------------------------
public void ausgabe() { this.showBranches(0); }
 
}//StringTree

7

Monday, December 10th 2007, 8:16pm

Und was brauchst du jetzte noch?

8

Tuesday, December 11th 2007, 4:14pm

  • Man merke sich die Unterbäume von B (BR,BL) sowie den rechten von A (AR).
  • Setzen Sie einen neuen rechten Unterbaum zur Wurzel A: temp
  • Der Knoten temp erhält den Inhalt von A und als rechten Unterbaum AR.
  • Der linke Unterbaum des Knoten temp wird mit BR belegt.
  • Die Wurzel erhält als Inhalt den Inhalt von B, sowie den linken Unterbaum BL.

Damit ist eine Methode: public void rotateRight(){...} möglich.

Wir
rotieren somit nicht den Wurzelknoten selbst sondern verändern seinen
Inhalt. Im Ergebnis entsteht dann ein Baum, der dem unten stehenden
Ergebnis entspricht.

9

Tuesday, December 11th 2007, 5:35pm

Weiß da keiner weiter? Ich bräuchte da dringend ein wenig Hilfe. Benötige das morgen für die Vorlesung. Wär super wenn jemand helfen könnten. Blane und ich haben ja soweit schon alles hierreingestellt, was wir haben oder was zur Verfügung steht.

Similar threads

Social bookmarks