5.3 Doppelt verkettete Listen

Transkript

1 5.3 Doppelt verkettete Listen Einfach verkettete Listen unterstützen das Einfügen und Löschen am Anfang in konstanter Zeit; für das Einfügen und Löschen am Ende benötigen sie jedoch lineare Laufzeit Doppelt verkettete Listen merken sich zu jedem Knoten sowohl den Vorgänger als auch den Nachfolger und können dadurch auch die Operationen am Ende ebenso in konstanter Laufzeit unterstützen 42

2 Knoten einer doppelt verketteten Liste Bei einer doppelt verketteten Liste enthält jeder Knoten einen Wert (value) und verweist auf den vorherigen (prev) sowie den nächsten (next) Knoten in der Liste prev value next 43

3 Knoten einer doppelt verketteten Liste 1 private class Node { 2 3 // Wert des Knotens 4 private int value; 5 6 // Vorheriger Knoten 7 private Node prev; 8 9 // Nä chster Knoten 10 private Node next; public void setvalue(int v) { 13 value = v; 14 } public void setprev(node p) { 17 prev = p; 18 } public void setnext(node n) { 21 next = n; 22 } public int getvalue() { 25 return value; 26 } public Node getprev() { 29 return prev; 30 } public Node getnext() { 33 return next; 34 } } prev value next 44

4 Kopf und Schwanz einer doppelt verketteten Liste Wir merken uns für eine doppelt verkettete Liste den ersten Knoten, genannt Kopf, sowie den letzten Knoten, genannt Schwanz Initial, wenn die Liste noch leer ist und es keine Knoten gibt, haben beide den Wert 1 public class DoubleLinkedList { 2 3 // Kopf der Liste 4 private Node head; 5 6 // Schwanz der Liste 7 private Node tail; 8 9 // Definition der Methoden folgt } 45

5 Einfügen am Anfang in doppelt verkettete Liste Zum Einfügen eines Werts k am Anfang einer doppelt verketteten Liste unterscheiden wir zwei Fälle Ist die Liste noch leer, so erzeugen wir einen neuen Knoten mit Wert k; dieser wird neuer Kopf und neuer Schwanz der Liste Andernfalls wird der neue Knoten neuer Kopf der Liste und zeigt auf den bisherigen Kopf als Nachfolger, welcher auf den neuen Knoten als Vorgänger zeigt 46

6 Einfügen am Anfang in doppelt verkettete Liste 1 public void insertfirst(int k) { 2 // Neuen Knoten anlegen 3 Node node = new Node(); 4 node.setvalue(k); 5 // Ist die Liste noch leer? 6 if (head == ) { 7 head = node; 8 tail = node; 9 } else { 10 node.setnext(head); 11 head.setprev(node); 12 head = node; 13 } 14 } Das Einfügen am Anfang hat Laufzeit in O(1) 47

7 Einfügen am Anfang in doppelt verkettete Liste Beispiel: Einfügen am Anfang einer Liste head tail insertfirst(3) head tail 48

8 Einfügen am Ende in doppelt verkettete Liste Zum Einfügen eines Werts k am Ende einer doppelt verketteten Liste unterscheiden wir zwei Fälle Ist die Liste noch leer, so erzeugen wir einen neuen Knoten mit Wert k; dieser wird neuer Kopf und neuer Schwanz der Liste Andernfalls wird der neue Knoten neuer Schwanz der Liste und zeigt auf den bisherigen Schwanz als Vorgänger, welcher auf den neuen Knoten als Nachfolger zeigt 49

9 Einfügen am Ende in doppelt verkettete Liste 1 public void insertlast(int k) { 2 // Neuen Knoten anlegen 3 Node node = new Node(); 4 node.setvalue(k); 5 // Ist die Liste noch leer? 6 if (head == ) { 7 head = node; 8 tail = node; 9 } else { 10 node.setprev(tail); 11 tail.setnext(node); 12 tail = node; 13 } 14 } Das Einfügen am Ende hat Laufzeit in O(1) 50

10 Einfügen am Ende in doppelt verkettete Liste Beispiel: Einfügen am Ende einer Liste head tail insertlast(3) head tail 51

11 Löschen am Anfang aus doppelt verketteter Liste Zum Löschen am Anfang einer doppelt verketteten Liste unterscheiden wir folgende Fälle Ist die Liste noch leer, so gibt es nichts zu tun Besteht die Liste nur aus einem einzigen Knoten, so entfernen wir diesen, indem wir Kopf und Schwanz der Liste auf setzen Andernfalls entfernen wir den ersten Knoten in der Liste, indem wir den zweiten Knoten zum Kopf machen 52

12 Löschen am Anfang aus doppelt verketteter Liste 1 public int deletefirst() { 2 int k = 0; 3 if (head!= ) { 4 k = head.getvalue(); 5 // Besteht die Liste nur aus einem Wert? 6 if (head == tail) { 7 head = ; 8 tail = ; 9 } else { 10 Node newhead = head.getnext(); 11 head.setnext(); 12 newhead.setprev(); 13 head = newhead; 14 } 15 } 16 return k; 17 } Das Löschen am Anfang hat Laufzeit in O(1) 53

13 Löschen am Anfang aus doppelt verketteter Liste Beispiel: Löschen am Anfang einer Liste head tail deletefirst() 5 1 head tail 54

14 Löschen am Ende aus doppelt verketteter Liste Zum Löschen am Ende einer doppelt verketteten Liste unterscheiden wir folgende Fälle Ist die Liste noch leer, so gibt es nichts zu tun Besteht die Liste nur aus einem einzigen Knoten, so entfernen wir diesen, indem wir Kopf und Schwanz der Liste auf setzen Andernfalls entfernen wir den letzten Knoten in der Liste, indem wir den zweitletzten Knoten zum Schwanz machen 55

15 Löschen am Ende aus doppelt verketteter Liste 1 public int deletelast() { 2 int k = 0; 3 if (tail!= ) { 4 k = tail.getvalue(); 5 // Besteht die Liste nur aus einem Wert? 6 if (head == tail) { 7 head = ; 8 tail = ; 9 } else { 10 Node newtail = tail.getprev(); 11 tail.setprev(); 12 newtail.setnext(); 13 tail = newtail; 14 } 15 } 16 return k; 17 } Das Löschen am Ende hat Laufzeit in O(1) 56

16 Löschen am Ende aus doppelt verketteter Liste Beispiel: Löschen am Ende einer Liste head tail deletelast() 2 5 head tail 57

17 Löschen aus doppelt verketteter Liste Zum Löschen eines gegebenen Werts k aus einer doppelt verketteten Liste suchen wir einen Knoten in der Liste, der den Wert enthält Haben wir einen solchen Knoten gefunden, machen wir seinen Nachfolger zum Nachfolger seines Vorgängers und seinen Vorgänger zum Vorgänger seines Nachfolgers 58

18 Löschen aus doppelt verketteter Liste 1 public boolean delete(int k) { 2 boolean found = false; 3 if (head!= ) { 4 Node cur = head; 5 while (cur!= && cur.getvalue()!= k) { 6 cur = cur.getnext(); 7 } 8 if (cur!= ) { 9 found = true; 10 Node prev = cur.getprev(); 11 Node next = cur.getnext(); 12 if (prev!= ) { 13 prev.setnext(next); 14 } else { 15 head = next; 16 } 17 if (next!= ) { 18 next.setprev(prev); 19 } else { 20 tail = prev; 21 } 22 cur.setprev(); 23 cur.setnext(); 24 } 25 } 26 return found; 27 } Das Löschen hat damit Laufzeit in O(n) 59

19 Löschen aus doppelt verketteter Liste Beispiel: Löschen aus einer Liste head tail delete(5) 2 1 head tail 60

20 Suche in doppelt verketteter Liste Zum Suchen eines gegebenen Werts k in einer doppelt verketteten Liste durchlaufen wir diese und überprüfen für jeden Knoten, ob dieser den gesuchten Wert enthält 61

21 Suche in doppelt verketteter Liste 1 public boolean search(int k) { 2 boolean found = false; 3 if (head!= ) { 4 Node cur = head; 5 while (cur!= && cur.getvalue()!= k) { 6 cur = cur.getnext(); 7 } 8 if (cur!= ) { 9 found = true; 10 } 11 } 12 return found; 13 } Die Suche hat Laufzeit in O(n) 62

22 5.4 LIFO- und FIFO-Warteschlangen Warteschlangen unterstützen die folgenden Operationen enqueue(k) reiht den Wert k in die Warteschlange ein dequeue() entnimmt einen Wert aus der Warteschlange Welcher Wert beim Aufruf von dequeue() entnommen wird, kann von der Reihenfolge, in der die Werte eingereiht oder den Werten selbst abhängen Warteschlangen sind ein wichtiger Baustein z.b. für Algorithmen auf Graphen sowie die Implementierung von Zwischenspeicher (Puffern) 63

23 5.4.1 LIFO-Warteschlange LIFO-Warteschlangen (last in first out) entnehmen immer den Wert, der zuletzt eingereiht wurde LIFO-Warteschlangen werden auch Stapel oder Keller (Englisch: stack oder lifo queue) genannt und die beiden Operationen als push(k) und pop() bezeichnet LIFO-Warteschlangen lassen sich mit Hilfe einer einfach oder doppelt verketteten Liste implementieren: enqueue(k) fügt den Wert k am Anfang der Liste ein dequeue() löscht den Wert am Anfang der Liste 64

24 LIFO-Warteschlange 1 public class LIFOQueue { 2 3 private DoubleLinkedList list; 4 5 public LIFOQueue() { 6 list = new DoubleLinkedList(); 7 } 8 9 public void enqueue(int k) { 10 list.insertfirst(k); 11 } public int dequeue() { 14 return list.deletefirst(); 15 } public int size() { 18 return list.size(); 19 } public boolean isempty() { 22 return list.isempty(); 23 } } 65

25 LIFO-Warteschlange Beispiel: LIFO-Warteschlange enqueue(5) 5 enqueue(2) 2 5 enqueue(1) dequeue()

26 5.4.2 FIFO-Warteschlange FIFO-Warteschlangen (first in first out) entnehmen immer den Wert, der zuerst eingereiht wurde FIFO-Warteschlangen lassen sich mit Hilfe einer doppelt verketteten Liste implementieren: enqueue(k) fügt den Wert k am Anfang der Liste ein dequeue() löscht den Wert am Ende der Liste 67

27 FIFO-Warteschlange 1 public class FIFOQueue { 2 3 private DoubleLinkedList list; 4 5 public FIFOQueue() { 6 list = new DoubleLinkedList(); 7 } 8 9 public void enqueue(int k) { 10 list.insertfirst(k); 11 } public int dequeue() { 14 return list.deletelast(); 15 } public int size() { 18 return list.size(); 19 } public boolean isempty() { 22 return list.isempty(); 23 } } 68

28 FIFO-Warteschlange Beispiel: FIFO-Warteschlange enqueue(5) 5 enqueue(2) 2 5 enqueue(1) dequeue()

29 Zusammenfassung Doppelt verkettete Listen belegen so viel Speicherplatz wie nötig und unterstützen das Einfügen und Löschen am Anfang und Ende in konstanter Laufzeit LIFO- und FIFO-Warteschlangen unterstützen die Operationen enqueue(k) sowie dequeue() zum Einreihen bzw. Entfernen von Werten und können mit Hilfe von verketteten Listen implementiert werden 70

30 Literatur [1] H.-P. Gumm und M. Sommer: Einführung in die Informatik, Oldenbourg Verlag, 2012 (Kapitel 4) [2] T. H. Cormen, C. E. Leiserson, R. Rivest und C. Stein: Algorithmen Eine Einführung, Oldenbourg Verlag, 2009 (Kapitel 10) 71