Baum

Fakultät für
Wirtschaftswissenschaften
Einführung in die Programmierung
Behälter-Klassen / Container-Klassen
Uwe Lämmel
www.wi.hs-wismar.de/~laemmel
[email protected]
Uwe Lämmel
Container-Klassen
Folie 1
Inhalt
 Datenbehälter – Container – Collection
– Zugriff bestimmt Verhalten
– abstrakter Datentyp
 Schlange
 Keller
 Baum
 Tabelle
Uwe Lämmel
Container-Klassen
Folie 2
Datenbehälter – Container – Collection
 Verwaltung von Objekten
 Standardisierte Zugriffsoperationen
– Implementation verbergen
– Abstrakte Datentypen
abstrakt: Abstraktion von Implementation
Uwe Lämmel
Container-Klassen
Folie 3
Datenbehälter – Container – Collection
 Schlange (queue)
First In First Out: FIFO
 Keller (Stack, Stapel)
Last In First Out : LIFO
 Tabelle (table)
Zugriff über Schlüssel
 Baum (tree)
Hierarchie
 Liste (list, Folge)
vor-zurück-anfang-ende
 Menge (set)
jedes Element nur einmal
Druckerwarteschlange, Tastaturpuffer, …
Methoden-Stack, Compilieren von Programmen, …
Datenbanken
Datenbanken, Suchen, Sortieren, …
Zeileneditor, Grundstruktur für Container
Uwe Lämmel
Container-Klassen
Folie 4
Schlange: Implementation ArrayList
class Queue {
ArrayList<String> queue;
//-- Konstruktor -----------------------------------------------public Queue () {
queue = new ArrayList<String>();
} //Queue
//-- Insert --- Remove ---- getFirst------------------------------public void insert(String x) { queue.add(x);
public void remove() { if (!isEmpty()) …}
}
public String getFirst() {
if (isEmpty()) return ??? ; else return ????;
} //getFirst
…
} //Queue
Uwe Lämmel
Container-Klassen
Folie 5
Die Schlange – verkettete Liste
“Tom“
“Anna“
“Paula“
“Max“
first
last
“Lea“
benötigen:
Wir
Einfügen
– Elemente (Objekte),
Inhalt (Name) und Referenz (auf Objekt)
 die
Löschen
verwalten  class Element
Uwe Lämmel
Container-Klassen
Folie 6
Elemente der Schlange
obj: “Inhalt“
next:
class Element {
private String
obj;
private Element next;
public
public
public
public
public
public
}//Element
Uwe Lämmel
Element ( )
{ obj= null; next=null; }
Element (String ob) { obj= ob; next=null; }
void
void
Object
Element
setString
setNext
getString
getNext
(String ob)
(Element x)
()
()
{ obj=ob;
}
{ next=x;
}
{ return obj; }
{ return next; }
Container-Klassen
Folie 7
Die Schlange – verkettete Liste
“Tom“
“Anna“
first
last
“Paula
“
“Max“
class QueueEl {
private Element first;
private Element last;
public QueueEl( ){ first=last=null; }
public void insert(String ob){ ... }
public Object getFirst ( ) {
if (isEmpty()) return null;
else
return first.getString( );
}//getFirst
Uwe Lämmel
Container-Klassen
Folie 8
Testrahmen Schlange
public static void main(String[ ] args) throws Exception {
char
c
= 'x';
boolean ende = false;
QueueEl p
= new QueueEl( );
LineIO io
= new LineIO( );
do {
c=io.readChar( "eXit Insert Remove ... : "); // Kommando lesen
switch (c) { // Auswahl der Aktion:
case 'x': ende = true; break;
case 'i': s = io.readString(" ... "); p.insert(s); break;
case 'f': io.writeln("Spitze: "+p.getFirst( )); break;
...
default: io.writeln(" Eingabe nicht verstanden :-( ");
} //switch
}
while(!ende); // wiederhole, solange noch nicht ende erreicht
Uwe Lämmel
Container-Klassen
Folie 9
mehrfache Alternative: switch-Anweisung
switch (Ausdruck) {
case Ausdruck1 : Anweisungen1
case Ausdruck2 : Anweisungen2
...
case AusdruckN : AnweisungenN
default :
Anweisungen
} //switch
switch (i) {
case 1 : wort="eins"; break;
case 2 : wort="zwei"; break;
case 3 :
case 4 : wort="einige"; break;
default : wort="viele";
} //switch
Uwe Lämmel
Container-Klassen
Folie 10
switch-Anweisung: Interpretation
switch (Ausdruck) {case Ausdruck1: Anweisungen ... }
 Ausdruck im Kopf vom Typ int, char, byte, short, oder long
seit Java 8 auch String

Jeden Teil mit break beenden,
falls kein weiterer case-Teil beachtet werden soll!
Interpretation:
Der Ausdruck wird ausgewertet und mit den Ausdrücken 1 bis N
der Reihe nach verglichen.
Stimmen beide überein,
wird die Bearbeitung an dieser Stelle fortgesetzt.
Gibt es keine Übereinstimmung wird der default-Teil ausgeführt
(sofern vorhanden).
Uwe Lämmel
Container-Klassen
Folie 11
mehrfache Alternative: else-if
if (Ausdruck== Ausdruck1) {Anweisungen1 }
else if (Ausdruck == Ausdruck2) { Anweisungen2}
...
else if (Ausdruck == AusdruckN) { AnweisungenN}
else { //default
Anweisungen
if
(i== 1)
wort ="eins";
} //if
else if (i== 2 )
wort ="zwei";
else if (i== 3 || i== 4 ) wort ="einige";
else
wort ="viele";

switch kann immer durch else-if ersetzt werden!
Umgekehrt: else-if durch switch ersetzen?
Uwe Lämmel
Container-Klassen
Folie 12
Aufgabe Schlange – Array
 Entwickeln Sie eine zweite Implementation einer Schlange:
Klasse QueueA.
 Benutzen Sie ein Array zum Speichern der Zeichenketten in
der Schlange
 Entwickeln Sie eine ausführbare Klasse zum Testen der
Schlange (main-Methode)
 Zusatzaufgabe:
Wie kann eine Schlange mittels ArrayList realisiert werden?
Uwe Lämmel
Container-Klassen
Folie 13
Stack – Keller - Stapel
Methoden:
push
– Objekt auf den Stapel legen
peek
– Oberstes Element zurückgeben
pop
– Oberstes Element löschen
depth – Tiefe des Kellers = Anzahl Elemente
isEmpty – Ist der Keller leer?
Uwe Lämmel
Container-Klassen
Folie 14
Stack – Keller - Stapel
class IntStack {
int [ ] stack;
int
zst; // Zeiger auf stack und Anzahl der Elemente
int
max; // maximale Anzahl von Elementen im
Stack
//-- Konstruktor -----------------------------------------------public IntStack(int max) { // maximale Anzahl im Keller
this.max = max; stack = new int[max]; zst = 0;
} //StackA
//-- Push --- Pop ---- Peek--------------------------------------public void push(int x) {
if (!isFull()) { stack[zst]=x; zst++; }
}//push
public void pop() { if (!isEmpty()) zst--; }
Uwe Lämmel
public int peek() {
if (isEmpty()) return -1; else return stack[zst-1];
} //top
Container-Klassen
Folie 15
Stack-Anwendung
3.
umgedreht
Stack s1 = new Stack(4);
s1.push(“Die“);
s1.push(“Reihenfolge“);
s1.push(“wird“);
s1.push(“umgedreht“);
2.
wird
1.
Reihenfolge
0.
Die
io.writeln(s1.top( )); // Ergebnis: „umgedreht“
Uwe Lämmel
Container-Klassen
Folie 16
java.util.Stack
java.lang.Object
|
+--java.util.AbstractCollection<E>
|
+--java.util.AbstractList<E>
|
+--java.util.Vector<E>
|
+--java.util.Stack<E>
The Stack class represents a
last-in-first-out (LIFO) stack of
objects.
It extends class Vector with
five operations that allow a
vector to be treated as a
stack.
The usual push and pop operations are provided, as well as a
method to peek at the top item on the stack, a method to test for
whether the stack is empty, and a method to search the stack for
an item and discover how far it is from the top.
Uwe Lämmel
Container-Klassen
Folie 17
Zusammenfassung
 Keller (LIFO)
 Schlange (FIFO)
 rekursive Datenstruktur: verkettete Liste
 Testrahmen
 switch-Anweisung
Uwe Lämmel
Container-Klassen
Folie 18
(Binär)Baum
Der leere Baum ist ein Baum.
Sind B1, B2 Bäume
und k ein Knoten
und k nicht in B1 oder B2 enthalten,
so ist auch
Wurzel
Knoten
Blatt
k2
b3
leer
ein Baum.
b4
k3
Uwe Lämmel
k
B1
B2
k4
Container-Klassen
Folie 19
Arbeiten mit Bäumen
Bearbeite:
– einen Teilbaum,
– dann Wurzel/Knoten,
– dann anderen Teilbaum
max
bob
alf
pit
kai
null
tom
ray
Reihenfolge ist Problem
– links – wurzel
– rechts – wurzel
– links – rechts
– wurzel – links
abhängig:
– rechts
– links
– wurzel
– rechts
uwe
alf, bob, kai, max, pit,ray, tom, uwe
Uwe Lämmel
Container-Klassen
Folie 20
Elemente eines Binärbaums
obj: “Inhalt“
:left
right:
class Tree {
private Object obj;
private Tree left;
private Tree right;
public
public
public
public
public
public
public
...
} //Tree
Uwe Lämmel
Tree
Tree
Tree
()
{ obj= null; left=right=null;}
(Object o)
{ obj=o; left=right=null;}
(Object o, Tree l, Tree r) { obj=o; left=l; right=r; }
void
void
Object
Tree
setObject
setLeft
getObject
getLeft
(Object o)
(Tree x)
()
()
{ obj=o;
}
{ left=x;
}
{ return obj; }
{ return left; }
Container-Klassen
Folie 21
Binärer Suchbaum
• nur für Elemente, für die eine Ordnung existiert (vergleichbar)
pat,tom,ulf,dan,ali,alf,eva,pit,ulf,udo,bee,bea,uli,bub
k
B1
pat
B2
Suchbaum:
• x, xB1: x<k
• x, xB2: kx
• B1, B2 - Suchbäume
dan
ali
alf
eva
bee
bea
Uwe Lämmel
tom
pit
ulf
udo
uli
bub
Container-Klassen
Folie 22
Methoden auf (Such-) Bäumen
 Sortiertes Einfügen in einen Baum
 Suche in einem Baum
 Anzahl der Knoten in einem Baum
 Anzahl der Blätter in einem Baum
 Tiefe eines Baumes
 Ausgabe des Baumes
– preorder (WLR –wurzel-links-rechts) – Präfix-Notation
– inorder
(LWR) – aufsteigend sortiert
– postorder (LRW) – Postfix-Notation
 Test auf AVL-Baum
Uwe Lämmel
Container-Klassen
Folie 23
Baum: Rekursive Methoden – Anzahl Knoten
public int anzKnoten() {
int anz = 1; // mind. akt. Knoten
if(left!=null)
anz += left.anzKnoten();
if(right!=null)
anz += right.anzKnoten();
return anz;
} //Tree
1
max
+3
bob
alf
pit
kai
null
tom
ray
Uwe Lämmel
+4
uwe
Container-Klassen
Folie 24
Baum: Rekursive Methoden
publicvoid
void
runInorder(LineIO
public
runInorder(LineIO
io) { io) {
if(this.getLeft(
)!=null)
if(left!=null)
left.runInorder(io);
this.getLeft(
).runInorder(io);
io.writeln(
obj.toString()
);
io.writeln( right.runInorder(io);
if(right!=null)
} //Tree this.getObject( ).toString() );
max
bob
alf
pit
kai
null
tom
ray
Uwe Lämmel
if(this.getRight( )!=null)
this.getRight( ).runInorder(io);
} //Tree
uwe
Container-Klassen
Folie 25
Liste
Methoden:
 Operationen nur an der markierten Position
– read
– insert
– remove
 Operationen zum Verschieben der Markierung:
– next
– prev
– pos1
– end
Beispiel: Zeileneditor
Uwe Lämmel
Container-Klassen
Folie 26
Liste – einfach verkettet
liste
“Tom“
“Anna“
“Paula“
“Max“
aktuell
“Tom“
 Einfügen: danach, eingefügtes Element ist aktuell

Uwe Lämmel
Probleme am Listenanfang!
Container-Klassen
Folie 27
Klasse Liste (von Zeichenketten)
class Liste {
private Element liste;
private Element aktuell;
public Liste( ) { liste=aktuell=null; }
public Liste(String neu) {
liste = new Element(neu); aktuell = liste;
} //Liste
public void insert(String ob) {
Element neu = new Element(obj);
if(aktuell==null) neu.setNext(liste);
else neu.setNext(aktuell.getNext());
if(aktuell==null) liste = neu;
else aktuell.setNext(neu);
aktuell = neu;
} //insert
Uwe Lämmel
Container-Klassen
Folie 28
Zusammenfassung
 Datenbehälter verwalten mehrere Objekte
 Datenbehälter haben definierte
Zugriffsmöglichkeiten
 Trennung von Interface und Implementation
 interface definiert Nutzung einer Klasse
 Baum-Operationen können (nur) mit rekursiver
Programmierung implementiert werden
 rekursive Datenstruktur
 einfach verkettete Liste
Uwe Lämmel
Container-Klassen
Folie 29
Ende
Uwe Lämmel
Container-Klassen
Folie 30