Algorithmen und Datenstrukturen (für ET/IT)

Transkript

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

2 Programm 3 Elementare Datenstrukturen Zeichenfolgen Felder Stack Queue 2

3 Definition Datenstruktur Definition Datenstruktur (nach Prof. Eckert) Eine Datenstruktur ist eine logische Anordnung von Datenobjekten, die Informationen repräsentieren, den Zugriff auf die repräsentierte Information über Operationen auf Daten ermöglichen und die Information verwalten. Zwei Hauptbestandteile: Datenobjekte z.b. definiert über primitive Datentypen Operationen auf den Objekten z.b. definiert als Funktionen 3

4 Primitive Datentypen in C, C++ Natürliche Zahlen, z.b. unsigned short, unsigned long Wertebereich: bei n Bit von 0 bis 2 n 1 Operationen: +, -, *, /, %, <, ==,!=, > Ganze Zahlen, z.b. int, long Wertebereich: bei n Bit von 2 n 1 bis 2 n 1 1 Operationen: +, -, *, /, %, <, ==,!=, > Floating Point Zahlen, z.b. double, float Wertebereich: abhängig von Größe Operationen: +, -, *, /, <, ==,!=, > Logische Werte, bool Wertebereich: true, false Operationen: &&,,!, ==,!= Was ist mit Zeichen und Zeichenfolgen? 4

5 Bits und Bytes Bit 7 Bit 0 1 Byte = 8 Bit Bytes als Maßeinheit für Speichergrössen: 2 10 Bytes = 1024 Bytes = 1 kb, ein kilo Byte (großes B) 2 20 Bytes = 1 MB, ein Mega Byte 2 30 Bytes = 1 GB, ein Giga Byte 2 40 Bytes = 1 TB, ein Tera Byte 2 50 Bytes = 1 PB, ein Peta Byte 2 60 Bytes = 1 EB, ein Exa Byte Hinweis: auch Bits werden als Maßangabe verwendet, z.b. 16 Mbit oder 16 Mb (kleines b). 5

6 Bytes und ASCII Interpretation eines Bytes als Zeichen (anstatt Zahlen) z.b. ASCII Code 7 Bit ASCII Code: Code A..B..C..D..E..F 0.. nul soh stx etx eot enq ack bel bs ht lf vt ff cr so si 1.. dle dc1 dc2 dc3 dc4 nak syn etb can em sub esc fs gs rs us 2.. sp! # $ % & ( ) * +, -. / : ; < = >? A B C D E F G H I J K L M N O 5.. P Q R S T U V W X Y Z [ \ ] ˆ 6.. a b c d e f g h i j k l m n o 7.. p q r s t u v w x y z { } del 6

7 ASCII Erweiterungen, Unicode ASCII verwendet nur 7 Bit von einem Byte enthält z.b. keine Umlaute (ä, ö, ü) oder Akzente (é, ç) es gibt verschiedene Erweiterungen von ASCII auf 8 Bit in Europa ist ISO Latin-1 verbreitet (ISO Norm ) belegt die Codes von (bzw. 80-FF in hex) Unicode wurde als 16 Bit Codierung eingeführt erste 128 Zeichen stimmen mit ASCII überein die nächsten 128 Zeichen mit ISO Latin-1 danach z.b. kyrillische, arabische, japanische Schriftzeichen UTF-8 ist eine Mehrbyte-Codierung von Unicode (1-6 Bytes) Code-Länge wird durch die ersten Bits codiert 7

8 Zeichen und Strings Repräsentation eines ASCII Zeichens in C, C++: char Zeichen-Literale in einfachen Anführungszeichen Beispiele: A, u, D char zeichen = A ; Vorsicht bei nicht-ascii Zeichen! Repräsentation einer Zeichenfolge? (Englisch: String) String-Literale in doppelten Anführungszeichen Beispiel: AuD in C gespeichert als Folge von Zeichen, terminiert durch \0 'A' 'u' 'D' '\0' 8

9 Strings in C Strings in C: dargestellt als Array von chars fester Länge: char test_ string [8]; C Arrays werden indiziert von 0! (hier also von 0 bis 7) immer genug Platz für terminierendes \0 einplanen! dargestellt als Array von chars dynamischer Länge (mittels Pointer): char * test_ string ; Speicher muss explizit über malloc/free angefordert/freigegeben werden! Größe des Arrays komplett in eigener Verantwortung! sehr fehleranfällig, bitte vermeiden wenn möglich! 9

10 Programm: Strings in C # include <stdio.h> # include < string.h> int main () { char test_ string [5] = " test "; // Laenge ist 4+1 printf (" test_string : %s\n", test_string ); char AuD_ string [4]; AuD_ string [0] = A ; AuD_ string [1] = u ; AuD_ string [2] = D ; AuD_ string [3] = \0 ; // terminierende 0 printf (" AuD_string : %s\n", AuD_string ); printf (" Laenge : %lu\n", strlen ( AuD_string ) ); } return 0; 10

11 Strings in C - Operationen Operationen auf C Strings: definiert in string.h strlen(str): liefert Länge des Strings str strcpy(ziel, quelle): kopiert String quelle nach ziel ziel wird als groß genug vorausgesetzt! strcat(ziel, quelle): hängt String quelle an String ziel hinten an ziel wird als groß genug vorausgesetzt! strcmp(str1, str2): vergleicht die Strings str1 und str2 ist das Ergebnis 0, sind die Strings gleich 11

12 Programm: Strings in C (Fortsetzung) # include <stdio.h> # include < string.h> int main () { char test_string [] = " test "; char AuD_string [] = " AuD "; char resultat_ string [20]; // gross genug strcpy ( resultat_string, AuD_ string ); printf (" strcpy Ergebnis : %s\n", resultat_string ); int vergleich = strcmp ( resultat_ string, AuD_ string ); printf (" strcmp Ergebnis : %d\n", vergleich ); strcat ( resultat_string, test_ string ); printf (" strcat Ergebnis : %s\n", resultat_string ); } return 0; 12

13 Strings in C - Probleme Probleme mit C Strings: terminierende \0 wird vergessen Zuweisung nach Initialisierung schwierig Größenvoraussetzungen werden nicht automatisch geprüft Verwaltung von Strings dynamischer Länge eine Quelle der häufigsten Programmierfehler aber gerade Strings dynamischer Länge werden gebraucht! 13

14 Strings in C++ Strings in C++: dargestellt als std::string std :: string test_ string ; Zugriff wie bei C Strings über [] Operator, indiziert von 0 std :: string test_string = " test "; test_ string [1] = a ; automatische Verwaltung der Größe nicht terminiert mit \0, sondern speichert Größe direkt Operationen direkt in std::string eingebaut 14

15 Programm: Strings in C++ # include < iostream > # include < string > using namespace std ; int main () { string test_ string = " test "; cout << " test_ string : " << test_ string << endl ; string AuD_ string = " BvE "; AuD_ string [0] = A ; AuD_ string [1] = u ; AuD_ string [2] = D ; cout << " AuD_ string : " << AuD_ string << endl ; cout << " Laenge : " << AuD_ string. length () << endl ;... 15

16 Programm: Strings in C++ (Fortsetzung)... string resultat_ string ; resultat_ string = AuD_ string ; cout << " Kopieren : " << resultat_ string << endl ; bool vergleich = ( resultat_ string == AuD_ string ); cout << " Vergleich : " << vergleich << endl ; resultat_ string = resultat_ string + test_ string ; // oder kuerzer : // resultat_ string += test_ string ; cout << " Anhaengen : " << resultat_ string << endl ; } return 0; 16

17 Programm 3 Elementare Datenstrukturen Zeichenfolgen Felder Stack Queue 17

18 Definition Feld Definition Feld Ein Feld A ist eine Folge von n Datenelementen (d i ) i=1,...,n, mit n N 0. A = d 1, d 2,..., d n Die Datenelemente d i sind beliebige Datentypen (z.b. primitive). Beispiele: A sind die natürlichen Zahlen von 1 bis 10, aufsteigend geordnet: A = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 Ist n = 0, so ist das Feld leer. 18

19 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] 19

20 Beispiel sequentielle Liste Feld A=0,8,15, Länge 3 Beispiel in C: int A [3]; A [0] = 0; A [1] = 8; A [2] = 15; Beispiel in C++: std :: vector <int > A (3); A [0] = 0; A [1] = 8; A [2] = 15; 20

21 Eigenschaften sequentielle Liste Feld A mit Länge n als sequentielle Liste (Array) Vorteile: direkter Zugriff auf Elemente in konstanter Zeit mittels A[i] sequentielles Durchlaufen sehr einfach Nachteile: Verschwendung von Speicher falls Liste nicht voll belegt Verlängern der sequentiellen Liste sehr aufwendig Hinzufügen und Löschen von Elementen sehr aufwendig 21

22 C Beispiel: sequentielles Durchlaufen Code: Ausgabe: int felda [5]; int i; // sequentielles Durchlaufen printf (" felda : "); for ( i = 0; i < 5; ++ i) { felda [ i] = i * i; printf ("%d ", felda [i ]); } printf ("\n"); felda :

23 Verlängern der sequentiellen Liste Gegeben: Feld A, Länge n+1, als sequentielle Liste Gewünscht: Feld A erweitert auf Länge n+2 neuen Speicher der Größe n+2 reservieren alte Liste in neuen Speicher kopieren... Feld A: A[n] A[n-1] A[2] A[1] A[0] neues Feld A: A[n+1] A[n] A[n-1]... A[2] A[1] A[0] 23

24 C Beispiel: Verlängern der Liste Code: int neuesfelda [6]; // altes Feld kopieren : for ( i = 0; i < 5; ++ i) neuesfelda [i] = felda [i]; // neues Element : neuesfelda [5] = 25; Ausgabe: // neuesfelda ausgeben : printf (" neuesfelda nach Verlaengern : "); for ( i = 0; i < 6; ++ i) printf ("%d ", neuesfelda [i ]); printf ("\n"); neuesfelda nach Verlaengern :

25 Löschen von Element aus Liste Gegeben: Feld A, Länge n, als sequentielle Liste Gewünscht: Element i aus Feld A löschen Element i entfernen Listenelemente nach i umkopieren

26 C Beispiel: Löschen von Element Code: Ausgabe: // loesche erstes Element for ( i = 1; i < 6; ++ i) neuesfelda [i -1] = neuesfelda [ i]; // setze letztes Element auf -1 neuesfelda [5] = -1; // neuesfelda ausgeben : printf (" neuesfelda nach Loeschen : "); for ( i = 0; i < 6; ++ i) printf ("%d ", neuesfelda [i ]); printf ("\n"); neuesfelda nach Loeschen :

27 Einfügen von Element in Liste Gegeben: Feld A, Länge n, als sequentielle Liste Gewünscht: neues Element in Feld A an Stelle i einfügen Listenelemente nach i umkopieren Element i einfügen

28 C Beispiel: Einfügen von Element Code: Ausgabe: // neues Element (8) an 3. Stelle einfuegen for (i = 5; i > 2; --i) neuesfelda [ i] = neuesfelda [i -1]; neuesfelda [2] = 8; // neuesfelda ausgeben : printf (" neuesfelda nach Einfuegen : "); for ( i = 0; i < 6; ++ i) printf ("%d ", neuesfelda [i ]); printf ("\n"); neuesfelda nach Einfuegen :

29 C++ Beispiel: sequentielle Listen Code: vector <int > felda (5); // sequentielles Durchlaufen for ( int i = 0; i < 5; ++ i) { felda [ i] = i * i; } // Verlaengern der Liste felda. resize (6); felda [5] = 25; // loesche erstes Element felda. erase ( felda. begin () ); felda [5] = -1; // neues Element (8) an 3. Stelle einfuegen felda. insert ( felda. begin () + 2, 8); 29

30 Operationen auf sequentiellen Listen Sei A sequentielle Liste. Operationen: initialize: Initialisiere seq. Liste A mit n Elementen destruct: vernichte seq. Liste A elementat(i): greife auf i-tes Element von A zu: 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]

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

32 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: Zeiger auf das nächste Element d i+1 Node: Daten next start ist Zeiger auf erstes Element des Feldes d 1 letztes Element d n hat keinen Nachfolger symbolisiert durch NULL-Zeiger 32

33 Operationen auf verketteter Liste Zugriff auf Element i: beginne bei start Zeiger vorhangeln entlang next Zeigern bis zum i-ten Element Beispiel für i=3: start Daten Daten Daten Daten next next next next NULL Hilfszeiger 33

34 Operationen auf verketteter Liste Löschen von Element i: Zugriff auf Element i-1 umhängen von next Zeiger von Element i-1 auf Element i+1 Beispiel für i=3: start Daten Daten Daten Daten next next next next NULL Hilfszeiger 34

35 Operationen auf verketteter Liste Einfügen von Element an Stelle i: Zugriff auf Element i-1 umhängen von next Zeiger von Element i-1 auf neues Element next Zeiger von neuem Element setzen auf altes Element i Beispiel für i=3: start Daten Daten Daten Daten next next next next NULL Hilfszeiger Daten neues Element next 35

36 Verkettete Liste in C (Auszug) // Datenstruktur fuer verkettete Liste struct node { struct node * next ; int Daten ; }; // Funktion zum Anlegen eines Nodes struct node * initnode ( int daten ); // Funktion zum Freigeben einer Liste void destructlist ( struct node * anfang ); // Funktion zur Listenausgabe void printlist ( struct node * anfang ); 36

37 Verkettete Liste in C (Auszug) struct node * start = NULL ; // Startknoten der Liste struct node * hilfszeiger ; // Hilfsvariablen int i; // Liste fuellen start = initnode (0); start - > next = NULL ; // Listenende markieren hilfszeiger = start ; for ( i = 1; i <= 5; ++ i) { hilfszeiger -> next = initnode (i*i); hilfszeiger = hilfszeiger - > next ; hilfszeiger - > next = NULL ; // neues Ende der Liste } printlist ( start ); // Liste durchlaufen und ausgeben destructlist ( start ); // Liste freigeben start = NULL ; // und wirklich als leer markieren 37

38 Verkettete Liste in C (Auszug) // Funktion zum Anlegen eines Nodes struct node * initnode ( int daten ) { struct node * ptr ; // neuen Knoten anlegen ptr = ( struct node *) malloc ( sizeof ( struct node ) ); if ( ptr == NULL ) { // falls malloc fehlgeschlagen //!! ACHTUNG!! // hier braeuchten wir Fehlerbehandlung! // machen wir hier der Einfachheit halber nicht } // Daten zuweisen ptr -> Daten = daten ; } return ptr ; 38

39 Verkettete Liste in C (Auszug) // Funktion zum Freigeben einer Liste void destructlist ( struct node * anfang ) { struct node * ptr ; // Hilfsvariablen struct node * temp ; } // Liste durchlaufen und freigeben ptr = anfang ; while ( ptr!= NULL ) { temp = ptr - > next ; // Nachfolger in temp speichern free ( ptr ); // aktuellen Knoten freigeben ptr = temp ; // zum naechsten Knoten } 39

40 Verkettete Liste in C (Auszug) // Funktion zur Listenausgabe void printlist ( struct node * anfang ) { struct node * ptr ; // Hilfsvariable printf (" Listen - Inhalt : "); } // Liste durchlaufen von anfang ptr = anfang ; while ( ptr!= NULL ) { printf ("%d ", ptr -> Daten ); // Wert ausgeben ptr = ptr - > next ; // zum naechsten Knoten } printf ("\n"); 40

41 Verkettete Liste in C++ (Auszug) std :: list < int > feld ; // Liste initialisieren // Iterator it als Hilfs " zeiger " auf Listenelemente std :: list <int >:: iterator it; // Liste fuellen for ( int i = 5; i >= 0; --i) feld. push_front (i*i); // push_ front fuegt Element am Anfang ein // alternativ : feld. insert ( feld. begin (), i*i); // Liste durchlaufen und ausgeben std :: cout << " Listen - Inhalt : "; for (it = feld. begin (); it!= feld. end (); ++ it) std :: cout << *it << " "; // * it gibt das Datenelement von Listeneintrag // an Stelle it aus std :: cout << std :: endl ; 41

42 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 42

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

44 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: Zeiger auf das nächste Element d i+1 prev: Zeiger auf das vorherige Element d i 1 Node: prev Daten next start/stop sind Zeiger auf erstes/letztes Element des Feldes 44

45 Operationen auf doppelt verketteter Liste Löschen von Element i: Zugriff auf Element i umhängen von next Zeiger von Element i-1 auf Element i+1 umhängen von prev Zeiger 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 45

46 Operationen auf doppelt verketteter Liste Einfügen von Element an Stelle i: Zugriff auf Element i umhängen von next Zeiger von Element i-1 auf neues Element, sowie umhängen von prev Zeiger von altem Element i auf neues Element next bzw. prev Zeiger 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 46

47 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 Zeiger Zeigerverwaltung komplizierter und fehleranfällig 47

48 Doppelt verkettete Liste in C und C++ in C: struct node { int Daten ; struct node * prev ; struct node * next ; }; struct node * start ; struct node * stop ; in C++: std :: list <int > feld ; 48

49 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 49

50 Programm 3 Elementare Datenstrukturen Zeichenfolgen Felder Stack Queue 50

51 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). 51

52 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) 52

53 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 53

54 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 54

55 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) 55

56 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) 56

57 Anwendungsbeispiele Stack Call-Stack bei Funktionsaufrufen (s. Übung vom ) Auswertung arithmetischer Ausdrücke (s. nächste Folie) 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 57

58 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 ( bei = steht das Ergebnis im obersten Stack-Element von S 58

59 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 60

60 Implementation Stack als sequentielle Liste Stack-Elemente speichern in sequentieller Liste A 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 61

61 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 62

62 Code-Beispiel: Stack als sequentielle Liste int stack [20]; // fixe Groesse! int top ; void initialize () { top = -1; } void push ( int x) { ++ top ; // keine Fehlererkennung falls zu gross! stack [ top ] = x; } int pop () { int wert = stack [ top ]; -- top ; // keine Fehlererkennung falls Stack leer! return wert ; } 63

63 Implementation Stack als verkettete Liste Stack-Elemente speichern in verketteter Liste L oberstes Stack-Element wird durch start Zeiger 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 64

64 Stacks in C++ in der C++ Standard Library: std::stack<datatype> unterstützte Operationen: push pop (liefer 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) 65

65 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 66

66 Programm 3 Elementare Datenstrukturen Zeichenfolgen Felder Stack Queue 67

67 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 68

68 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 69

69 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 70

70 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 71

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

72 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 73

73 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 74

74 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 75

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

76 Implementation Queue als sequentielle Liste Queue-Element speichern in sequentieller Liste L 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 77

77 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. 78

78 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 79

79 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) 80

80 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 Zeiger 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) 81

81 Zusammenfassung 3 Elementare Datenstrukturen Zeichenfolgen Felder Stack Queue 82