Algorithmen und Datenstrukturen (für ET/IT)

Transkript

1 Algorithmen und Datenstrukturen (für ET/IT) Sommersemester 2014 Dr. Tobias Lasser Computer Aided Medical Procedures Technische Universität München

2 2 Programm heute 1 Einführung 2 Grundlagen von Algorithmen 3 Grundlagen von Datenstrukturen Primitive Datentypen und Zahldarstellung Felder als sequentielle Liste Zeichen und Zeichenfolgen Felder als verkettete Liste Abstrakte Datentypen Stacks Queues

3 Definition Feld Definition Feld Ein Feld A ist eine Folge von n Datenelementen (d i ) i=1,...,n, A = d 1, d 2,..., d n mit n N 0. Die Datenelemente d i sind beliebige Datentypen (z.b. primitive).

4 Feld als sequentielle Liste Repräsentation von Feld A als sequentielle Liste (oder Array) feste Anzahl n von Datenelementen zusammenhängend gespeichert in linearer Reihenfolge mit Index Zugriff auf i-tes Element über Index i: A[i]... Feld A: A[n-1] A[n-2] A[2] A[1] A[0] Deklaration: in C++: std::vector<int> A(n);

5 5 Operationen auf sequentiellen Listen Sei A sequentielle Liste. Operationen: initialize: Initialisiere seq. Liste A mit n Elementen elementat(i): Zugriff auf i-tes Element von A: A[i] insert: füge Element in seq. Liste A ein (erfordert Umkopieren und evtl. Verlängern von A) erase: entferne Element aus seq. Liste A (erfordert Umkopieren) A[n-1] A[n-2].... A[1] A[0]

6 6 Feld als einfach verkettete Liste Repräsentation von Feld A als verkettete Liste dynamische Anzahl von Datenelementen in linearer Reihenfolge gespeichert (nicht notwendigerweise zusammenhängend!) mit Referenzen oder Zeigern verkettet start Daten Daten Daten Daten next next next next null auf Englisch: linked list

7 Verkettete Liste start Daten Daten Daten Daten next next next next null Folge von miteinander verbundenen Elementen jedes Element d i besteht aus Daten: Wert des Feldes an Position i next: Referenz auf das nächste Element d i+1 Node: Daten next start ist Referenz auf erstes Element des Feldes d 1 letztes Element d n hat keinen Nachfolger symbolisiert durch null-referenz 7

8 Operationen auf verketteter Liste Zugriff auf Element i: beginne bei start Referenz vorhangeln entlang next Referenzen bis zum i-ten Element Beispiel für i=3: start Daten Daten Daten Daten next next next next null Hilfsreferenz

9 9 Operationen auf verketteter Liste Löschen von Element i: Zugriff auf Element i-1 umhängen von next Referenz von Element i-1 auf Element i+1 Beispiel für i=3: start Daten Daten Daten Daten next next next next null Hilfsreferenz

10 Operationen auf verketteter Liste Einfügen von Element an Stelle i: Zugriff auf Element i-1 umhängen von next Referenz von Element i-1 auf neues Element next Referenz von neuem Element setzen auf altes Element i Beispiel für i=3: start Daten Daten Daten Daten next next next next null Hilfsreferenz Daten neues Element next

11 Optionales C++ Beispiel: Verkettete Liste (Auszug 1) // Liste initialisieren std :: forward_list < int > A{0, 1, 4, 9, 16}; // erstes Element aendern A. front () = 7; // front () greift auf start Referenz zu // Liste ausgeben for ( int x: A) std :: cout << x << " "; std :: cout << std :: endl ; // Zugriff auf 3. Element auto hilfsref = A. begin (); // start Referenz std :: advance ( hilfsref, 2); // 2 Elemente weiter hangeln std :: cout << "3. Element : " << * hilfsref << std :: endl ; Ausgabe: Element : 4

12 Optionales C++ Beispiel: Verkettete Liste (Auszug 2) // 3. Element loeschen auto hilfsref = A. begin (); // start Referenz std :: advance ( hilfsref, 1); // zeigt nun auf 2. Element A. erase_ after ( hilfsref ); // loesche Element nach hilfsref // Liste ausgeben for ( int x: A) std :: cout << x << " "; std :: cout << std :: endl ; // neues Element an 3. Stelle einfuegen A. insert_ after ( hilfsref, 8); // Liste ausgeben for ( int x: A) std :: cout << x << " "; std :: cout << std :: endl ; Ausgabe:

13 13 Gegenüberstellung sequentielle Liste und verkettete Liste Sequentielle Liste Direkter Zugriff auf i-tes Element sequentielles Durchlaufen sehr einfach statische Länge, kann Speicher verschwenden Einfügen/Löschen erfordert erheblich Kopieraufwand Verkettete Liste Zugriff auf i-tes Element erfordert i Iterationen sequentielles Durchlaufen sehr einfach dynamische Länge zusätzlicher Speicher für Zeiger benötigt Einfügen/Löschen einfach

14 Feld als doppelt verkettete Liste Repräsentation von Feld A als doppelt verkettete Liste verkettete Liste jedes Element mit Referenzen doppelt verkettet null prev prev prev prev start Daten Daten Daten Daten stop next next next next null auf Englisch: doubly linked list

15 start/stop sind Referenzen auf erstes/letztes Element des Doppelt verkettete Liste null prev prev prev prev start Daten Daten Daten Daten stop next next next next null Folge von miteinander verbundenen Elementen jedes Element d i besteht aus Daten: Wert des Feldes an Position i next: Referenz auf das nächste Element d i+1 prev: Referenz auf das vorherige Element d i 1 Node: prev Daten next

16 16 Operationen auf doppelt verketteter Liste Löschen von Element i: Zugriff auf Element i umhängen von next von Element i-1 auf Element i+1 umhängen von prev von Element i+1 auf Element i-1 Beispiel für i=3: null prev prev prev prev start Daten Daten Daten Daten stop next next next next null

17 Operationen auf doppelt verketteter Liste Einfügen von Element an Stelle i: Zugriff auf Element i umhängen von next von Element i-1 auf neues Element, sowie umhängen von prev von altem Element i auf neues Element next bzw. prev von neuem Element setzen auf altes Element i bzw. Element i-1 Beispiel für i=3: null prev prev prev prev start Daten Daten Daten Daten stop next next next next prev null Daten next 17

18 Eigenschaften doppelt verkettete Liste Feld A als doppelt verkettete Liste Vorteile: Durchlauf in beiden Richtungen möglich Einfügen/Löschen potentiell einfacher, da man sich Vorgänger nicht extra merken muss Nachteile: zusätzlicher Speicher erforderlich für zwei Referenzen Referenzverwaltung komplizierter und fehleranfällig

19 Optionales Beispiel in C++: Doppelt verkettete Liste 1 // Liste initialisieren std :: list <int > A{0, 1, 4, 9, 16}; // erstes und letztes Element aendern A. front () = 7; // front () greift auf start Referenz zu A. back () = 23; // back () greift auf stop Referenz zu // Liste ausgeben for ( int x: A) std :: cout << x << " "; std :: cout << std :: endl ; // Zugriff auf 3. Element auto hilfsref = A. begin (); // start Referenz std :: advance ( hilfsref, 2); // zwei Elemente weiter hangeln std :: cout << "3. Element : " << * hilfsref << std :: endl ; Ausgabe: Element : 4

20 Optionales Beispiel in C++: Doppelt verkettete Liste 2 // 3. Element loeschen hilfsref = A. begin (); // start Referenz std :: advance ( hilfsref, 2); // zwei Elemente weiter hangeln hilfsref = A. erase ( hilfsref ); // Element loeschen // Liste ausgeben for ( int x: A) std :: cout << x << " "; std :: cout << std :: endl ; // neues Element an 3. Stelle einfuegen A. insert ( hilfsref, 8); // Liste ausgeben for ( int x: A) std :: cout << x << " "; std :: cout << std :: endl ; Ausgabe:

21 Zusammenfassung Felder Ein Feld A kann repräsentiert werden als: sequentielle Liste (array) mit fixer Länge verkettete Liste (linked list) mit dynamischer Länge doppelt verkettete Liste (doubly linked list) mit dynamischer Länge Eigenschaften: einfach und flexibel aber manche Operationen aufwendig Als nächstes Aufgabe von Flexibilität für Effizienz

22 22 Programm heute 1 Einführung 2 Grundlagen von Algorithmen 3 Grundlagen von Datenstrukturen Primitive Datentypen und Zahldarstellung Felder als sequentielle Liste Zeichen und Zeichenfolgen Felder als verkettete Liste Abstrakte Datentypen Stacks Queues

23 23 Definition Abstrakter Datentyp Abstrakter Datentyp (englisch: abstract data type, ADT) Ein abstrakter Datentyp ist ein mathematisches Modell für bestimmte Datenstrukturen mit vergleichbarem Verhalten. Ein abstrakter Datentyp wird indirekt definiert über mögliche Operationen auf ihm sowie mathematische Bedingungen (oder: constraints) über die Auswirkungen der Operationen (u.u. auch die Kosten der Operationen).

24 24 Beispiel abstrakter Datentyp: abstrakte Variable Abstrakte Variable V ist eine veränderliche Dateneinheit mit zwei Operationen load(v) liefert einen Wert store(v, x) wobei x ein Wert und der Bedingung load(v) liefert immer den Wert x der letzten Operation store(v, x)

25 25 Beispiel abstrakter Datentyp: abstrakte Liste (Teil 1) Abstrakte Liste L ist ein Datentyp mit Operationen pushfront(l, x) liefert eine Liste front(l) liefert ein Element rest(l) liefert eine Liste und den Bedingungen ist x Element, L Liste, dann liefert front(pushfront(l, x)) das Element x. ist x Element, L Liste, dann liefert rest(pushfront(l, x)) die Liste L.

26 26 Beispiel abstrakter Datentyp: abstrakte Liste (Teil 2) Abstrakte Liste L. Weitere Operationen sind isempty(l) liefert true oder false initialize() liefert eine Listen Instanz mit den Bedingungen initialize() L für jede Liste L (d.h. jede neue Liste ist separat von alten Listen) isempty(initialize()) == true (d.h. eine neue Liste ist leer) isempty(pushfront(l, x)) == false (d.h. eine Liste ist nach einem pushfront nicht leer)

27 27 Programm heute 1 Einführung 2 Grundlagen von Algorithmen 3 Grundlagen von Datenstrukturen Primitive Datentypen und Zahldarstellung Felder als sequentielle Liste Zeichen und Zeichenfolgen Felder als verkettete Liste Abstrakte Datentypen Stacks Queues

28 28 Definition Stack Stack (oder deutsch: Stapel, Keller) Ein Stack ist ein abstrakter Datentyp. Er beschreibt eine spezielle Listenstruktur nach dem Last In First Out (LIFO) Prinzip mit den Eigenschaften löschen, einfügen ist nur am Ende der Liste erlaubt, nur das letzte Element darf manipuliert werden. Operationen auf Stacks: push: legt ein Element auf den Stack (einfügen) pop: entfernt das letzte Element vom Stack (löschen) top: liefert das letzte Stack-Element isempty: liefert true falls Stack leer initialize: Stack erzeugen und in Anfangszustand (leer) setzen

29 Definition Stack Stack (oder deutsch: Stapel, Keller) Ein Stack ist ein abstrakter Datentyp. Er beschreibt eine spezielle Listenstruktur nach dem Last In First Out (LIFO) Prinzip mit den Eigenschaften lo schen, einfu gen ist nur am Ende der Liste erlaubt, nur das letzte Element darf manipuliert werden. "push" Piz za Piz za neu e Piz Piz z a za #3 #2 #1 29

30 30 Definition Stack (exakter) Stack S ist ein abstrakter Datentyp mit Operationen pop(s) liefert einen Wert push(s, x) wobei x ein Wert mit der Bedingung ist x Wert und V abstrakte Variable, dann ist die Sequenz push(s, x); store(v, pop(s)) äquivalent zu store(v, x) sowie der Operation top(s) liefert einen Wert mit der Bedingung ist x Wert und V abstrakte Variable, dann ist die Sequenz push(s, x); store(v, top(s)); äquivalent zu push(s, x); store(v, x)

31 31 Definition Stack (exakter, Teil 2) Stack S. Weitere Operationen sind isempty(s) liefert true oder false initialize() liefert eine Stack Instanz mit den Bedingungen initialize() S für jeden Stack S (d.h. jeder neue Stack ist separat von alten Stacks) isempty(initialize()) == true (d.h. ein neuer Stack ist leer) isempty(push(s, x)) == false (d.h. ein Stack nach push ist nicht leer)

32 32 Anwendungsbeispiele Stack Auswertung arithmetischer Ausdrücke (s. nächste Folie) Call-Stack bei Funktionsaufrufen Einfache Vorwärts- / Rückwärts Funktion in Software z.b. im Internet-Browser Syntaxanalyse eines Programms z.b. zur Erkennung von Syntax-Fehlern durch Compiler

33 Auswertung arithmetischer Ausdrücke Gegeben sei ein vollständig geklammerter, einfacher arithmetischer Ausdruck mit Bestandteilen Zahl, +, *, = Beispiel: (3 * (4 + 5)) = Schema: arbeite Ausdruck von links nach rechts ab, speichere jedes Zeichen ausser ) und = in Stack S bei ) werte die 3 obersten Elemente von S aus, dann entferne die passende Klammer ( vom Stack S und speichere Ergebnis in Stack S bei = steht das Ergebnis im obersten Stack-Element von S

34 35 Implementation Stack Stack ist abstrakter Datentyp. Implementation ist nicht festgelegt nur Operationen und Bedingungen sind festgelegt Stack kann auf viele Arten implementiert werden, zum Beispiel als: sequentielle Liste verkettete Liste

35 36 Implementation Stack als sequentielle Liste Stack-Elemente speichern in sequentieller Liste A (Länge n) oberstes Stack-Element merken mittels Variable top falls Stack leer ist top == -1 n-1 n top push(x) inkrementiert top und speichert x in A[top] pop() liefert A[top] zurück und dekrementiert top top() liefert A[top] zurück

36 37 Implementation Stack als sequentielle Liste n-1 n initialize(); top n-1 n push(1); push(4); push(9); top n-1 n pop(); top

37 Implementation Stack als verkettete Liste Stack-Elemente speichern in verketteter Liste L oberstes Stack-Element wird durch start Referenz markiert start Daten Daten Daten Daten next next next next null push(x) fügt Element an erster Position ein pop() liefert Element an erster Position zurück und entfernt es top() liefert Element an erster Position zurück

38 39 Optional: Stacks in C++ in der C++ Standard Library: std::stack<datatype> unterstützte Operationen: push pop (liefert aber nichts zurück!) top empty implementiert wahlweise als doppelt verkettete Liste als std::stack<datatype, std::list<datatype> > sequentielle Liste als std::stack<datatype, std::vector<datatype> > std::dequeue (default, zerstückelte sequentielle Liste)

39 Optionales C++ Beispiel: Stack std :: stack < int > S; // erstelle Stack S if (S. empty ()) std :: cout << " Stack S ist leer." << std :: endl ; // fuege Elemente 1, 4, 9 hinzu S. push (1); S. push (4); S. push (9); // gib oberstes Element aus std :: cout << " top = " << S. top () << std :: endl ; // entferne oberstes Element S. pop (); // gib oberstes Element aus std :: cout << " top = " << S. top () << std :: endl ; Ausgabe: Stack S ist leer. top = 9 top = 4

40 Zusammenfassung Stack Stack ist abstrakter Datentyp als Metapher für einen Stapel wesentliche Operationen: push, pop Implementation als sequentielle Liste fixe Größe (entweder Speicher verschwendet oder zu klein) push, pop sehr effizient Implementation als verkettete Liste dynamische Größe, aber Platz für Zeiger verschwendet push, pop sehr effizient

41 42 Programm heute 1 Einführung 2 Grundlagen von Algorithmen 3 Grundlagen von Datenstrukturen Primitive Datentypen und Zahldarstellung Felder als sequentielle Liste Zeichen und Zeichenfolgen Felder als verkettete Liste Abstrakte Datentypen Stacks Queues

42 43 Definition Queue Queue (oder deutsch: Warteschlange) Eine Queue ist ein abstrakter Datentyp. Sie beschreibt eine spezielle Listenstruktur nach dem First In First Out (FIFO) Prinzip mit den Eigenschaften einfügen ist nur am Ende der Liste erlaubt, entfernen ist nur am Anfang der Liste erlaubt. Person verlässt Schlange Person stellt sich an

43 44 Definition Queue Queue (oder deutsch: Warteschlange) Eine Queue ist ein abstrakter Datentyp. Sie beschreibt eine spezielle Listenstruktur nach dem First In First Out (FIFO) Prinzip mit den Eigenschaften einfügen ist nur am Ende der Liste erlaubt, entfernen ist nur am Anfang der Liste erlaubt. Operationen auf Queues: enqueue: fügt ein Element am Ende der Schlange hinzu dequeue: entfernt das erste Element der Schlange isempty: liefert true falls Queue leer initialize: Queue erzeugen und in Anfangszustand (leer) setzen

44 45 Definition Queue (exakter) Queue Q ist ein abstrakter Datentyp mit Operationen dequeue(q) liefert einen Wert enqueue(q, x) wobei x ein Wert isempty(q) liefert true oder false initialize liefert eine Queue Instanz und mit Bedingungen ist x Wert, V abstrakte Variable und Q eine leere Queue, dann ist die Sequenz enqueue(q, x); store(v, dequeue(q)) äquivalent zu store(v, x) sind x,y Werte, V abstrakte Variable und Q eine leere Queue, dann ist die Sequenz enqueue(q, x); enqueue(q, y); store(v, dequeue(q)) äquivalent zu store(v, x); enqueue(q, y) initialize() Q für jede Queue Q isempty(initialize()) == true isempty(enqueue(q, x)) == false

45 46 Beispiel: Queue Q: Q = initialize(); Anfang Q: 1 enqueue(1); Anfang Q: 1 2 enqueue(2); Anfang Q: enqueue(3); Anfang Q: 2 3 dequeue(); Anfang Q: 3 dequeue(); Anfang

46 47 Anwendungsbeispiele Queue Druckerwarteschlange Playlist von itunes (oder ähnlichem Musikprogramm) Kundenaufträge bei Webshops Warteschlange für Prozesse im Betriebssystem (Multitasking)

47 48 Anwendungsbeispiel Stack und Queue Palindrom Ein Palindrom ist eine Zeichenkette, die von vorn und von hinten gelesen gleich bleibt. Beispiel: Reittier Erkennung ob Zeichenkette ein Palindrom ist ein Stack kann die Reihenfolge der Zeichen umkehren eine Queue behält die Reihenfolge der Zeichen

48 49 Palindrom Erkennung Algorithmus: Eingabe: Zeichenkette k durchlaufe k von links nach rechts füge dabei jedes Zeichen in Stack S (push) und Queue Q (enqueue) ein leere den Stack S (pop) und die Queue Q (dequeue) und vergleiche die Zeichen falls die Zeichen nicht gleich sind, ist k kein Palindrom ansonsten ist k Palindrom Ausgabe: k ist Palindrom oder nicht Zeichenkette k: RADAR Queue Q: Stack S: R A D A R R A D A R Anfang top

49 50 Implementation Queue Auch Queue ist abstrakter Datentyp. Implementation ist nicht festgelegt nur Operationen und Bedingungen sind festgelegt Queue kann auf viele Arten implementiert werden, zum Beispiel als: verkettete Liste sequentielle Liste

50 51 Implementation Queue als verkettete Liste Queue-Elemente speichern in verketteter Liste L Anfang der Queue wird durch anfang Referenz markiert Ende der Queue wird durch extra ende Referenz markiert anfang Daten Daten Daten Daten ende next next next next NULL enqueue(x) fügt Element bei ende Referenz ein dequeue() liefert Element bei anfang Referenz zurück und entfernt es

51 52 Implementation Queue als sequentielle Liste Queue-Element speichern in sequentieller Liste L (Länge n) Anfang der Queue wird durch Index anfang markiert Ende der Queue wird durch Index ende markiert n-1 n ende anfang enqueue(x) fügt Element bei Index ende+1 ein dequeue liefert Element bei Index anfang zurück und entfernt es durch Inkrement von anfang

52 53 Implementation Queue als sequentielle Liste 2 Problem: n-1 n ende anfang wird nach ein paar Operationen zu n-1 n ende anfang Linksdrift! Lösungsansatz: zirkuläre sequentielle Liste.

53 54 Implementation Queue als zwei Stacks Queue Q kann mittels zwei Stacks implementiert werden erster Stack inbox wird für enqueue benutzt: Q.enqueue(x) resultiert in inbox.push(x) zweiter Stack outbox wird für dequeue benutzt: falls outbox leer, kopiere alle Elemente von inbox zu outbox: outbox.push( inbox.pop() ) Q.dequeue liefert outbox.pop() zurück enqueue dequeue inbox outbox inbox outbox

54 55 Optional: Queues in C++ in der C++ Standard Library: std::queue<datatype> unterstützte Operationen: push (= enqueue) pop (= dequeue, liefert aber nichts zurück!) front back empty implementiert wahlweise als doppelt verkettete Liste als std::queue<datatype, std::list<datatype > std::dequeue (default, zerstückelte sequentielle Liste)

55 Optionales C++ Beispiel: Queue std :: queue < int > Q; // erstelle Queue Q if (Q. empty ()) std :: cout << " Queue Q ist leer." << std :: endl ; // fuege Elemente 1, 2, 3 hinzu Q. push (1); Q. push (2); Q. push (3); // gib vorderstes Element aus std :: cout << " front = " << Q. front () << std :: endl ; // entferne vorderstes Element Q. pop (); // gib vorderstes Element aus std :: cout << " front = " << Q. front () << std :: endl ; Ausgabe: Queue Q ist leer. front = 1 front = 2

56 57 Zusammenfassung Queue Queue ist abstrakter Datentyp als Metapher für eine Warteschlange wesentliche Operationen: enqueue, dequeue Implementation als verkettete Liste dynamische Größe, aber Platz für Referenzen verschwendet enqueue, dequeue sehr effizient Implementation als sequentielle Liste fixe Größe (entweder Speicher verschwendet oder zu klein) enqueue, dequeue sehr effizient Queue sehr schnell voll durch Linksdrift (ist aber durch zirkuläre sequentielle Liste lösbar)

57 58 Zusammenfassung 1 Einführung 2 Grundlagen von Algorithmen 3 Grundlagen von Datenstrukturen Primitive Datentypen und Zahldarstellung Felder als sequentielle Liste Zeichen und Zeichenfolgen Felder als verkettete Liste Abstrakte Datentypen Stacks Queues