Keller, Schlangen und Listen. Elementare Datenstrukturen Keller, Schlangen und Listen 1 / 14

Transkript

1 Keller, Schlangen und Listen Elementare Datenstrukturen Keller, Schlangen und Listen 1 / 14

2 Listen Listen unterstützen die Operationen Lookup, Insert, Remove. + Listen passen sich der Größe der zu speichernden Datenmenge dynamisch an. Elementare Datenstrukturen Keller, Schlangen und Listen 2 / 14

3 Listen Listen unterstützen die Operationen Lookup, Insert, Remove. + Listen passen sich der Größe der zu speichernden Datenmenge dynamisch an. - Achtung: Lookup wird durch die lineare Suche implementiert und benötigt eine Laufzeit proportional zur Länge der Liste! Fürchterlich?!? Gleiches gilt für die Insert-Operation (wenn die Schlüssel sortiert abgespeichert werden) wie auch für die Remove-Operation. Elementare Datenstrukturen Keller, Schlangen und Listen 2 / 14

4 Listen Listen unterstützen die Operationen Lookup, Insert, Remove. + Listen passen sich der Größe der zu speichernden Datenmenge dynamisch an. - Achtung: Lookup wird durch die lineare Suche implementiert und benötigt eine Laufzeit proportional zur Länge der Liste! Fürchterlich?!? Gleiches gilt für die Insert-Operation (wenn die Schlüssel sortiert abgespeichert werden) wie auch für die Remove-Operation. Die Adjazenzliste für Graphen ist eine wichtige Anwendung. Viele Graph-Algorithmen (wie etwa Tiefen- oder Breitensuche) müssen alle Nachbarn besuchen: Die Abspeicherung der Nachbarn in einer Liste ist optimal! Elementare Datenstrukturen Keller, Schlangen und Listen 2 / 14

5 Keller und Schlangen Keller unterstützen die Operationen Insert und Remove (des jüngsten Schlüssels). + Beide Operationen gelingen in Konstantzeit! + Eine wichtige Anwendung ist Elementare Datenstrukturen Keller, Schlangen und Listen 3 / 14

6 Keller und Schlangen Keller unterstützen die Operationen Insert und Remove (des jüngsten Schlüssels). + Beide Operationen gelingen in Konstantzeit! + Eine wichtige Anwendung ist die Implementierung der Rekursion. Elementare Datenstrukturen Keller, Schlangen und Listen 3 / 14

7 Keller und Schlangen Keller unterstützen die Operationen Insert und Remove (des jüngsten Schlüssels). + Beide Operationen gelingen in Konstantzeit! + Eine wichtige Anwendung ist die Implementierung der Rekursion. Schlangen modellieren Warteschlangen und unterstützen die Operationen Insert und Remove (des ältesten Schlüssels). + Beide Operationen gelingen in Konstantzeit! Elementare Datenstrukturen Keller, Schlangen und Listen 3 / 14

8 Keller und Schlangen Keller unterstützen die Operationen Insert und Remove (des jüngsten Schlüssels). + Beide Operationen gelingen in Konstantzeit! + Eine wichtige Anwendung ist die Implementierung der Rekursion. Schlangen modellieren Warteschlangen und unterstützen die Operationen Insert und Remove (des ältesten Schlüssels). + Beide Operationen gelingen in Konstantzeit! + Breitensuche wird mit Schlangen implementiert. Elementare Datenstrukturen Keller, Schlangen und Listen 3 / 14

9 Prioritätswarteschlangen Elementare Datenstrukturen Prioritätswarteschlangen 4 / 14

10 Insert und Delete_Max Prioritätswarteschlangen unterstützen Warteschlangen mit Prioritäten, nämlich die Operationen Insert und Delete_Max. + Ein Heap implementiert beide Operationen in logarithmischer Zeit. - Lookup ist Elementare Datenstrukturen Prioritätswarteschlangen 5 / 14

11 Insert und Delete_Max Prioritätswarteschlangen unterstützen Warteschlangen mit Prioritäten, nämlich die Operationen Insert und Delete_Max. + Ein Heap implementiert beide Operationen in logarithmischer Zeit. - Lookup ist extrem langsam! + Eine wichtige Anwendung von Prioritätswarteschlangen ist Elementare Datenstrukturen Prioritätswarteschlangen 5 / 14

12 Insert und Delete_Max Prioritätswarteschlangen unterstützen Warteschlangen mit Prioritäten, nämlich die Operationen Insert und Delete_Max. + Ein Heap implementiert beide Operationen in logarithmischer Zeit. - Lookup ist extrem langsam! + Eine wichtige Anwendung von Prioritätswarteschlangen ist Dijkstra s Algorithmus für das Single- Source-Shortest-Path Problem. Elementare Datenstrukturen Prioritätswarteschlangen 5 / 14

13 Heaps: Nutzen und Fluch der Heapordnung Ein Heap wird durch Heapstruktur und Heapordnung definiert. Was bedeuten diese Begriffe? Elementare Datenstrukturen Prioritätswarteschlangen 6 / 14

14 Heaps: Nutzen und Fluch der Heapordnung Ein Heap wird durch Heapstruktur und Heapordnung definiert. Was bedeuten diese Begriffe? Die Funktionen Repair_up und Repair_down stellen die Heapordnung wieder her. Was genau tun diese Funktionen? Elementare Datenstrukturen Prioritätswarteschlangen 6 / 14

15 Heaps: Nutzen und Fluch der Heapordnung Ein Heap wird durch Heapstruktur und Heapordnung definiert. Was bedeuten diese Begriffe? Die Funktionen Repair_up und Repair_down stellen die Heapordnung wieder her. Was genau tun diese Funktionen? Ein Heap implementiert eine Prioritätswarteschlange durch ein Array: Wie navigiert man im Heap-Array? Wo findet man den Vater, wo die Kinder, wo die Wurzel? Elementare Datenstrukturen Prioritätswarteschlangen 6 / 14

16 Heaps: Nutzen und Fluch der Heapordnung Ein Heap wird durch Heapstruktur und Heapordnung definiert. Was bedeuten diese Begriffe? Die Funktionen Repair_up und Repair_down stellen die Heapordnung wieder her. Was genau tun diese Funktionen? Ein Heap implementiert eine Prioritätswarteschlange durch ein Array: Wie navigiert man im Heap-Array? Wo findet man den Vater, wo die Kinder, wo die Wurzel? Warum ist die Lookup-Operation so schwierig für Heaps, warum sind Insert und Delete_Max einfach? Elementare Datenstrukturen Prioritätswarteschlangen 6 / 14

17 Bäume Bäume 7 / 14

18 Die wichtigen Begriffe 1 Wie definiert man ungerichtete Bäume und wie gerichtete Bäume und wozu benutzt man eigentlich Bäume? Zur Veranschaulichung (Rekursionsbäume, Verzeichnisbäume, Vorfahrenbäume,...) Zur Implementierung von Wörterbüchern, für die Kompilierung,.... Bäume 8 / 14

19 Die wichtigen Begriffe 1 Wie definiert man ungerichtete Bäume und wie gerichtete Bäume und wozu benutzt man eigentlich Bäume? Zur Veranschaulichung (Rekursionsbäume, Verzeichnisbäume, Vorfahrenbäume,...) Zur Implementierung von Wörterbüchern, für die Kompilierung, Was ist die Tiefe und was ist die Höhe eines Baums? Und wie berechnet man Tiefe und Höhe? Bäume 8 / 14

20 Die wichtigen Begriffe 1 Wie definiert man ungerichtete Bäume und wie gerichtete Bäume und wozu benutzt man eigentlich Bäume? Zur Veranschaulichung (Rekursionsbäume, Verzeichnisbäume, Vorfahrenbäume,...) Zur Implementierung von Wörterbüchern, für die Kompilierung, Was ist die Tiefe und was ist die Höhe eines Baums? Und wie berechnet man Tiefe und Höhe? 3 Was ist ein Präorder-, Inorder oder Postorder-Durchlauf? Und wie führt man diese Durchläufe aus? Bäume 8 / 14

21 Die wichtigen Begriffe 1 Wie definiert man ungerichtete Bäume und wie gerichtete Bäume und wozu benutzt man eigentlich Bäume? Zur Veranschaulichung (Rekursionsbäume, Verzeichnisbäume, Vorfahrenbäume,...) Zur Implementierung von Wörterbüchern, für die Kompilierung, Was ist die Tiefe und was ist die Höhe eines Baums? Und wie berechnet man Tiefe und Höhe? 3 Was ist ein Präorder-, Inorder oder Postorder-Durchlauf? Und wie führt man diese Durchläufe aus? 4 Wie implementiert man Bäume? Man verwendet ein Vater-Array, die Kind-Geschwister- oder, falls anwendbar, die Binärbaum-Darstellung. Was sind die Vor- und Nachteile der einzelnen Implementierungen? Bäume 8 / 14

22 Präorder void praeorder (Knoten *p) Bäume 9 / 14

23 Präorder void praeorder (Knoten *p) { Knoten *q; Bäume 9 / 14

24 Präorder void praeorder (Knoten *p) { Knoten *q; if (p!= null) Bäume 9 / 14

25 Präorder void praeorder (Knoten *p) { Knoten *q; if (p!= null) { cout «p wert; Bäume 9 / 14

26 Präorder void praeorder (Knoten *p) { Knoten *q; if (p!= null) { cout «p wert; for (q=p LKind; q!= null; q=q RGeschwister) Bäume 9 / 14

27 Präorder void praeorder (Knoten *p) { Knoten *q; if (p!= null) { cout «p wert; for (q=p LKind; q!= null; q=q RGeschwister) praeorder(q); }} Und wie implementiert man Präorder nicht-rekursiv? Wie implementiert man Postorder? Bäume 9 / 14

28 Welcher Knoten wird direkt nach v besucht? Präorder: Bäume 10 / 14

29 Welcher Knoten wird direkt nach v besucht? Präorder: Das linkeste Kind von v, wenn v kein Blatt ist. Bäume 10 / 14

30 Welcher Knoten wird direkt nach v besucht? Präorder: Das linkeste Kind von v, wenn v kein Blatt ist. Wenn v ein Blatt ist, dann das Bäume 10 / 14

31 Welcher Knoten wird direkt nach v besucht? Präorder: Das linkeste Kind von v, wenn v kein Blatt ist. Wenn v ein Blatt ist, dann das erste nicht-besuchte Kind des tiefsten, nicht vollständig durchsuchten Vorfahren von v. Postorder: Bäume 10 / 14

32 Welcher Knoten wird direkt nach v besucht? Präorder: Das linkeste Kind von v, wenn v kein Blatt ist. Wenn v ein Blatt ist, dann das erste nicht-besuchte Kind des tiefsten, nicht vollständig durchsuchten Vorfahren von v. Postorder: Das linkeste Blatt im Baum des rechten Geschwisterknotens. Bäume 10 / 14

33 Welcher Knoten wird direkt nach v besucht? Präorder: Das linkeste Kind von v, wenn v kein Blatt ist. Wenn v ein Blatt ist, dann das erste nicht-besuchte Kind des tiefsten, nicht vollständig durchsuchten Vorfahren von v. Postorder: Das linkeste Blatt im Baum des rechten Geschwisterknotens. Wenn v keinen rechten Geschwisterknoten besitzt, dann wird Bäume 10 / 14

34 Welcher Knoten wird direkt nach v besucht? Präorder: Das linkeste Kind von v, wenn v kein Blatt ist. Wenn v ein Blatt ist, dann das erste nicht-besuchte Kind des tiefsten, nicht vollständig durchsuchten Vorfahren von v. Postorder: Das linkeste Blatt im Baum des rechten Geschwisterknotens. Wenn v keinen rechten Geschwisterknoten besitzt, dann wird der Vater von v als nächster besucht. Bäume 10 / 14

35 Graphen Graphen 11 / 14

36 Die wichtigen Begriffe und Methoden Ungerichtete und gerichtete Graphen modellieren Verkehrsnetze, Netzwerke, Schaltungen, den Webgraphen... Für viele Anwendungen ist die Graphdarstellung durch Adjazenzlisten maßgeschneidert. Warum? Graphen 12 / 14

37 Die wichtigen Begriffe und Methoden Ungerichtete und gerichtete Graphen modellieren Verkehrsnetze, Netzwerke, Schaltungen, den Webgraphen... Für viele Anwendungen ist die Graphdarstellung durch Adjazenzlisten maßgeschneidert. Warum? Begriffe wie Zusammenhangskomponenten, Wege, Distanz zwischen Knoten und azyklische Graphen sind zentral. Wie berechnet man Zusammenhangskomponenten, wie stellt man fest, ob ein Graph azyklisch ist, und wie führt man eine topologische Sortierung durch? Graphen 12 / 14

38 Die wichtigen Begriffe und Methoden Ungerichtete und gerichtete Graphen modellieren Verkehrsnetze, Netzwerke, Schaltungen, den Webgraphen... Für viele Anwendungen ist die Graphdarstellung durch Adjazenzlisten maßgeschneidert. Warum? Begriffe wie Zusammenhangskomponenten, Wege, Distanz zwischen Knoten und azyklische Graphen sind zentral. Wie berechnet man Zusammenhangskomponenten, wie stellt man fest, ob ein Graph azyklisch ist, und wie führt man eine topologische Sortierung durch? Tiefen- und Breitensuche sind wichtige Methoden. Und wie funktionieren diese Algorithmen? Graphen 12 / 14

39 Tiefen- und Breitensuche Welche Kantentypen erzeugt Tiefensuche für ungerichtete Graphen und welche Kantentypen für gerichtete Graphen? Warum interessiert man sich denn überhaupt für Kantentypen und was kann man mit Tiefensuche so alles anstellen? Graphen 13 / 14

40 Tiefen- und Breitensuche Welche Kantentypen erzeugt Tiefensuche für ungerichtete Graphen und welche Kantentypen für gerichtete Graphen? Warum interessiert man sich denn überhaupt für Kantentypen und was kann man mit Tiefensuche so alles anstellen? Wie wird der Wald der Tiefensuche berechnet? Wann ist eine Kante eine Baum-, Vorwärts-, Rückwärts- oder Querkante? Graphen 13 / 14

41 Tiefen- und Breitensuche Welche Kantentypen erzeugt Tiefensuche für ungerichtete Graphen und welche Kantentypen für gerichtete Graphen? Warum interessiert man sich denn überhaupt für Kantentypen und was kann man mit Tiefensuche so alles anstellen? Wie wird der Wald der Tiefensuche berechnet? Wann ist eine Kante eine Baum-, Vorwärts-, Rückwärts- oder Querkante? Wie wird der Baum der Breitensuche berechnet? Warum ist dieser Baum denn wichtig? Graphen 13 / 14

42 Eine automatische Erkennung der Kantentypen Wir benutzen zwei integer-arrays Anfang und Ende als Uhren, um den Zeitpunkt des Beginns und des Endes des Besuchs festzuhalten. Graphen 14 / 14

43 Eine automatische Erkennung der Kantentypen Wir benutzen zwei integer-arrays Anfang und Ende als Uhren, um den Zeitpunkt des Beginns und des Endes des Besuchs festzuhalten. Anfangnr=Endenr=0; void tsuche(int v) {Knoten *p; Anfang[v] = ++Anfangnr; Graphen 14 / 14

44 Eine automatische Erkennung der Kantentypen Wir benutzen zwei integer-arrays Anfang und Ende als Uhren, um den Zeitpunkt des Beginns und des Endes des Besuchs festzuhalten. Anfangnr=Endenr=0; void tsuche(int v) {Knoten *p; Anfang[v] = ++Anfangnr; for (p = A[v]; p!= 0; p = p->next) Graphen 14 / 14

45 Eine automatische Erkennung der Kantentypen Wir benutzen zwei integer-arrays Anfang und Ende als Uhren, um den Zeitpunkt des Beginns und des Endes des Besuchs festzuhalten. Anfangnr=Endenr=0; void tsuche(int v) {Knoten *p; Anfang[v] = ++Anfangnr; for (p = A[v]; p!= 0; p = p->next) if (!Anfang[p->name]) tsuche(p->name); Graphen 14 / 14

46 Eine automatische Erkennung der Kantentypen Wir benutzen zwei integer-arrays Anfang und Ende als Uhren, um den Zeitpunkt des Beginns und des Endes des Besuchs festzuhalten. Anfangnr=Endenr=0; void tsuche(int v) {Knoten *p; Anfang[v] = ++Anfangnr; for (p = A[v]; p!= 0; p = p->next) if (!Anfang[p->name]) tsuche(p->name); Ende[v] = ++Endenr; } Graphen 14 / 14

47 Eine automatische Erkennung der Kantentypen Wir benutzen zwei integer-arrays Anfang und Ende als Uhren, um den Zeitpunkt des Beginns und des Endes des Besuchs festzuhalten. Anfangnr=Endenr=0; void tsuche(int v) {Knoten *p; Anfang[v] = ++Anfangnr; for (p = A[v]; p!= 0; p = p->next) if (!Anfang[p->name]) tsuche(p->name); Ende[v] = ++Endenr; } - e = (u, v) ist eine Vorwärtskante Graphen 14 / 14

48 Eine automatische Erkennung der Kantentypen Wir benutzen zwei integer-arrays Anfang und Ende als Uhren, um den Zeitpunkt des Beginns und des Endes des Besuchs festzuhalten. Anfangnr=Endenr=0; void tsuche(int v) {Knoten *p; Anfang[v] = ++Anfangnr; for (p = A[v]; p!= 0; p = p->next) if (!Anfang[p->name]) tsuche(p->name); Ende[v] = ++Endenr; } - e = (u, v) ist eine Vorwärtskante Anfang [u] < Anfang [v] und Graphen 14 / 14

49 Eine automatische Erkennung der Kantentypen Wir benutzen zwei integer-arrays Anfang und Ende als Uhren, um den Zeitpunkt des Beginns und des Endes des Besuchs festzuhalten. Anfangnr=Endenr=0; void tsuche(int v) {Knoten *p; Anfang[v] = ++Anfangnr; for (p = A[v]; p!= 0; p = p->next) if (!Anfang[p->name]) tsuche(p->name); Ende[v] = ++Endenr; } - e = (u, v) ist eine Vorwärtskante Anfang [u] < Anfang [v] und e = (u, v) ist keine Baumkante. Graphen 14 / 14

50 Eine automatische Erkennung der Kantentypen Wir benutzen zwei integer-arrays Anfang und Ende als Uhren, um den Zeitpunkt des Beginns und des Endes des Besuchs festzuhalten. Anfangnr=Endenr=0; void tsuche(int v) {Knoten *p; Anfang[v] = ++Anfangnr; for (p = A[v]; p!= 0; p = p->next) if (!Anfang[p->name]) tsuche(p->name); Ende[v] = ++Endenr; } - e = (u, v) ist eine Vorwärtskante Anfang [u] < Anfang [v] und e = (u, v) ist keine Baumkante. - e = (u, v) ist eine Rückwärtskante Graphen 14 / 14

51 Eine automatische Erkennung der Kantentypen Wir benutzen zwei integer-arrays Anfang und Ende als Uhren, um den Zeitpunkt des Beginns und des Endes des Besuchs festzuhalten. Anfangnr=Endenr=0; void tsuche(int v) {Knoten *p; Anfang[v] = ++Anfangnr; for (p = A[v]; p!= 0; p = p->next) if (!Anfang[p->name]) tsuche(p->name); Ende[v] = ++Endenr; } - e = (u, v) ist eine Vorwärtskante Anfang [u] < Anfang [v] und e = (u, v) ist keine Baumkante. - e = (u, v) ist eine Rückwärtskante Anfang [u] > Anfang [v] und Graphen 14 / 14

52 Eine automatische Erkennung der Kantentypen Wir benutzen zwei integer-arrays Anfang und Ende als Uhren, um den Zeitpunkt des Beginns und des Endes des Besuchs festzuhalten. Anfangnr=Endenr=0; void tsuche(int v) {Knoten *p; Anfang[v] = ++Anfangnr; for (p = A[v]; p!= 0; p = p->next) if (!Anfang[p->name]) tsuche(p->name); Ende[v] = ++Endenr; } - e = (u, v) ist eine Vorwärtskante Anfang [u] < Anfang [v] und e = (u, v) ist keine Baumkante. - e = (u, v) ist eine Rückwärtskante Anfang [u] > Anfang [v] und Ende [u] < Ende [v]. Graphen 14 / 14

53 Eine automatische Erkennung der Kantentypen Wir benutzen zwei integer-arrays Anfang und Ende als Uhren, um den Zeitpunkt des Beginns und des Endes des Besuchs festzuhalten. Anfangnr=Endenr=0; void tsuche(int v) {Knoten *p; Anfang[v] = ++Anfangnr; for (p = A[v]; p!= 0; p = p->next) if (!Anfang[p->name]) tsuche(p->name); Ende[v] = ++Endenr; } - e = (u, v) ist eine Vorwärtskante Anfang [u] < Anfang [v] und e = (u, v) ist keine Baumkante. - e = (u, v) ist eine Rückwärtskante Anfang [u] > Anfang [v] und Ende [u] < Ende [v]. - e = (u, v) ist eine Querkante Graphen 14 / 14

54 Eine automatische Erkennung der Kantentypen Wir benutzen zwei integer-arrays Anfang und Ende als Uhren, um den Zeitpunkt des Beginns und des Endes des Besuchs festzuhalten. Anfangnr=Endenr=0; void tsuche(int v) {Knoten *p; Anfang[v] = ++Anfangnr; for (p = A[v]; p!= 0; p = p->next) if (!Anfang[p->name]) tsuche(p->name); Ende[v] = ++Endenr; } - e = (u, v) ist eine Vorwärtskante Anfang [u] < Anfang [v] und e = (u, v) ist keine Baumkante. - e = (u, v) ist eine Rückwärtskante Anfang [u] > Anfang [v] und Ende [u] < Ende [v]. - e = (u, v) ist eine Querkante Anfang [u] > Anfang [v] und Graphen 14 / 14

55 Eine automatische Erkennung der Kantentypen Wir benutzen zwei integer-arrays Anfang und Ende als Uhren, um den Zeitpunkt des Beginns und des Endes des Besuchs festzuhalten. Anfangnr=Endenr=0; void tsuche(int v) {Knoten *p; Anfang[v] = ++Anfangnr; for (p = A[v]; p!= 0; p = p->next) if (!Anfang[p->name]) tsuche(p->name); Ende[v] = ++Endenr; } - e = (u, v) ist eine Vorwärtskante Anfang [u] < Anfang [v] und e = (u, v) ist keine Baumkante. - e = (u, v) ist eine Rückwärtskante Anfang [u] > Anfang [v] und Ende [u] < Ende [v]. - e = (u, v) ist eine Querkante Anfang [u] > Anfang [v] und Ende [u] > Ende [v]. Graphen 14 / 14