Listen. Arrays. Deklaration. Einfach verkettete Listen

Transkript

1 Arrays Bisher Listen von Daten in Arrays gespeichert type* array = malloc(n*sizeof(type)); dyn. Verlängern und Kürzen am Ende möglich array = realloc(array,nnew); Zugriff auf j-ten Eintrag (Lesen/Schreiben) array[j] Listen einfach verkettete Listen doppelt verkettete Listen Nachteile: Ggf. Speicher kopieren beim Verlängern Worst case: N N +1, aber O(N) Operat. Effizientes Verlängern (Einfügen) nur am Ende sonst Umkopieren nötig Beispiel: Vektor x R N Füge an k-ter Stelle einen neuen Wert ein d.h. Vektor auf Länge N +1 verlängern und umkopieren der Werte x k,...,x N d.h. N +1 k Werte werden umkopiert Mittlerer Aufwand für Umkopieren 1 N (N +1 k) = O(N) N +1 k=1 analog beim Streichen von Einträgen wieder Umkopieren im Mittel O(N) Deklaration Einfach verkettete Listen Mittels struct kann man Datentyp für Listen bauen Idee dahinter: Jedes Listenelt. hat Inhalt (entspricht array[j]) und kennt seinen Nachfolger (mittels Pointer) Vorteil: Kann Liste am ersten Elt. mit Aufwand O(1) verlängern/kürzen Kann nach einem Elt. ein neues in Aufwand O(1) einfügen Nachteil: Kann auf j-tes Element nicht direkt zugreifen muss Liste ablaufen, d.h. O(j) für j-tes Elt. Kann kein mittleres Elt. effizient streichen müßte dazu Vorgänger abändern also Liste ablaufen, d.h. O(j) für j-tes Elt. Anwendung: Datenstapel (engl. stack) LIFO = last in, first out 1 struct _Node_ { 3 struct _Node_* next; 4 }; 5 typedef struct _Node_ Node; 6 7 typedef struct _List_ { 8 int length; 9 Node* first; 10 } List; Inhalt content kann beliebiger Datentyp sein hier nur als Beispiel int Beachte: struct Node * Pointer auf struct Node keine Klammern setzen, weil sonst Type Cast! keine bessere Schreibweise möglich! Member length is Luxus und eigentlich unnötig! 1 typedef struct _Node_ { 3 Node* next; 4 } Node; 5 6 typedef struct _List_ { 7 int length; 8 Node* first; 9 } List; Fehler, da Datentyp Node in Zeile 3 noch nicht def!

2 Anlegen & Freigeben 1 struct _Node_ { 3 struct _Node_* next; 4 }; 5 typedef struct _Node_ Node; 6 7 typedef struct _List_ { 8 int length; 9 Node* first; 10 } List; List* newlist() { 13 List* list = malloc(sizeof(list)); 14 list->length = 0; 15 list->first = NULL; 16 return list; 17 } List* dellist (List* list) { 20 Node* node = list->first; 21 Node* next = NULL; 22 while (node!= NULL) { 23 next = node->next; 24 free(node); 25 node = next; 26 } 27 free(list); 28 return NULL; 29 } Einfügen/Löschen eines Elements 1 // insert new element after existing one 2 insertafter(node* node, int content){ 3 Node* new_node = malloc(sizeof(node)); 4 new_node->content = content; 5 new_node->next = node->next; 6 node->next = new_node; 7 } 8 9 // add new first element to list 10 void pushlist(list* list, int content) { 11 Node* new_node = malloc(sizeof(node)); 12 new_node->content = content; 13 new_node->next = list->first; 14 list->first = new_node; 15 ++(list->length); 16 } // del first elt from list and return its content 19 int poplist(list* list) { 20 Node* old_first = list->first; 21 int content = old_first->content; 22 list->first = old_first->next; 23 free(old_first); 24 --(list->length); 25 return content; 26 } Verlängern einer Liste durch Einfügen eines neuen Elt. mit Aufwand O(1), wenn Vorgänger bekannt Kürzen einer Liste durch Löschen des ersten Elt. mit Aufwand O(1) Ausgeben einer Liste Sortiertes Einfügen 1 void insertsorted(list* list, int new_content) { 2 Node* node = list->first; 3 Node* next = NULL; 4 if (node!= NULL) { 5 while (node->next!= NULL) { 6 next = node->next; 7 if (node->content < new_content) { 8 if (next!= NULL) { 9 if (next->content >= new_content) { 10 break; 11 } 12 } 13 } 14 node = next; 16 insertafter(node,new_content); 17 ++(list->length); 18 } 19 else { 20 pushlist(list,new_content); 21 } 22 } generischer Aufwand O(N) für Liste der Länge N 1 void printlist(list* list) { 2 int j = 0; 3 Node* node = list->first; 4 5 printf("length = %d\n",list->length); 6 while (node!= NULL) { 7 printf("%d: %d\n",j,node->content); 8 node = node->next; 9 j++; 10 } 11 } main() { 14 List* list = newlist(); 15 int tmp = 0; pushlist(list,0); 18 pushlist(list,1); 19 pushlist(list,2); 20 pushlist(list,3); 21 pushlist(list,4); tmp = poplist(list); printlist(list); 26 printf("tmp = %d\n",tmp); dellist(list); 29 } Inhalt der Liste: 3,2,1,0 tmp hat den Wert

3 Doppelt verkettete Listen bisher nur Bewegung durch Liste in eine Richtung kann z.b. einfach verkettete Listen mit Bubble-Sort sortieren MinSort schon schwerer wegen Vertauschen (dennoch möglich mit Hilfsvariablen) Vorwärtsausgabe hat Aufwand O(N) Rückwärtsausgabe hat Aufwand O(N 2 ) Wenn Bewegungen in beiden Richtungen nötig, kann man doppelt verkettete Liste machen Jedes Listenelt. hat Inhalt (entspricht array[j]) kennt seinen Nachfolger (mittels Pointer) kennt seinen Vorgänger (mittels Pointer) Vorteil: Kann Liste bei jedem Elt. vorher und nachher mit Aufwand O(1) verlängern/kürzen Nachteil: Kein direkter Zugriff auf j-tes Element wie bei einfach verketteter Liste Deklaration 1 struct _Node_ { 3 struct _Node_* prev; 4 struct _Node_* next; 5 }; 6 typedef struct _Node_ Node; 7 8 typedef struct _List_ { 9 int length; 10 Node* first; 11 Node* last; 12 } List; Jedes Element kennt Vorgänger und Nachfolger Datentyp für content kann beliebig sein Liste hat zwei ausgezeichnete Elte (erstes, letztes) Member length ist Luxus und eigentlich unnötig! Anlegen & Löschen einer Liste 1 struct _Node_ { 3 struct _Node_* prev; 4 struct _Node_* next; 5 }; 6 typedef struct _Node_ Node; 7 8 typedef struct _List_ { 9 int length; 10 Node* first; 11 Node* last; 12 } List; List* newlist() { 15 List* list = malloc(sizeof(list)); 16 list->length = 0; 17 list->first = NULL; 18 list->last = NULL; 19 return list; 20 } List* dellist(list* list) { 23 Node* node = list->first; 24 Node* next = node; while (node!= NULL) { 27 next = node->next; 28 free(node); 29 node = next; 30 } 31 free(list); 32 } Push & Pop am Listenanfang 1 // add new first element to list 2 void pushfront(list* list, int content) { 3 Node* new_node = malloc(sizeof(node)); 4 new_node->content = content; 5 new_node->prev = NULL; 6 new_node->next = list->first; 7 if (list->first!= NULL) { 8 list->first->prev = new_node; 9 } 10 else { 11 list->last = new_node; 12 } 13 list->first = new_node; 14 ++(list->length); // del first elt from list and return its content 18 int popfront(list* list) { 19 Node* old_first = list->first; 20 int content = old_first->content; 21 list->first = old_first->next; 22 list->first->prev = NULL; 23 free(old_first); 24 if (list->first == NULL) { 25 list->last == NULL; 26 } 27 --(list->length); 28 return content; 29 }

4 Push & Pop am Listenende 1 // add new last element to list 2 void pushback(list* list, int content) { 3 Node* new_node = malloc(sizeof(node)); 4 new_node->content = content; 5 new_node->prev = list->last; 6 new_node->next = NULL; 7 if (list->last!= NULL) { 8 list->last->next = new_node; 9 } 10 else { 11 list->first = new_node; 12 } 13 list->last = new_node; 14 ++(list->length); // del last elt from list and return its content 18 int popback(list* list) { 19 Node* old_last = list->last; 20 int content = old_last->content; 21 list->last = old_last->next; 22 list->last->next = NULL; 23 free(old_last); 24 if (list->last == NULL) { 25 list->first == NULL; 26 } 27 --(list->length); 28 return content; 29 } Ausgabe Rückwärts 1 void printlist(list* list) { 2 Node* node = list->last; 3 int j = list->length -1; 4 printf("length = %d\n",list->length); 5 while (node!= NULL) { 6 printf("%d: %d\n",j,node->content); 7 node = node->prev; 8 j--; 9 } 10 } main() { 13 List* list = newlist(); pushfront(list,0); 16 pushfront(list,1); 17 pushfront(list,2); pushback(list,3); 20 pushback(list,4); 21 pushback(list,5); printlist(list); 24 } Inhalt der Liste: 2, 1, 0, 3, 4, 5 O(N 2 ) bei einfach verketteter Liste Was ist C++ C++ Was ist C++ Datenkapselung Hello World! mit C++ string Eine Weiterentwicklung von C Verwendung neuer Programmierparadigmen (siehe auch nächste VO) Objektorientierte Programmiersprache (OOP) Objekte stehen im Vordergrund bei OOP Reale Objekte als Software Objekte abgebildet Zusammenfassung von Daten und Funktionen zu Objekten Realisierung mittels Klassen in C++ Datenkapselung! Kein direkter Zugriff auf Daten Erfolgt über Schnittstellen

5 Good to know C++ ist eine höhere Programmiersprache Entwicklung ab 1979 bei AT&T Entwickler: Bjarne Stroustrup Erweiterung von C Einführung eines Klassenkonzeptes (C with classes) Abwärtskompatibel (zu C) keine Syntaxkorrektur Heute: voll objektorientiert ISO genormt Inspiration für andere Sprachen C#, Java Compiler: g++, gpp frei verfügbar Microsoft Visual C++ Compiler Borland C++ Compiler Was kann mir helfen? Endlose Anzahl an Büchern Die C++ Programmiersprache Jetzt lerne ich C++ C++ in 21 Tagen C++ für C Programmierer Online Tutorien einfach googeln C++ API C++ Befehlsreferenz Entwicklungsumgebungen engl. Integrated Development Environment (IDE) Hello World 1 #include <iostream> 2 3 int main() { 4 std::cout << "Hello World!\n"; 5 return 0; 6 } Speichern unter helloworld.cpp Compilieren mittels g++ helloworld.cpp Ausgabe: Hello World! Standardbibliothek für Ein- und Ausgabe in C++ heißt iostream cout ist der Standard-Ausgabestream kann unterschiedliche Datentypen übernehmen Scope-Operator :: deklariert den Namensbereich Operator übergibt sein zweites Argument an den Ausgabestream main hat Rückgabewert int 1 #include <iostream> 2 using namespace std; 3 4 int main() { 5 cout << "Hello World!\n"; 6 return 0; 7 } Zeile 2: Bereich std wird durchgehend benutzt Mehr zu namespace später Datentyp string 1/2 1 #include <iostream> 2 #include <string> 3 using namespace std; 4 5 int main() { 6 string str1 = "Hallo"; 7 string str2 = "Welt"; 8 string str3 = str1 + " " + str2; 9 10 cout << str3 << "!\n"; 11 str3.replace(6,4, "Peter"); 12 cout << str3 << "!\n"; return 0; Ausgabe: Hallo Welt! Hallo Peter! Strings sind mächtiger als char* liefert eine Reihe nützlicher Operationen + zur Konkatenation replace zum ersetzen von Teilstrings substr zum auslesen von Teilstrings length zum auslesen der Länge u.v.m. Datentypen können Methoden haben Prinzip der Datenkapselung Sie enthalten mehr als nur die Zeichen (Unterschied zu C)

6 Datentyp string 2/2 1 #include <iostream> 2 #include <string> 3 #include <stdio.h> 4 using namespace std; 5 6 int main() { 7 string str1 = "Hallo"; 8 string str2 = "Welt"; 9 string str3 = str1 + " " + str2; printf("%s\n", str3.c_str()); 12 cout << str3 << endl; return 0; Ausgabe: Hallo Welt Hallo Welt Inhalt mittels c str() erreichbar Das sind die bekannten char-arrays aus C Zugriff über name.c str() können mittels printf ausgegeben werden Klassen Was sind Klassen Objekte Klassen und Strukturen Wichtig: string char-array Zeile 3: Kann auch #include <cstdio> verwenden um C-Standardbibiliotheken einzubinden Zeile 12: Zeilenumbruch mit endl Beispiel Was sind Klassen Klassen sind benutzerdefinierte Datentypen Verwendung völlig analog zu int, string Klassen erweitern struct aus C erlauben Methoden (Funktionen) Klassen erlauben das Prinzip der Datenkapselung Code wird besser wiederverwendbar black-box-implementierung möglich Klassen sind Schablonen für Objekte Klassen sind der Grundbaustein zur OO Beschreiben Attribute und Methoden, also Verhaltensweisen, der Objekte 1 #include <string> 2 using namespace std; 3 4 class Student { 5 string name; 6 string studiengang; 7 int matrikelnummer; 8 9 void lernen(); 10 void testschreiben(); 11 }; Deklaration mit Schlüsselwort class enthält Daten (members) analog zu struct aus C enthält Funktionen (Methoden) erlaubt es komplette Objekte abzubilden Strichpunkt nach Deklaration zu Namenskonvention: C++ ist case sensitive Groß- und Kleinschreibung beachten Klassen (Coding Standard) AlleWorteCapitalizedOhneUnderlines Methoden, Funktionen und Variablen ersteswortkleinrestcapitalizedohneunderlines

7 Objekte Zugriffskontrolle Objekte sind Instanzen einer Klasse Sie sind die tatsächlichen Variablen werden angelegt wie bei primitiven Typen entsprechen Variablen vom struct Datentyp Student Marcus; int x; Zugriff auf Klassenelemente mit Punktoperator (.) Marcus.name = "Marcus Page"; Marcus.lernen(); Achtung: Zugriff muss erlaubt sein sonst Fehlermeldung von Compiler Achtung: An Objekte zuweisen, nicht an Klassen int = 5; Student = "Marcus Page"; // Fehler // Fehler Klassen und Objekte dienen der Abstraktion genaue Implementierung nicht wichtig zum Beispiel durch Bibliotheken Benutzer soll so wenig wissen wie möglich black-box Programmierung nur Ein- und Ausgabe müssen bekannt sein Richtiger Zugriff muss sichergestellt werden Schlüsselwörter private, public, und protected private (Standard) Zugriff nur von Methoden der gleichen Klasse public erlaubt Zugriff von überall protected teilweiser Zugriff von außen (später) class Dreieck { 2 private: 3 double x[2]; 4 double y[2]; 5 double z[2]; 6 7 public: 8 double flaeche(); 9 }; Beispiel Dreieck in R 2 mit Eckpunkten x,y,z Benutzer kann Funktion flaeche aufrufen Benutzer kann Daten x,y,z nicht direkt verändern get/set Funktionen in public-bereich einbauen Benutzer muss nicht wissen wie Daten intern verwaltet werden Kann interne Datenstruktur später verändern Dreieck kann auch durch einen Punkt und zwei Vektoren abgespeichert werden Beispiel 2 1 #include <string> 2 using namespace std; 3 4 class Student { 5 private: // Kann auch weggelassen werden 6 string studiengang; 7 8 public: // Ab hier alle Members public! 9 string name; 10 int matrikelnummer; 11 void lernen(); 12 void testschreiben(); 13 }; int main() { 16 Student Marcus; 17 Marcus.name = "Marcus Page"; 18 Marcus.matrikelnummer = ; 19 Marcus.studiengang = "Mathematik"; 20 } Fehler in Zeile 19: std::string Student::studiengang is private

8 Klassenmethoden implementieren 1 class Student { 2 public: 3 string name; 4 int matrikelnummer; 5 void lernen(); 6 void testschreiben(); 7 }; 8 9 void Student::lernen() { 10 cout << "oh mann..." << endl; 11 } void Student::testSchreiben() { 14 cout << "geschafft!" << endl; int main() { 18 Student Marcus; 19 Marcus.lernen(); 20 Marcus.testSchreiben(); 21 } Ausgabe: oh mann... geschafft! Implementierung wie bei anderen Funktionen Zugehörigkeit zur Klasse durch (::) Student :: testschreiben() Deklaration auch in Header-Datei möglich (nächste VO) Klassen und Strukturen Struktur: Zusammenfassung elementarer Datentypen (wie int,double) zu einem Gesamtdatentyp Können von Funktionen manipuliert werden Klasse: Enthält neben den Daten auch noch Methoden, welche diese manipulieren Realisierung von Strukturen in C mit struct Keine Funktionen in Struktur erlaubt Realisierung von Klassen in C++ mit class ACHTUNG: struct in C struct in C++ struct in C++ wie class, nur sind alle Members standardmäßig public!