Listen Klaus Becker 2003

KB Listen 2 Listen Ansgar A., Speyer Claudia B., Koblenz Knut B., Neustadt Annett B., Wörrstadt Stefani D., Bad Ems Jochen F., Ludwigshafen... Wieland S., Trier Harald T.-R., Biesdorf

KB Listen 3 Teil 1 Objektorientierte Modellierung und Implementierung von Listen

KB Listen 4 Was ist eine Liste? Lisa Roland Anna Gerd Stefanie Susanne Walter Ulrike Theo... Bernd 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. Ziel ist es zunächst, die dynamische Datenstruktur Liste mit Hilfe einer geeigneten Klasse zu implementieren.

KB Listen 5 Objektorientierte Repräsentation... = Lisa... = Roland... = Anna... = Gerd... = Bernd... Lisa Roland Anna Gerd Stefanie Susanne Walter Ulrike... Bernd

KB Listen 6 Objektorientierte Repräsentation... = Lisa... = Roland... = Anna... = Gerd... = Bernd Die Listenelemente werden mit Hilfe von Objekten beschrieben. Die Folgenstruktur der Liste wird mit Hilfe von Referenzen aufgebaut....

KB Listen 7 Objektorientierte Repräsentation... = Lisa... = Roland... = Anna... = Gerd... = Bernd... Knoten

KB Listen 8 Objektorientierte Repräsentation Spezielle Liste: String-Liste Verallgemeinerte Liste: Objekt-Liste

KB Listen 9 Klassendiagramm Liste anfang: Knoten... Knoten next: Knoten inhalt: string... Spezielle Liste: kennt

KB Listen 10 Klassendiagramm Liste anfang: Knoten... Knoten next: Knoten inhalt:... Object Verallgemeinerte Liste: kennt hat

KB Listen 11 Implementierung type TKnoten = class private next : TKnoten; inhalt : TObject; public... end; type TListe = class private anfang : TKnoten; public... end; Liste anfang: Knoten... Knoten next: Knoten inhalt:... Object

KB Listen 12 Listenoperationen { liste: [ ] } liste.create { liste: [Lisa] } liste.insert(0, Lisa) { liste: [Lisa; Anna] } liste.insert(1, Anna) liste.insert(1, Roland) { liste: [Lisa; Roland; Anna] } { liste: [Lisa; Anna] } liste.delete(1) liste.items(1) Anna liste.getCount 2 Liste - anfang: Knoten - count: integer + create + getCount: integer - knotenItems(pos: integer) : Knoten + items(pos: integer): Object + delete(pos: integer) + insert(pos: integer; obj: Object) Hilfsoperation

KB Listen 13 knotenItems – Spezifikation liste.knotenItems(2) Die Funktion knotenItems bestimmt den i-ten Knoten der Liste, wobei i = pos+1. function TListe.knotenItems (pos: integer): TKnoten;

KB Listen 14 liste.knotenItems(2) – Trace z := 0; k := anfang;

KB Listen 15 liste.knotenItems(2) – Trace inc(z); k := k.getNext;

KB Listen 16 liste.knotenItems(2) – Trace inc(z); k := k.getNext;

KB Listen 17 liste.knotenItems(2) – Trace result := k;

KB Listen 18 knotenItems – Algorithmus begin z := 0; k := anfang; while ((z < pos) and (z < count)) do begin inc(z); k := k.getNext; end; result := k; end;

KB Listen 19 items – Spezifikation liste.items(2) Die Funktion items bestimmt den Inhalt des i-ten Knotens der Liste, wobei i = pos+1. function TListe.items (pos: integer): TObject;

KB Listen 20 items – Algorithmus function TListe.items (pos: integer): TObject; begin if ((pos >= 0) and (pos < count)) then result := knotenItems(pos).getInhalt else result := nil; end;

KB Listen 21 delete – Spezifikation liste.delete(2) procedure TListe.delete(pos: integer);

KB Listen 22 liste.delete(2) – Trace hilf := knotenItems(pos);

KB Listen 23 liste.delete(2) – Trace knotenItems(pos-1). setNext(knotenItems(pos).getNext);

KB Listen 24 liste.delete(2) – Trace hilf.getInhalt.free; hilf.free; dec(count)

KB Listen 25 Achtung: liste.delete(0) knotenItems(pos-1). setNext(knotenItems(pos).getNext);

KB Listen 26 Achtung: liste.delete(0) anfang := knotenItems(pos).getNext

KB Listen 27 delete – Algorithmus

KB Listen 28 insert – Spezifikation liste.insert(2,o) procedure TListe.insert (pos: integer; obj: TObject);

KB Listen 29 liste.insert(2,o) – Trace danach := knotenItems(pos);

KB Listen 30 liste.insert(2,o) – Trace neu := TKnoten.create(danach,obj);

KB Listen 31 liste.insert(2,o) – Trace knotenItems(pos-1).setNext(neu); inc(count);

KB Listen 32 Vorsicht: liste.insert(0,o) knotenItems(pos-1).setNext(neu);

KB Listen 33 insert – Algorithmus

KB Listen 34 Aufgabe Entwickeln Sie mit Hilfe der Trace-Beispiele die Algorithmen zu den beiden Operationen delete und insert. Erstellen Sie ein neues Delphi-Projekt (in einem neuen Ordner) und implementieren Sie die Klasse TListe.

KB Listen 35 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;

KB Listen 36 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;

KB Listen 37 Listentest Ziel ist es, ein Programm zu erstellen, mit dessen Hilfe die Implementierung der Klasse TListe gestestet werden kann. Z. B.: Es soll eine Namensliste [Lisa; Anna;...] erstellt und angezeigt werden.

KB Listen 38 Spezialisierung Spezialisierte Liste: Allgemeine Liste:

KB Listen 39 Spezialisierung Liste anfang: Knoten... Knoten next: Knoten inhalt:...Element Object wert: String create(w: String) setWert(w: String) getWert: String kennt hat ist

KB Listen 40 Erzeugung einer Liste liste := TListe.create; e := TElement.create('Lisa'); liste.insert(0,e); e := TElement.create('Anna'); liste.insert(1,e);...

KB Listen 41 Anzeige einer Liste h := ''; for i := 0 to liste.getCount-1 do begin w := TElement(liste.items(i)).getWert; h := h + ' ' + w; end; PListe.Caption := h; Hilfsvariable Anzeige-Panel Typumwandlung: TObject TElement

KB Listen 42 Aufgabe 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 Zur Kontrolle: Listen2

KB Listen 43 Teil 2 Anwendung: Lexikon

KB Listen 44 Auftrag Aus: H. Balzert: Lehrbuch Grundlagen der Informatik, S Ziel ist es, ein Programm zur Erstellung und Benutzung eines Glossars (Lexikons) zu entwickeln.

KB Listen 45 Pflichtenheft /0/ Das Lexikon ist eine endliche Folge von Einträgen. Jeder Eintrag liefert eine Erläuterung zu einem Stichwort. /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 Listen 46 Prototyp

KB 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 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 Listen 49 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;

KB Listen 50 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;

KB Listen 51 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;

KB Listen 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. Zur Kontrolle: siehe Lexikon2

KB Listen 53 Zum Vergleich unit uLexikon; interface uses uEintrag, classes {TList}; type TLexikon = class private liste: TList; public constructor create;... end; unit uLexikon; interface uses uEintrag, uListe {TListe}; type TLexikon = class private liste: TListe; public constructor create;... end; Vordefinierte Liste Selbstdefinierte Liste

KB Listen 54 Zum Vergleich constructor TLexikon.create; begin liste := TListe.create; // liste := TList.create; end; Vordefinierte Liste Selbstdefinierte Liste

KB Listen 55 Zum Vergleich procedure TLexikon.addEintrag(stichwort, erlaeuterung: string); var eintrag: TEintrag; begin eintrag := TEintrag.create(stichwort,erlaeuterung); liste.insert(0,eintrag); // liste.Insert(0, eintrag); end; Vordefinierte Liste Selbstdefinierte Liste

KB Listen 56 Zum Vergleich 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; Vordefinierte Liste Selbstdefinierte Liste

KB Listen 57 Zum Vergleich 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] Vordefinierte Liste Selbstdefinierte Liste

KB Listen 58 Zum Vergleich TListe - anfang: Knoten - count: integer + create(k: Knoten) + getCount: integer - knotenItems(pos: integer) : Knoten + items(pos: integer): TObject + delete(pos: integer) + insert(pos: integer; obj: TObject) TList + Count: integer + Items[pos: integer]: Pointer + create + Delete(pos: integer) + Insert(pos: integer; obj: Pointer)... Properties

KB Listen 59 Teil 3 Stapel und Schlangen

KB Listen 60 Auswertung von Termen Term:( ) * 3 = 7 ( - (7 2 (7 - ) * 5 3 *5 (7 - 2 = * Operandenstapel Operatorenstapel

KB Listen 61 Stapel LIFO-Prinzip: last in, first out mitErstemerstesohneErstes

KB Listen 62 Modellierung mitErstemerstesohneErstes Stapel + create + istLeer: boolean + mitErstem(obj: Object) + erstes: Object + ohneErstes

KB Listen 63 Druckerwarteschlange Druckauftragswarteschlange

KB Listen 64 Schlange FIFO-Prinzip: first in, first out mitLetztem erstesohneErstes

KB Listen 65 Modellierung mitLetztemerstes ohneErstes Schlange + create + istLeer: boolean + mitLetztem(obj: Object) + erstes: Object + ohneErstes

KB Listen 66 Vereinfachung Im folgenden sollen nur Stapel und Schlangen betrachtet werden, deren Elemente Zeichenketten sind. Stapel + create + istLeer: boolean + mitErstem(s: String) + erstes: String + ohneErstes Schlange + create + istLeer: boolean + mitLetztem (s: String) + erstes: String + ohneErstes

KB Listen 67 Implementierung unit uStapel; 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... Stapel + create + istLeer: boolean + mitErstem(s: String) + erstes: String + ohneErstes TStringList + Count: integer + Strings: array[0..] of string + create + delete(p: integer) + insert(p: integer; s: String)...

KB Listen 68 Implementierung 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; Stapel + create + istLeer: boolean + mitErstem(s: String) + erstes: String + ohneErstes TStringList + Count: integer + Strings: array[0..] of string + create + delete(p: integer) + insert(p: integer; s: String)...

KB Listen 69 Aufgabe Implementieren Sie analog die Klasse Schlange. Benutzen Sie hierzu die vordefinierte Delphi- Klasse 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. 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

KB Listen 70

KB Listen 71 Teil 4 Anwendung: Taschenrechner

KB Listen 72 Auftrag Es soll ein Demo-Taschenrechner erstellt werden, der die Bearbeitung von Klammertermen veranschaulicht. Eingabe:( ) * 3 = 7 ( - (7 2 (7 - ) (7 - 2 Verarbeitung: Ergebnis: (7 - 2) * 3 = 15

KB Listen 73 Pflichtenheft /0/ Der Benutzer gibt die Bestandteile des Terms – auch Token genannt – Schritt für Schritt ein: Klammern, Zahlen, Rechenzeichen (+, -, *, :), Gleicheitszeichen. Z.B.: ( ) * 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 Listen 74 Auswertung von Termen Term:( ) * 3 = 7 ( - (7 2 (7 - ) * 5 3 *5 (7 - 2 = *5 3 15

KB Listen 75 Interpreter ) * 3 = ( termSchlange operandenStapel operatorenStapel Interpreter '(7-2' ''

KB Listen 76 OOM ) * 3 = ( Interpreter '(7-2)' '' termSchlange operandenStapel operatorenStapel

KB Listen 77 Aufgabe Fall 1: Das erste Element der TermSchlange ist ein Gleichheitszeichen und der OperatorenStapel ist nicht leer: = - 7 '7-2' '' Ergänzen Sie den Interpretieralgorithmus. 2

KB Listen 78 Aufgabe Fall 2: Das erste Element der TermSchlange ist ein Gleichheitszeichen und der OperatorenStapel ist leer: Ergänzen Sie den Interpretieralgorithmus. = 5 '(7-2)' ''

KB Listen 79 Aufgabe Fall 3: Das erste Element der TermSchlange ist Klammerauf: Ergänzen Sie den Interpretieralgorithmus. ( ) = ''

KB Listen 80 Aufgabe Fall 4: Das erste Element der TermSchlange ist Klammerzu: Ergänzen Sie den Interpretieralgorithmus. ) = ( - 7 '(7-2' '' 2

KB Listen 81 Aufgabe Fall 5: Das erste Element der TermSchlange ist ein Rechenzeichen: Ergänzen Sie den Interpretieralgorithmus. - 2 ) = ( 7 '(7' ''

KB Listen 82 Aufgabe Fall 6: Das erste Element der TermSchlange ist eine Zahl: Ergänzen Sie den Interpretieralgorithmus. 2 ) = ( - 7 '(7-' ''

KB Listen 83 Aufgabe Implementieren Sie den Interpreter und testen Sie das Taschenrechner-Programm. Welche Erweiterungen wären wünschenswert?

KB Listen 84 Lösung Fall 1: Das erste Element der TermSchlange ist ein Gleichheitszeichen und der OperatorenStapel ist nicht leer: = - 7 '7-2' '' 2 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);

KB Listen 85 Lösung Fall 2: Das erste Element der TermSchlange ist ein Gleichheitszeichen und der OperatorenStapel ist leer: = 5 '(7-2)' '' hilf := termSchlange.erstes; termSchlange.ohneErstes; term := term + hilf; ergebnis := operandenStapel.erstes;

KB Listen 86 Lösung Fall 3: Das erste Element der TermSchlange ist Klammerauf: ( ) = '' hilf := termSchlange.erstes; termSchlange.ohneErstes; term := term + hilf; token := hilf; operatorenStapel.mitErstem(token);

KB Listen 87 Lösung Fall 4: Das erste Element der TermSchlange ist Klammerzu: ) = ( - 7 '(7-2' '' 2 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);

KB Listen 88 Lösung Fall 5: Das erste Element der TermSchlange ist ein Rechenzeichen: - 2 ) = ( 7 '(7' '' hilf := termSchlange.erstes; termSchlange.ohneErstes; term := term + hilf; token := hilf; operatorenStapel.mitErstem(token);

KB Listen 89 Lösung Fall 6: Das erste Element der TermSchlange ist eine Zahl: 2 ) = ( - 7 '(7-' '' hilf := termSchlange.erstes; termSchlange.ohneErstes; term := term + hilf; token := hilf; operandenStapel.mitErstem(token);

KB Listen 90 Literaturhinweise Helmut Balzert: Lehrbuch Grundlagen der Informatik. Spektrum Ak. Verlag H.-P. Gumm u. M. Sommer: Einführung in die Informatik. Oldenbourg Verlag