Liste - Informatik
Werbung
Slide 1
Listen
Klaus Becker
2003
Slide 2
Listen
2
Ansgar A., Speyer
Claudia B., Koblenz
Knut B., Neustadt
Listen
Annett B., Wörrstadt
Stefani D., Bad Ems
Jochen F., Ludwigshafen
...
...
Wieland S., Trier
Harald T.-R., Biesdorf
KB
Slide 3
Listen
3
KB
Teil 1
Objektorientierte Modellierung und Implementierung
von Listen
Slide 4
Was ist eine Liste?
4
Lisa
Roland
Anna
Listen
Gerd
Bernd
Stefanie
Eine Liste ist eine endliche,
beliebig lange Folge von
Elementen, in der an jeder
Stelle neue Elemente eingefügt
oder vorhandene Elemente
entfernt werden können.
Susanne
Walter
Ulrike
Theo
...
KB
Ziel ist es zunächst, die
dynamische Datenstruktur „Liste“
mit Hilfe einer geeigneten Klasse
zu implementieren.
Slide 5
Objektorientierte Repräsentation
5
Lisa
... = Lisa
Roland
Anna
Listen
Gerd
Bernd
... = Roland
Stefanie
Susanne
... = Anna
... = Bernd
Walter
Ulrike
...
KB
... = Gerd
...
Slide 6
6
Objektorientierte Repräsentation
Listen
Die Listenelemente
werden mit Hilfe von
Objekten beschrieben.
Die Folgenstruktur der
Liste wird mit Hilfe von
Referenzen aufgebaut.
... = Lisa
... = Roland
... = Anna
... = Bernd
... = Gerd
...
KB
Slide 7
7
Objektorientierte Repräsentation
... = Lisa
Knoten
Listen
... = Roland
... = Anna
... = Bernd
... = Gerd
...
KB
Slide 8
8
Objektorientierte Repräsentation
Listen
Spezielle Liste: String-Liste
KB
Verallgemeinerte Liste: Objekt-Liste
Slide 9
Klassendiagramm
9
Listen
Spezielle Liste:
Liste
anfang: Knoten
Knoten
kennt
next: Knoten
inhalt: string
...
...
KB
kennt
Slide 10
Klassendiagramm
10
Listen
Verallgemeinerte Liste:
Liste
anfang: Knoten
Knoten
kennt
next: Knoten
inhalt:
...
...
KB
kennt
hat
Object
Slide 11
Implementierung
Listen
11
type
TKnoten = class
private
next
: TKnoten;
inhalt : TObject;
public
...
Liste
end;
anfang: Knoten
Knoten
next: Knoten
inhalt:
...
...
KB
type
TListe = class
private
anfang : TKnoten;
public
...
end;
Object
Slide 12
Listenoperationen
12
Liste
{ liste: [ ] }
- anfang: Knoten
- count: integer
Listen
liste.create
+ create
+ getCount: integer
- knotenItems(pos: integer) : Knoten
+ items(pos: integer): Object
+ delete(pos: integer)
+ insert(pos: integer; obj: Object)
liste.insert(0, Lisa)
{ liste: [Lisa] }
liste.insert(1, Anna)
{ liste: [Lisa; Anna] }
Hilfsoperation
liste.insert(1, Roland)
{ liste: [Lisa; Roland; Anna] }
liste.delete(1)
{ liste: [Lisa; Anna] }
liste.items(1) Anna
KB
liste.getCount 2
Slide 13
13
knotenItems – Spezifikation
function TListe.knotenItems
(pos: integer): TKnoten;
Listen
Die Funktion „knotenItems“ bestimmt den i-ten Knoten
der Liste, wobei i = pos+1.
KB
liste.knotenItems(2)
Slide 14
Listen
14
KB
liste.knotenItems(2) – Trace
z := 0; k := anfang;
Slide 15
Listen
15
KB
liste.knotenItems(2) – Trace
inc(z); k := k.getNext;
Slide 16
Listen
16
KB
liste.knotenItems(2) – Trace
inc(z); k := k.getNext;
Slide 17
Listen
17
KB
liste.knotenItems(2) – Trace
result := k;
Slide 18
knotenItems – Algorithmus
18
begin
z := 0;
k := anfang;
Listen
while ((z < pos) and (z < count)) do
begin
inc(z);
k := k.getNext;
end;
result := k;
end;
KB
Slide 19
19
items – Spezifikation
function TListe.items
(pos: integer): TObject;
Listen
Die Funktion „items“ bestimmt den Inhalt des i-ten
Knotens der Liste, wobei i = pos+1.
KB
liste.items(2)
Slide 20
items – Algorithmus
20
function TListe.items (pos: integer): TObject;
begin
if ((pos >= 0) and (pos < count)) then
Listen
result := knotenItems(pos).getInhalt
else
result := nil;
end;
KB
Slide 21
21
delete – Spezifikation
Listen
procedure TListe.delete(pos: integer);
KB
liste.delete(2)
Slide 22
Listen
22
KB
liste.delete(2) – Trace
hilf := knotenItems(pos);
Slide 23
Listen
23
KB
liste.delete(2) – Trace
knotenItems(pos-1).
setNext(knotenItems(pos).getNext);
Slide 24
Listen
24
KB
liste.delete(2) – Trace
hilf.getInhalt.free; hilf.free;
dec(count)
Slide 25
Listen
25
KB
Achtung: liste.delete(0)
knotenItems(pos-1).
setNext(knotenItems(pos).getNext);
Slide 26
Listen
26
KB
Achtung: liste.delete(0)
anfang := knotenItems(pos).getNext
Slide 27
Listen
27
KB
delete – Algorithmus
Slide 28
28
insert – Spezifikation
Listen
procedure TListe.insert
(pos: integer; obj: TObject);
KB
liste.insert(2,o)
Slide 29
Listen
29
KB
liste.insert(2,o) – Trace
danach := knotenItems(pos);
Slide 30
Listen
30
KB
liste.insert(2,o) – Trace
neu := TKnoten.create(danach,obj);
Slide 31
Listen
31
KB
liste.insert(2,o) – Trace
knotenItems(pos-1).setNext(neu);
inc(count);
Slide 32
Listen
32
KB
Vorsicht: liste.insert(0,o)
knotenItems(pos-1).setNext(neu);
Slide 33
Listen
33
KB
insert – Algorithmus
Slide 34
34
Aufgabe
Entwickeln Sie mit Hilfe der Trace-Beispiele die Algorithmen zu
den beiden Operationen delete und insert.
Listen
Erstellen Sie ein neues Delphi-Projekt (in einem neuen Ordner)
und implementieren Sie die Klasse TListe.
KB
Slide 35
Listen
35
KB
Lösung: delete – Algorithmus
procedure TListe.delete(pos: integer);
var hilf: TKnoten;
begin
if pos <= count-1 then
begin
hilf := knotenItems(pos);
if pos = 0 then
anfang := knotenItems(pos).getNext
else
knotenItems(pos-1).setNext(knotenItems(pos).getNext);
hilf.getInhalt.free;
hilf.free;
dec(count);
end;
end;
Slide 36
Listen
36
KB
Lösung: insert – Algorithmus
procedure TListe.insert (pos: integer; obj: TObject);
var neu, danach: TKnoten;
begin
if pos <= count then begin
if pos = 0 then
begin
danach := anfang;
neu := TKnoten.create(danach, obj);
anfang := neu; inc(count);
end
else
begin
danach := knotenItems(pos);
neu := TKnoten.create(danach, obj);
knotenItems(pos-1).setNext(neu); inc(count);
end;
end;
end;
Slide 37
37
Listentest
Ziel ist es, ein Programm zu erstellen, mit dessen Hilfe die
Implementierung der Klasse „TListe“ gestestet werden
kann.
Listen
Z. B.: Es soll eine Namensliste [Lisa; Anna; ...] erstellt und
angezeigt werden.
KB
Slide 38
Spezialisierung
38
Listen
Allgemeine Liste:
KB
Spezialisierte Liste:
Slide 39
Spezialisierung
39
Liste
anfang: Knoten
Knoten
kennt
kennt
next: Knoten
inhalt:
...
...
hat
Object
ist
Element
Listen
wert: String
KB
create(w: String)
setWert(w: String)
getWert: String
Slide 40
Erzeugung einer Liste
40
liste := TListe.create;
e := TElement.create('Lisa');
liste.insert(0,e);
Listen
e := TElement.create('Anna');
KB
liste.insert(1,e);
...
Slide 41
Anzeige einer Liste
41
Hilfsvariable
h := '';
Listen
for i := 0 to liste.getCount-1 do
begin
w := TElement(liste.items(i)).getWert;
h := h + ' ' + w;
end;
PListe.Caption := h;
Anzeige-Panel
KB
Typumwandlung: TObject TElement
Slide 42
Aufgabe
42
Die Klasse „TElement“ ist noch nicht implementiert. Ergänzen
Sie die fehlenden Teile.
Erstellen Sie eine einfache Testoberfläche und ergänzen Sie die
Methodenaufrufe zur Erzeugung und zur Anzeige einer Testliste
Listen
Zur Kontrolle: Listen2
KB
Slide 43
Listen
43
KB
Teil 2
Anwendung: Lexikon
Slide 44
Auftrag
Listen
44
Ziel ist es, ein Programm
zur Erstellung und
Benutzung eines Glossars
(Lexikons) zu entwickeln.
KB
Aus:
H. Balzert: Lehrbuch Grundlagen
der Informatik, S. 137.
Slide 45
45
Pflichtenheft
/0/ Das Lexikon ist eine endliche Folge von Einträgen. Jeder
Eintrag liefert eine Erläuterung zu einem Stichwort.
Listen
/1/ Im Lexikon kann der Benutzer eine Erklärung zu einem
Stichwort nachschlagen. Der Benutzer muss hierzu das ihn
interessierende Stichwort eingeben.
/2/ Das Lexikon kann vom Benutzer ergänzt und verändert
werden: Es können jederzeit neue Einträge eingefügt und
bereits bestehende Einträge gelöscht werden.
/3/ Das Lexikon kann extern gespeichert und wieder geladen
werden.
KB
Slide 46
Listen
46
KB
Prototyp
Slide 47
Listen
47
OOA
Ein Lexikon ist eine endliche Folge von Einträgen. Jeder Eintrag
liefert eine Erläuterung zu einem Stichwort.
Im Lexikon kann man eine Erklärung zu einem Stichwort
nachschlagen.
Das Lexikon kann ergänzt und verändert werden: Es können
neue Einträge eingefügt und bereits bestehende Einträge
gelöscht werden.
Das Lexikon kann extern gespeichert und wieder geladen
werden.
KB
Slide 48
Listen
48
OOD
„create“ erstellt ein neues Listenobjekt „liste“.
„addEintrag“ erstellt zunächst ein „Eintrag“-Objekt und fügt es
dann in „liste“ ein.
„delEintrag“ durchsucht zunächst die Liste „liste“ nach dem
„stichwort“ und bestimmt gegebenenfalls die Position.
Anschließend wird der zugehörige Eintrag in der Liste gelöscht.
„getErlaeuterung“ liefert zu dem „stichwort“ die zugehörige
Erläuterung im Lexikon.
KB
Slide 49
Listen
49
KB
Algorithmen
constructor TLexikon.create;
begin
liste := TListe.create(nil);
end;
procedure TLexikon.addEintrag(stichwort, erlaeuterung: string);
var eintrag: TEintrag;
begin
eintrag := TEintrag.create(stichwort,erlaeuterung);
liste.insert(0,eintrag);
end;
Slide 50
Listen
50
KB
Algorithmen
procedure TLexikon.delEintrag(stichwort: string);
var i, position: integer;
begin
position := -1;
for i := 0 to liste.getCount-1 do
if TEintrag(liste.items(i)).getStichwort = stichwort then
position := i;
if position >= 0 then liste.delete(position);
end;
Slide 51
Listen
51
KB
Algorithmen
function TLexikon.getErlaeuterung(stichwort: string): string;
var position: integer;
erlaeuterung: string;
begin
erlaeuterung := 'kein Eintrag gefunden!';
for position := 0 to liste.getCount-1 do
if TEintrag(liste.items(position)).getStichwort = stichwort then
erlaeuterung := TEintrag(liste.items(position)).getErlaeuterung;
result := erlaeuterung;
end;
Slide 52
52
Aufgabe
Delphi verfügt über eine vordefinierte Klasse „TList“.
Informieren Sie sich über diese Klasse mit der Delphi-Hilfe.
Implementieren Sie dann das Lexikon mit dieser vordefinierten
Klasse „TList“ an Stelle der selbst entwickelten Klasse „TListe“.
Listen
Zur Kontrolle: siehe Lexikon2
KB
Slide 53
53
Zum Vergleich
Listen
Selbstdefinierte Liste
KB
unit uLexikon;
interface
uses uEintrag, uListe {TListe};
type
TLexikon = class
private
liste: TListe;
public
constructor create;
...
end;
Vordefinierte Liste
unit uLexikon;
interface
uses uEintrag, classes {TList};
type
TLexikon = class
private
liste: TList;
public
constructor create;
...
end;
Slide 54
54
Zum Vergleich
Listen
Selbstdefinierte Liste
KB
constructor TLexikon.create;
begin
liste := TListe.create;
end;
Vordefinierte Liste
// liste := TList.create;
Slide 55
55
Zum Vergleich
Listen
Selbstdefinierte Liste
KB
Vordefinierte Liste
procedure TLexikon.addEintrag(stichwort, erlaeuterung: string);
var eintrag: TEintrag;
begin
eintrag := TEintrag.create(stichwort,erlaeuterung);
liste.insert(0,eintrag);
// liste.Insert(0, eintrag);
end;
Slide 56
56
Zum Vergleich
Listen
Selbstdefinierte Liste
KB
Vordefinierte Liste
procedure TLexikon.delEintrag(stichwort: string);
var i, position: integer;
begin
position := -1;
for i := 0 to liste.getCount-1 do
// liste.Count-1
if TEintrag(liste.items(i)).getStichwort = stichwort then
position := i;
// liste.Items[i]
if position >= 0 then liste.delete(position); // liste.Delete(position)
end;
Slide 57
57
Zum Vergleich
Listen
Selbstdefinierte Liste
KB
Vordefinierte Liste
function TLexikon.getErlaeuterung(stichwort: string): string;
var position: integer;
erlaeuterung: string;
begin
erlaeuterung := 'kein Eintrag gefunden!';
for position := 0 to liste.getCount-1 do // liste.Count-1
if TEintrag(liste.items(position)).getStichwort = stichwort then
erlaeuterung := TEintrag(liste.items(position)).getErlaeuterung;
result := erlaeuterung;
end;
// liste.Items[position]
Slide 58
Zum Vergleich
58
Properties
Listen
TListe
KB
TList
- anfang: Knoten
- count: integer
+ Count: integer
+ Items[pos: integer]: Pointer
+ create(k: Knoten)
+ getCount: integer
- knotenItems(pos: integer) : Knoten
+ items(pos: integer): TObject
+ delete(pos: integer)
+ insert(pos: integer; obj: TObject)
+ create
+ Delete(pos: integer)
+ Insert(pos: integer; obj: Pointer)
...
Slide 59
Listen
59
KB
Teil 3
Stapel und Schlangen
Slide 60
Auswertung von Termen
60
Term: ( 7 - 2 ) * 3 =
7
-
Listen
(
7
*
2
(
7
3
)
-
2
-
(
7
(
*
15
=
3
5
KB
5
Operatorenstapel
*
5
Operandenstapel
Slide 61
Stapel
61
erstes
ohneErstes
Listen
mitErstem
LIFO-Prinzip: last in, first out
KB
Slide 62
Modellierung
62
erstes
Listen
mitErstem
Stapel
+ create
+ istLeer: boolean
+ mitErstem(obj: Object)
+ erstes: Object
+ ohneErstes
KB
ohneErstes
Slide 63
Listen
63
KB
Druckerwarteschlange
Druckauftragswarteschlange
Slide 64
Schlange
64
erstes
ohneErstes
Listen
mitLetztem
FIFO-Prinzip: first in, first out
KB
Slide 65
Modellierung
65
erstes
Listen
mitLetztem
Schlange
+ create
+ istLeer: boolean
+ mitLetztem(obj: Object)
+ erstes: Object
+ ohneErstes
KB
ohneErstes
Slide 66
Vereinfachung
66
Im folgenden sollen nur Stapel und Schlangen betrachtet
werden, deren Elemente Zeichenketten sind.
Listen
Stapel
KB
+ create
+ istLeer: boolean
+ mitErstem(s: String)
+ erstes: String
+ ohneErstes
Schlange
+ create
+ istLeer: boolean
+ mitLetztem (s: String)
+ erstes: String
+ ohneErstes
Slide 67
Implementierung
67
unit uStapel;
TStringList
+ Count: integer
+ Strings: array[0..] of string
Listen
+ create
+ delete(p: integer)
+ insert(p: integer; s: String)
...
Stapel
+ create
+ istLeer: boolean
+ mitErstem(s: String)
+ erstes: String
+ ohneErstes
interface
uses classes {TStringList};
type
TStapel = class(TStringList)
private
public
constructor create;
function istLeer: boolean;
procedure mitErstem(s: string);
procedure ohneErstes;
function erstes: string;
end;
implementation
...
KB
Slide 68
Implementierung
68
TStringList
+ Count: integer
+ Strings: array[0..] of string
Listen
+ create
+ delete(p: integer)
+ insert(p: integer; s: String)
...
Stapel
+ create
+ istLeer: boolean
+ mitErstem(s: String)
+ erstes: String
+ ohneErstes
KB
constructor TStapel.create;
begin inherited create; end;
function TStapel.istLeer: boolean;
begin
result := (Count = 0);
end;
function TStapel.erstes: string;
begin
result := Strings[0];
end;
procedure TStapel.ohneErstes;
begin
delete(0);
end;
procedure TStapel.mitErstem(s: string);
begin
insert(0,s);
end;
Slide 69
Listen
69
Aufgabe
Implementieren Sie analog die
Klasse Schlange. Benutzen Sie
hierzu die vordefinierte DelphiKlasse TStringList. Die benötigten
Attribute (Properties) und
Operationen sind im
nebenstehenden
Klassendiagramm aufgeführt. Die
Bedeutung der Bestandteile kann
mit der Delphi-Hilfe ermittelt
werden.
Erstellen Sie auch (einfache)
Testprogramme, um die
Korrektheit der Operationen zu
überprüfen.
KB
TStringList
+ Count: integer
+ Strings: array[0..] of string
+ create
+ delete(p: integer)
+ insert(p: integer; s: String)
...
Schlange
+ create
+ istLeer: boolean
+ mitLetztem (s: String)
+ erstes: String
+ ohneErstes
Slide 70
Listen
70
KB
Slide 71
Listen
71
KB
Teil 4
Anwendung: Taschenrechner
Slide 72
Auftrag
72
Es soll ein Demo-Taschenrechner erstellt werden, der die
Bearbeitung von Klammertermen veranschaulicht.
Eingabe: ( 7 - 2 ) * 3 =
Listen
Verarbeitung:
7
-
(
7
Ergebnis: (7 - 2) * 3 = 15
KB
2
(
7
)
-
2
-
(
7
(
Slide 73
Pflichtenheft
73
Listen
/0/ Der Benutzer gibt die Bestandteile des Terms – auch Token
genannt – Schritt für Schritt ein: Klammern, Zahlen,
Rechenzeichen (+, -, *, :), Gleicheitszeichen.
Z.B.: ( 7 - 2 ) * 3 =
/1/ Die Bearbeitung
des Terms wird
Schritt für Schritt
mit Hilfe eines
Buttons ausgelöst.
Die benutzten Stapel
werden dabei
jeweils auf dem
Bildschirm
angezeigt.
/2/ Der gesamte Term und das berechnete Ergebnis wird
abschließend angezeigt.
KB
Slide 74
Auswertung von Termen
74
Term: ( 7 - 2 ) * 3 =
7
-
Listen
(
7
*
2
(
7
3
)
-
2
-
(
7
(
*
15
=
3
5
KB
5
*
5
Slide 75
Interpreter
75
) * 3 =
termSchlange
operandenStapel
Listen
operatorenStapel
2
-
7
(
'(7-2'
''
Interpreter
KB
Slide 76
OOM
76
) * 3 =
termSchlange
operandenStapel
Listen
operatorenStapel
2
+
7
(
'(7-2)'
''
Interpreter
KB
Slide 77
Aufgabe
77
Ergänzen Sie den Interpretieralgorithmus.
Fall 1:
Das erste Element der TermSchlange ist ein
Gleichheitszeichen und der OperatorenStapel ist
nicht leer:
Listen
=
2
7
'7-2'
''
KB
-
Slide 78
Aufgabe
78
Ergänzen Sie den Interpretieralgorithmus.
Fall 2:
Das erste Element der TermSchlange ist ein
Gleichheitszeichen und der OperatorenStapel ist
leer:
Listen
=
5
'(7-2)'
''
KB
Slide 79
Aufgabe
79
Ergänzen Sie den Interpretieralgorithmus.
Listen
( 7 - 2 ) =
''
''
KB
Fall 3:
Das erste Element der TermSchlange ist
„Klammerauf“:
Slide 80
Aufgabe
80
Ergänzen Sie den Interpretieralgorithmus.
Fall 4:
Das erste Element der TermSchlange ist
„Klammerzu“:
Listen
) =
2
-
7
(
'(7-2'
''
KB
Slide 81
Aufgabe
81
Ergänzen Sie den Interpretieralgorithmus.
Fall 5:
Das erste Element der TermSchlange ist ein
Rechenzeichen:
Listen
- 2 ) =
7
'(7'
''
KB
(
Slide 82
Aufgabe
82
Ergänzen Sie den Interpretieralgorithmus.
Fall 6:
Das erste Element der TermSchlange ist eine
Zahl:
Listen
2) =
7
'(7-'
''
KB
(
Slide 83
83
Aufgabe
Implementieren Sie den Interpreter und testen Sie das
Taschenrechner-Programm.
Listen
Welche Erweiterungen wären wünschenswert?
KB
Slide 84
Lösung
84
Fall 1:
Das erste Element der TermSchlange ist ein Gleichheitszeichen und der
OperatorenStapel ist nicht leer:
Listen
=
2
7
'7-2'
''
KB
-
hilf := termSchlange.erstes;
termSchlange.ohneErstes;
term := term + hilf;
z1 := StrToInt(operandenStapel.erstes);
operandenStapel.ohneErstes;
z2 := StrToInt(operandenStapel.erstes);
operandenStapel.ohneErstes;
op := operatorenStapel.erstes;
operatorenStapel.ohneErstes;
if (op = '+') then erg := z2 + z1;
if (op = '-') then erg := z2 - z1;
if (op = '*') then erg := z2 * z1;
if (op = ':') then erg := z2 div z1;
ergebnis := IntToStr(erg);
operandenStapel.mitErstem(ergebnis);
Slide 85
Lösung
85
Fall 2:
Das erste Element der TermSchlange ist ein Gleichheitszeichen und der
OperatorenStapel ist leer:
hilf := termSchlange.erstes;
termSchlange.ohneErstes;
term := term + hilf;
ergebnis := operandenStapel.erstes;
Listen
=
5
'(7-2)'
''
KB
Slide 86
Lösung
86
Fall 3:
Das erste Element der TermSchlange ist „Klammerauf“:
Listen
( 7 - 2 ) =
''
''
KB
hilf := termSchlange.erstes;
termSchlange.ohneErstes;
term := term + hilf;
token := hilf;
operatorenStapel.mitErstem(token);
Slide 87
Lösung
87
Fall 4:
Das erste Element der TermSchlange ist „Klammerzu“:
Listen
) =
2
-
7
(
'(7-2'
''
KB
hilf := termSchlange.erstes;
termSchlange.ohneErstes;
term := term + hilf;
z1 := StrToInt(operandenStapel.erstes);
operandenStapel.ohneErstes;
z2 := StrToInt(operandenStapel.erstes);
operandenStapel.ohneErstes;
op := operatorenStapel.erstes;
operatorenStapel.ohneErstes;
operatorenStapel.ohneErstes;
if (op = '+') then erg := z2 + z1;
if (op = '-') then erg := z2 - z1;
if (op = '*') then erg := z2 * z1;
if (op = ':') then erg := z2 div z1;
token := IntToStr(erg);
operandenStapel.mitErstem(token);
Slide 88
Lösung
88
Fall 5:
Das erste Element der TermSchlange ist ein Rechenzeichen:
hilf := termSchlange.erstes;
termSchlange.ohneErstes;
term := term + hilf;
token := hilf;
operatorenStapel.mitErstem(token);
Listen
- 2 ) =
7
'(7'
''
KB
(
Slide 89
Lösung
89
Fall 6:
Das erste Element der TermSchlange ist eine Zahl:
hilf := termSchlange.erstes;
termSchlange.ohneErstes;
term := term + hilf;
token := hilf;
operandenStapel.mitErstem(token);
Listen
2) =
-
7
'(7-'
''
KB
(
Slide 90
Literaturhinweise
90
Helmut Balzert: Lehrbuch Grundlagen der Informatik. Spektrum Ak.
Verlag 1999.
H.-P. Gumm u. M. Sommer: Einführung in die Informatik.
Oldenbourg Verlag 2002.
Listen
...
KB
Listen
Klaus Becker
2003
Slide 2
Listen
2
Ansgar A., Speyer
Claudia B., Koblenz
Knut B., Neustadt
Listen
Annett B., Wörrstadt
Stefani D., Bad Ems
Jochen F., Ludwigshafen
...
...
Wieland S., Trier
Harald T.-R., Biesdorf
KB
Slide 3
Listen
3
KB
Teil 1
Objektorientierte Modellierung und Implementierung
von Listen
Slide 4
Was ist eine Liste?
4
Lisa
Roland
Anna
Listen
Gerd
Bernd
Stefanie
Eine Liste ist eine endliche,
beliebig lange Folge von
Elementen, in der an jeder
Stelle neue Elemente eingefügt
oder vorhandene Elemente
entfernt werden können.
Susanne
Walter
Ulrike
Theo
...
KB
Ziel ist es zunächst, die
dynamische Datenstruktur „Liste“
mit Hilfe einer geeigneten Klasse
zu implementieren.
Slide 5
Objektorientierte Repräsentation
5
Lisa
... = Lisa
Roland
Anna
Listen
Gerd
Bernd
... = Roland
Stefanie
Susanne
... = Anna
... = Bernd
Walter
Ulrike
...
KB
... = Gerd
...
Slide 6
6
Objektorientierte Repräsentation
Listen
Die Listenelemente
werden mit Hilfe von
Objekten beschrieben.
Die Folgenstruktur der
Liste wird mit Hilfe von
Referenzen aufgebaut.
... = Lisa
... = Roland
... = Anna
... = Bernd
... = Gerd
...
KB
Slide 7
7
Objektorientierte Repräsentation
... = Lisa
Knoten
Listen
... = Roland
... = Anna
... = Bernd
... = Gerd
...
KB
Slide 8
8
Objektorientierte Repräsentation
Listen
Spezielle Liste: String-Liste
KB
Verallgemeinerte Liste: Objekt-Liste
Slide 9
Klassendiagramm
9
Listen
Spezielle Liste:
Liste
anfang: Knoten
Knoten
kennt
next: Knoten
inhalt: string
...
...
KB
kennt
Slide 10
Klassendiagramm
10
Listen
Verallgemeinerte Liste:
Liste
anfang: Knoten
Knoten
kennt
next: Knoten
inhalt:
...
...
KB
kennt
hat
Object
Slide 11
Implementierung
Listen
11
type
TKnoten = class
private
next
: TKnoten;
inhalt : TObject;
public
...
Liste
end;
anfang: Knoten
Knoten
next: Knoten
inhalt:
...
...
KB
type
TListe = class
private
anfang : TKnoten;
public
...
end;
Object
Slide 12
Listenoperationen
12
Liste
{ liste: [ ] }
- anfang: Knoten
- count: integer
Listen
liste.create
+ create
+ getCount: integer
- knotenItems(pos: integer) : Knoten
+ items(pos: integer): Object
+ delete(pos: integer)
+ insert(pos: integer; obj: Object)
liste.insert(0, Lisa)
{ liste: [Lisa] }
liste.insert(1, Anna)
{ liste: [Lisa; Anna] }
Hilfsoperation
liste.insert(1, Roland)
{ liste: [Lisa; Roland; Anna] }
liste.delete(1)
{ liste: [Lisa; Anna] }
liste.items(1) Anna
KB
liste.getCount 2
Slide 13
13
knotenItems – Spezifikation
function TListe.knotenItems
(pos: integer): TKnoten;
Listen
Die Funktion „knotenItems“ bestimmt den i-ten Knoten
der Liste, wobei i = pos+1.
KB
liste.knotenItems(2)
Slide 14
Listen
14
KB
liste.knotenItems(2) – Trace
z := 0; k := anfang;
Slide 15
Listen
15
KB
liste.knotenItems(2) – Trace
inc(z); k := k.getNext;
Slide 16
Listen
16
KB
liste.knotenItems(2) – Trace
inc(z); k := k.getNext;
Slide 17
Listen
17
KB
liste.knotenItems(2) – Trace
result := k;
Slide 18
knotenItems – Algorithmus
18
begin
z := 0;
k := anfang;
Listen
while ((z < pos) and (z < count)) do
begin
inc(z);
k := k.getNext;
end;
result := k;
end;
KB
Slide 19
19
items – Spezifikation
function TListe.items
(pos: integer): TObject;
Listen
Die Funktion „items“ bestimmt den Inhalt des i-ten
Knotens der Liste, wobei i = pos+1.
KB
liste.items(2)
Slide 20
items – Algorithmus
20
function TListe.items (pos: integer): TObject;
begin
if ((pos >= 0) and (pos < count)) then
Listen
result := knotenItems(pos).getInhalt
else
result := nil;
end;
KB
Slide 21
21
delete – Spezifikation
Listen
procedure TListe.delete(pos: integer);
KB
liste.delete(2)
Slide 22
Listen
22
KB
liste.delete(2) – Trace
hilf := knotenItems(pos);
Slide 23
Listen
23
KB
liste.delete(2) – Trace
knotenItems(pos-1).
setNext(knotenItems(pos).getNext);
Slide 24
Listen
24
KB
liste.delete(2) – Trace
hilf.getInhalt.free; hilf.free;
dec(count)
Slide 25
Listen
25
KB
Achtung: liste.delete(0)
knotenItems(pos-1).
setNext(knotenItems(pos).getNext);
Slide 26
Listen
26
KB
Achtung: liste.delete(0)
anfang := knotenItems(pos).getNext
Slide 27
Listen
27
KB
delete – Algorithmus
Slide 28
28
insert – Spezifikation
Listen
procedure TListe.insert
(pos: integer; obj: TObject);
KB
liste.insert(2,o)
Slide 29
Listen
29
KB
liste.insert(2,o) – Trace
danach := knotenItems(pos);
Slide 30
Listen
30
KB
liste.insert(2,o) – Trace
neu := TKnoten.create(danach,obj);
Slide 31
Listen
31
KB
liste.insert(2,o) – Trace
knotenItems(pos-1).setNext(neu);
inc(count);
Slide 32
Listen
32
KB
Vorsicht: liste.insert(0,o)
knotenItems(pos-1).setNext(neu);
Slide 33
Listen
33
KB
insert – Algorithmus
Slide 34
34
Aufgabe
Entwickeln Sie mit Hilfe der Trace-Beispiele die Algorithmen zu
den beiden Operationen delete und insert.
Listen
Erstellen Sie ein neues Delphi-Projekt (in einem neuen Ordner)
und implementieren Sie die Klasse TListe.
KB
Slide 35
Listen
35
KB
Lösung: delete – Algorithmus
procedure TListe.delete(pos: integer);
var hilf: TKnoten;
begin
if pos <= count-1 then
begin
hilf := knotenItems(pos);
if pos = 0 then
anfang := knotenItems(pos).getNext
else
knotenItems(pos-1).setNext(knotenItems(pos).getNext);
hilf.getInhalt.free;
hilf.free;
dec(count);
end;
end;
Slide 36
Listen
36
KB
Lösung: insert – Algorithmus
procedure TListe.insert (pos: integer; obj: TObject);
var neu, danach: TKnoten;
begin
if pos <= count then begin
if pos = 0 then
begin
danach := anfang;
neu := TKnoten.create(danach, obj);
anfang := neu; inc(count);
end
else
begin
danach := knotenItems(pos);
neu := TKnoten.create(danach, obj);
knotenItems(pos-1).setNext(neu); inc(count);
end;
end;
end;
Slide 37
37
Listentest
Ziel ist es, ein Programm zu erstellen, mit dessen Hilfe die
Implementierung der Klasse „TListe“ gestestet werden
kann.
Listen
Z. B.: Es soll eine Namensliste [Lisa; Anna; ...] erstellt und
angezeigt werden.
KB
Slide 38
Spezialisierung
38
Listen
Allgemeine Liste:
KB
Spezialisierte Liste:
Slide 39
Spezialisierung
39
Liste
anfang: Knoten
Knoten
kennt
kennt
next: Knoten
inhalt:
...
...
hat
Object
ist
Element
Listen
wert: String
KB
create(w: String)
setWert(w: String)
getWert: String
Slide 40
Erzeugung einer Liste
40
liste := TListe.create;
e := TElement.create('Lisa');
liste.insert(0,e);
Listen
e := TElement.create('Anna');
KB
liste.insert(1,e);
...
Slide 41
Anzeige einer Liste
41
Hilfsvariable
h := '';
Listen
for i := 0 to liste.getCount-1 do
begin
w := TElement(liste.items(i)).getWert;
h := h + ' ' + w;
end;
PListe.Caption := h;
Anzeige-Panel
KB
Typumwandlung: TObject TElement
Slide 42
Aufgabe
42
Die Klasse „TElement“ ist noch nicht implementiert. Ergänzen
Sie die fehlenden Teile.
Erstellen Sie eine einfache Testoberfläche und ergänzen Sie die
Methodenaufrufe zur Erzeugung und zur Anzeige einer Testliste
Listen
Zur Kontrolle: Listen2
KB
Slide 43
Listen
43
KB
Teil 2
Anwendung: Lexikon
Slide 44
Auftrag
Listen
44
Ziel ist es, ein Programm
zur Erstellung und
Benutzung eines Glossars
(Lexikons) zu entwickeln.
KB
Aus:
H. Balzert: Lehrbuch Grundlagen
der Informatik, S. 137.
Slide 45
45
Pflichtenheft
/0/ Das Lexikon ist eine endliche Folge von Einträgen. Jeder
Eintrag liefert eine Erläuterung zu einem Stichwort.
Listen
/1/ Im Lexikon kann der Benutzer eine Erklärung zu einem
Stichwort nachschlagen. Der Benutzer muss hierzu das ihn
interessierende Stichwort eingeben.
/2/ Das Lexikon kann vom Benutzer ergänzt und verändert
werden: Es können jederzeit neue Einträge eingefügt und
bereits bestehende Einträge gelöscht werden.
/3/ Das Lexikon kann extern gespeichert und wieder geladen
werden.
KB
Slide 46
Listen
46
KB
Prototyp
Slide 47
Listen
47
OOA
Ein Lexikon ist eine endliche Folge von Einträgen. Jeder Eintrag
liefert eine Erläuterung zu einem Stichwort.
Im Lexikon kann man eine Erklärung zu einem Stichwort
nachschlagen.
Das Lexikon kann ergänzt und verändert werden: Es können
neue Einträge eingefügt und bereits bestehende Einträge
gelöscht werden.
Das Lexikon kann extern gespeichert und wieder geladen
werden.
KB
Slide 48
Listen
48
OOD
„create“ erstellt ein neues Listenobjekt „liste“.
„addEintrag“ erstellt zunächst ein „Eintrag“-Objekt und fügt es
dann in „liste“ ein.
„delEintrag“ durchsucht zunächst die Liste „liste“ nach dem
„stichwort“ und bestimmt gegebenenfalls die Position.
Anschließend wird der zugehörige Eintrag in der Liste gelöscht.
„getErlaeuterung“ liefert zu dem „stichwort“ die zugehörige
Erläuterung im Lexikon.
KB
Slide 49
Listen
49
KB
Algorithmen
constructor TLexikon.create;
begin
liste := TListe.create(nil);
end;
procedure TLexikon.addEintrag(stichwort, erlaeuterung: string);
var eintrag: TEintrag;
begin
eintrag := TEintrag.create(stichwort,erlaeuterung);
liste.insert(0,eintrag);
end;
Slide 50
Listen
50
KB
Algorithmen
procedure TLexikon.delEintrag(stichwort: string);
var i, position: integer;
begin
position := -1;
for i := 0 to liste.getCount-1 do
if TEintrag(liste.items(i)).getStichwort = stichwort then
position := i;
if position >= 0 then liste.delete(position);
end;
Slide 51
Listen
51
KB
Algorithmen
function TLexikon.getErlaeuterung(stichwort: string): string;
var position: integer;
erlaeuterung: string;
begin
erlaeuterung := 'kein Eintrag gefunden!';
for position := 0 to liste.getCount-1 do
if TEintrag(liste.items(position)).getStichwort = stichwort then
erlaeuterung := TEintrag(liste.items(position)).getErlaeuterung;
result := erlaeuterung;
end;
Slide 52
52
Aufgabe
Delphi verfügt über eine vordefinierte Klasse „TList“.
Informieren Sie sich über diese Klasse mit der Delphi-Hilfe.
Implementieren Sie dann das Lexikon mit dieser vordefinierten
Klasse „TList“ an Stelle der selbst entwickelten Klasse „TListe“.
Listen
Zur Kontrolle: siehe Lexikon2
KB
Slide 53
53
Zum Vergleich
Listen
Selbstdefinierte Liste
KB
unit uLexikon;
interface
uses uEintrag, uListe {TListe};
type
TLexikon = class
private
liste: TListe;
public
constructor create;
...
end;
Vordefinierte Liste
unit uLexikon;
interface
uses uEintrag, classes {TList};
type
TLexikon = class
private
liste: TList;
public
constructor create;
...
end;
Slide 54
54
Zum Vergleich
Listen
Selbstdefinierte Liste
KB
constructor TLexikon.create;
begin
liste := TListe.create;
end;
Vordefinierte Liste
// liste := TList.create;
Slide 55
55
Zum Vergleich
Listen
Selbstdefinierte Liste
KB
Vordefinierte Liste
procedure TLexikon.addEintrag(stichwort, erlaeuterung: string);
var eintrag: TEintrag;
begin
eintrag := TEintrag.create(stichwort,erlaeuterung);
liste.insert(0,eintrag);
// liste.Insert(0, eintrag);
end;
Slide 56
56
Zum Vergleich
Listen
Selbstdefinierte Liste
KB
Vordefinierte Liste
procedure TLexikon.delEintrag(stichwort: string);
var i, position: integer;
begin
position := -1;
for i := 0 to liste.getCount-1 do
// liste.Count-1
if TEintrag(liste.items(i)).getStichwort = stichwort then
position := i;
// liste.Items[i]
if position >= 0 then liste.delete(position); // liste.Delete(position)
end;
Slide 57
57
Zum Vergleich
Listen
Selbstdefinierte Liste
KB
Vordefinierte Liste
function TLexikon.getErlaeuterung(stichwort: string): string;
var position: integer;
erlaeuterung: string;
begin
erlaeuterung := 'kein Eintrag gefunden!';
for position := 0 to liste.getCount-1 do // liste.Count-1
if TEintrag(liste.items(position)).getStichwort = stichwort then
erlaeuterung := TEintrag(liste.items(position)).getErlaeuterung;
result := erlaeuterung;
end;
// liste.Items[position]
Slide 58
Zum Vergleich
58
Properties
Listen
TListe
KB
TList
- anfang: Knoten
- count: integer
+ Count: integer
+ Items[pos: integer]: Pointer
+ create(k: Knoten)
+ getCount: integer
- knotenItems(pos: integer) : Knoten
+ items(pos: integer): TObject
+ delete(pos: integer)
+ insert(pos: integer; obj: TObject)
+ create
+ Delete(pos: integer)
+ Insert(pos: integer; obj: Pointer)
...
Slide 59
Listen
59
KB
Teil 3
Stapel und Schlangen
Slide 60
Auswertung von Termen
60
Term: ( 7 - 2 ) * 3 =
7
-
Listen
(
7
*
2
(
7
3
)
-
2
-
(
7
(
*
15
=
3
5
KB
5
Operatorenstapel
*
5
Operandenstapel
Slide 61
Stapel
61
erstes
ohneErstes
Listen
mitErstem
LIFO-Prinzip: last in, first out
KB
Slide 62
Modellierung
62
erstes
Listen
mitErstem
Stapel
+ create
+ istLeer: boolean
+ mitErstem(obj: Object)
+ erstes: Object
+ ohneErstes
KB
ohneErstes
Slide 63
Listen
63
KB
Druckerwarteschlange
Druckauftragswarteschlange
Slide 64
Schlange
64
erstes
ohneErstes
Listen
mitLetztem
FIFO-Prinzip: first in, first out
KB
Slide 65
Modellierung
65
erstes
Listen
mitLetztem
Schlange
+ create
+ istLeer: boolean
+ mitLetztem(obj: Object)
+ erstes: Object
+ ohneErstes
KB
ohneErstes
Slide 66
Vereinfachung
66
Im folgenden sollen nur Stapel und Schlangen betrachtet
werden, deren Elemente Zeichenketten sind.
Listen
Stapel
KB
+ create
+ istLeer: boolean
+ mitErstem(s: String)
+ erstes: String
+ ohneErstes
Schlange
+ create
+ istLeer: boolean
+ mitLetztem (s: String)
+ erstes: String
+ ohneErstes
Slide 67
Implementierung
67
unit uStapel;
TStringList
+ Count: integer
+ Strings: array[0..] of string
Listen
+ create
+ delete(p: integer)
+ insert(p: integer; s: String)
...
Stapel
+ create
+ istLeer: boolean
+ mitErstem(s: String)
+ erstes: String
+ ohneErstes
interface
uses classes {TStringList};
type
TStapel = class(TStringList)
private
public
constructor create;
function istLeer: boolean;
procedure mitErstem(s: string);
procedure ohneErstes;
function erstes: string;
end;
implementation
...
KB
Slide 68
Implementierung
68
TStringList
+ Count: integer
+ Strings: array[0..] of string
Listen
+ create
+ delete(p: integer)
+ insert(p: integer; s: String)
...
Stapel
+ create
+ istLeer: boolean
+ mitErstem(s: String)
+ erstes: String
+ ohneErstes
KB
constructor TStapel.create;
begin inherited create; end;
function TStapel.istLeer: boolean;
begin
result := (Count = 0);
end;
function TStapel.erstes: string;
begin
result := Strings[0];
end;
procedure TStapel.ohneErstes;
begin
delete(0);
end;
procedure TStapel.mitErstem(s: string);
begin
insert(0,s);
end;
Slide 69
Listen
69
Aufgabe
Implementieren Sie analog die
Klasse Schlange. Benutzen Sie
hierzu die vordefinierte DelphiKlasse TStringList. Die benötigten
Attribute (Properties) und
Operationen sind im
nebenstehenden
Klassendiagramm aufgeführt. Die
Bedeutung der Bestandteile kann
mit der Delphi-Hilfe ermittelt
werden.
Erstellen Sie auch (einfache)
Testprogramme, um die
Korrektheit der Operationen zu
überprüfen.
KB
TStringList
+ Count: integer
+ Strings: array[0..] of string
+ create
+ delete(p: integer)
+ insert(p: integer; s: String)
...
Schlange
+ create
+ istLeer: boolean
+ mitLetztem (s: String)
+ erstes: String
+ ohneErstes
Slide 70
Listen
70
KB
Slide 71
Listen
71
KB
Teil 4
Anwendung: Taschenrechner
Slide 72
Auftrag
72
Es soll ein Demo-Taschenrechner erstellt werden, der die
Bearbeitung von Klammertermen veranschaulicht.
Eingabe: ( 7 - 2 ) * 3 =
Listen
Verarbeitung:
7
-
(
7
Ergebnis: (7 - 2) * 3 = 15
KB
2
(
7
)
-
2
-
(
7
(
Slide 73
Pflichtenheft
73
Listen
/0/ Der Benutzer gibt die Bestandteile des Terms – auch Token
genannt – Schritt für Schritt ein: Klammern, Zahlen,
Rechenzeichen (+, -, *, :), Gleicheitszeichen.
Z.B.: ( 7 - 2 ) * 3 =
/1/ Die Bearbeitung
des Terms wird
Schritt für Schritt
mit Hilfe eines
Buttons ausgelöst.
Die benutzten Stapel
werden dabei
jeweils auf dem
Bildschirm
angezeigt.
/2/ Der gesamte Term und das berechnete Ergebnis wird
abschließend angezeigt.
KB
Slide 74
Auswertung von Termen
74
Term: ( 7 - 2 ) * 3 =
7
-
Listen
(
7
*
2
(
7
3
)
-
2
-
(
7
(
*
15
=
3
5
KB
5
*
5
Slide 75
Interpreter
75
) * 3 =
termSchlange
operandenStapel
Listen
operatorenStapel
2
-
7
(
'(7-2'
''
Interpreter
KB
Slide 76
OOM
76
) * 3 =
termSchlange
operandenStapel
Listen
operatorenStapel
2
+
7
(
'(7-2)'
''
Interpreter
KB
Slide 77
Aufgabe
77
Ergänzen Sie den Interpretieralgorithmus.
Fall 1:
Das erste Element der TermSchlange ist ein
Gleichheitszeichen und der OperatorenStapel ist
nicht leer:
Listen
=
2
7
'7-2'
''
KB
-
Slide 78
Aufgabe
78
Ergänzen Sie den Interpretieralgorithmus.
Fall 2:
Das erste Element der TermSchlange ist ein
Gleichheitszeichen und der OperatorenStapel ist
leer:
Listen
=
5
'(7-2)'
''
KB
Slide 79
Aufgabe
79
Ergänzen Sie den Interpretieralgorithmus.
Listen
( 7 - 2 ) =
''
''
KB
Fall 3:
Das erste Element der TermSchlange ist
„Klammerauf“:
Slide 80
Aufgabe
80
Ergänzen Sie den Interpretieralgorithmus.
Fall 4:
Das erste Element der TermSchlange ist
„Klammerzu“:
Listen
) =
2
-
7
(
'(7-2'
''
KB
Slide 81
Aufgabe
81
Ergänzen Sie den Interpretieralgorithmus.
Fall 5:
Das erste Element der TermSchlange ist ein
Rechenzeichen:
Listen
- 2 ) =
7
'(7'
''
KB
(
Slide 82
Aufgabe
82
Ergänzen Sie den Interpretieralgorithmus.
Fall 6:
Das erste Element der TermSchlange ist eine
Zahl:
Listen
2) =
7
'(7-'
''
KB
(
Slide 83
83
Aufgabe
Implementieren Sie den Interpreter und testen Sie das
Taschenrechner-Programm.
Listen
Welche Erweiterungen wären wünschenswert?
KB
Slide 84
Lösung
84
Fall 1:
Das erste Element der TermSchlange ist ein Gleichheitszeichen und der
OperatorenStapel ist nicht leer:
Listen
=
2
7
'7-2'
''
KB
-
hilf := termSchlange.erstes;
termSchlange.ohneErstes;
term := term + hilf;
z1 := StrToInt(operandenStapel.erstes);
operandenStapel.ohneErstes;
z2 := StrToInt(operandenStapel.erstes);
operandenStapel.ohneErstes;
op := operatorenStapel.erstes;
operatorenStapel.ohneErstes;
if (op = '+') then erg := z2 + z1;
if (op = '-') then erg := z2 - z1;
if (op = '*') then erg := z2 * z1;
if (op = ':') then erg := z2 div z1;
ergebnis := IntToStr(erg);
operandenStapel.mitErstem(ergebnis);
Slide 85
Lösung
85
Fall 2:
Das erste Element der TermSchlange ist ein Gleichheitszeichen und der
OperatorenStapel ist leer:
hilf := termSchlange.erstes;
termSchlange.ohneErstes;
term := term + hilf;
ergebnis := operandenStapel.erstes;
Listen
=
5
'(7-2)'
''
KB
Slide 86
Lösung
86
Fall 3:
Das erste Element der TermSchlange ist „Klammerauf“:
Listen
( 7 - 2 ) =
''
''
KB
hilf := termSchlange.erstes;
termSchlange.ohneErstes;
term := term + hilf;
token := hilf;
operatorenStapel.mitErstem(token);
Slide 87
Lösung
87
Fall 4:
Das erste Element der TermSchlange ist „Klammerzu“:
Listen
) =
2
-
7
(
'(7-2'
''
KB
hilf := termSchlange.erstes;
termSchlange.ohneErstes;
term := term + hilf;
z1 := StrToInt(operandenStapel.erstes);
operandenStapel.ohneErstes;
z2 := StrToInt(operandenStapel.erstes);
operandenStapel.ohneErstes;
op := operatorenStapel.erstes;
operatorenStapel.ohneErstes;
operatorenStapel.ohneErstes;
if (op = '+') then erg := z2 + z1;
if (op = '-') then erg := z2 - z1;
if (op = '*') then erg := z2 * z1;
if (op = ':') then erg := z2 div z1;
token := IntToStr(erg);
operandenStapel.mitErstem(token);
Slide 88
Lösung
88
Fall 5:
Das erste Element der TermSchlange ist ein Rechenzeichen:
hilf := termSchlange.erstes;
termSchlange.ohneErstes;
term := term + hilf;
token := hilf;
operatorenStapel.mitErstem(token);
Listen
- 2 ) =
7
'(7'
''
KB
(
Slide 89
Lösung
89
Fall 6:
Das erste Element der TermSchlange ist eine Zahl:
hilf := termSchlange.erstes;
termSchlange.ohneErstes;
term := term + hilf;
token := hilf;
operandenStapel.mitErstem(token);
Listen
2) =
-
7
'(7-'
''
KB
(
Slide 90
Literaturhinweise
90
Helmut Balzert: Lehrbuch Grundlagen der Informatik. Spektrum Ak.
Verlag 1999.
H.-P. Gumm u. M. Sommer: Einführung in die Informatik.
Oldenbourg Verlag 2002.
Listen
...
KB
