Listen

1. Listen Klaus Becker 2003

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

3. Teil 1 Objektorientierte Modellierung und Implementierung von Listen

4. Was ist eine Liste? Lisa Roland Anna Gerd Stefanie Susanne Walter Ulrike Theo ... Eine Liste ist eine endliche,beliebig langeFolge von Elementen, in der an jeder Stelle neue Elemente eingefügt oder vorhandene Elemente entfernt werden können. Bernd Ziel ist es zunächst, die dynamische Datenstruktur „Liste“ mit Hilfe einer geeigneten Klasse zu implementieren.

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

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

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

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

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

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

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

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

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

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

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

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

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

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;

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

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;

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

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

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

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

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

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

27. delete – Algorithmus

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

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

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

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

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

33. insert – Algorithmus

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.

35. Lösung: delete – Algorithmus procedure TListe.delete(pos: integer); var hilf: TKnoten;beginif 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;

36. Lösung: insert – Algorithmus procedure TListe.insert (pos: integer; obj: TObject); var neu, danach: TKnoten;beginif 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;

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.

38. Spezialisierung Allgemeine Liste: Spezialisierte Liste:

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

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

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

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

43. Teil 2 Anwendung: Lexikon

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

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.

46. Prototyp

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.

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.

49. Algorithmen constructor TLexikon.create;beginliste := TListe.create(nil); end; procedure TLexikon.addEintrag(stichwort, erlaeuterung: string); var eintrag: TEintrag;begineintrag := TEintrag.create(stichwort,erlaeuterung);liste.insert(0,eintrag); end;

50. Algorithmen procedure TLexikon.delEintrag(stichwort: string); var i, position: integer;beginposition := -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;