3.3 Verkettete Listen

1. tmp tmp tmp tmp head null null 0 null null 1 2 4 3 null 3.3 Verkettete Listen • Erweiterung der (nicht-leeren!) Liste: tmp = head;while (tmp.next != null) tmp = tmp.next;tmp.next = new ListNode(4);

2. head 0 null null 1 2 4 null tmp tmp tmp tmp tmp null null null null 3 pred pred pred pred pred 3.3 Verkettete Listen • Entfernen des letzten Elementesaus der (aus mehr als 1 Element bestehenden!) Liste: ListNode<Integer> pred = null;tmp = head;while (tmp.next != null) { pred = tmp; tmp = tmp.next;}pred.next = null;

3. 3.3 Verkettete Listen • RekursiveTraversierung einer Liste vom Anfang zum Endeund wieder zurück: void traverse(ListNode<E> p) { ListNode<Integer> Node; if (Node = p; p != null; Node = Node.next) { process(Node.data); }} initialer Aufruf: traverse(head);

4. null head present old present old present old present present present present old old old null present present present old old old old old old present present null 3.3 Verkettete Listen • Iterative Traversierung der Liste vom Anfang zum Ende und wieder zurück: ListNode<E> head, tmp;…ListNode<E> old, present;present = head;for (int i = 1; i <= 2; i++) { old = null;while (present != null) { process(present.data); tmp = present.next; present.next = old; old = present; present = tmp; } present = old;} Bewirkt eine Listenumkehr

5. head 3.3 Verkettete Listen • Programmcode für iterative Traversierung der Liste vom Anfang zum Ende und wieder zurück wird eleganter, wenn der letzte Knoten nicht auf null, sondern auf sich selbst verweist: • ListNode<E> head, tmp;…ListNode<E> old, present;present = head;old = null;while (present != null) { process(present.data); tmp = present.next; present.next = old; old = present; present = tmp;}

6. ei+1 e1 e2 ei 3.3 Verkettete Listen Erweiterungen: • ZirkuläreListen: entry ... ... en

7. 3.3 Verkettete Listen • Beispiel: Josephus-Funktion • N Personen (rechts N=9) wählen einen Anführer, indem sie sich in einem Kreis aufstellen und jede M-te Person (M=5) aus dem Kreis entlassen. Nach dem Weggang einer Person wird der Kreis wieder geschlossen. Die letzte Person wird der Anführer (ein mathematisch gebildeter Möchtegern-Anführer ermittelt im Voraus, welche Position er im Kreis einzunehmen hat). • Josephus-FunktionJ(N, M): Die Identität des gewählten Anführers. J(9,5) = 8.

8. entry • Doppelt-verkettete zirkuläre Listen: e1 e2 en ei ei+1 ei+1 ei en … … 3.3 Verkettete Listen • Doppelt-verkettete Listen: entry null e1 e2 … … null

9. 3.3 Verkettete Listen • Mehrfach verkettete Listen: Knoten haben mehrere Verbindungsfelder und gehören zu unabhängig verwalteten verketteten Listen. Bsp. a, b: Start einer Liste. Doppelt-verkettete Listen: Spezialfall von mehrfach verketteten Listen

10. 3.3 Verkettete Listen • Realisierung verketteter Listen: • i.d.R. Referenzen auf Objekte • Arrays von Ganzzahlen, um verkettete Listen, z.B. für Josephus-Spiel (rechts), zu implementieren. Wir realisieren Verbindungen mit Arrayindizes. (Warum und wann ist dies möglich?) Die Abstraktionsmöglichkeit von Java hilft, solche Details zu verbergen

11. 3.4 Arrays vs. Verkettete Listen • Listen:Lokale Veränderungen können mit einem Aufwand durchgeführt werden, der unabhängig von der Größe der Liste ist - vorausgesetzt wir kennen die Speicherpositionen der involvierten Elemente • Verkettete Listen: Ein aus einer Liste gelöschtes Element hinterlässt keine Lücke, die wie beim Array gefüllt werden müsste. Stattdessen hinterlässt es freien Speicherplatz Speicherplatzverwalter (garbage collector) sammelt den nicht mehr benötigten Speicherplatz wieder ein.

12. 3.4 Arrays vs. Verkettete Listen Primzahlensieb von Eratosthenes: Array vorteilhaft, weil die Effizienz des Algorithmus darauf beruft, schnell auf eine beliebige Arrayposition zugreifen zu können Josephus-Problem: Verkettete Liste vorteilhaft, weil die Effizienz des Algorithmus darauf beruft, schnell Elemente entfernen zu können. Achtung: Verkettete Listen könnten durchaus intern mit Arrays realisiert werden! Die Wechselwirkung zwischen Datenstrukturen und Algorithmen bildet das Herz des Entwurfsprozesses und Kern der Vorlesung!

13. 3.5 Zusammengesetzte Datenstrukturen Arrays und verkettete Listen liefern eine erste Stufe der Abstraktion, auf der komplexere Datenstrukturen definiert werden können Mehrdimensionale Arrays: • Deklaration: Typ[][] Arrayname// 2-dimensionalTyp[][][] Arrayname// 3-dimensional alternativ: Typ Arrayname[][] • Initialisierung: Arrayname = new Typ[Size1][Size2]; oder (für nicht notwendigerweise rechteckige Arrays): Arrayname = newTyp[Size][]; for (int i = 0; i < Size; i++) Arrayname[i] = new Typ[Size_i];

14. 3.5 Zusammengesetzte Datenstrukturen • Beispiel: • Deklaration: int[][] table; • Erzeugung: • table = new int[3][2]; oder table = new int[3][]; • table[1] = new int[2];

15. 3.5 Zusammengesetzte Datenstrukturen • Beispiel: Effiziente Speicherung von nicht-rechteckigen Strukturen • int pascal [][] = { { 1 }, • { 1, 1 }, • { 1, 2, 1 }, • { 1, 3, 3, 1 }, • { 1, 4, 6, 4, 1 } }; Pascal[4][1]

16. 3.5 Zusammengesetzte Datenstrukturen • Beispiel: Darstellung von Graphen mit Adjazenzmatrix • Einfachheitshalber ordnen wir den Knoten Indizes zu. Adjazenzmatrix = 2D Matrix: Zeile i und Spalte j hat den Wert true, wenn es eine Kante von Knoten i zu Knoten j gibt. Das Array ist für ungerichtete Graphen symmetrisch. Per Konvention weisen wir den Elementen in der Diagonalen true-Werte zu. • Boolean adj[][] = new boolean[V][V];

17. 3.5 Zusammengesetzte Datenstrukturen • Dünn besetzte Adjazenzmatrix: Ein Graph mit wenigen Kanten kann auch mit einem Array von Adjazenzlisten darstellt werden. Der Speicherbedarf ist proportional zur Anzahl der Knoten plus Anzahl der Kanten.

18. Zusammenfassung • 3.1 Grundlegendes • 3.2 Arrays (Felder) • 3.3 Verkettete Listen • 3.4 Arrays vs. Verkettete Listen • 3.5 Zusammengesetzte Datenstrukturen