Teneriffa Süd Abflug
Peter Klingebiel, DVZ Listen und dynamische Datenstrukturen Einfach verkettete Liste Problem: Strings einlesen, dynamisch in Liste speichern und ausgeben Ablauf: Datentyp für in einfach verketteter Liste gespeicherte Strings mit Zeilennummer und Zeilenlänge entwerfen, Strings bis EOF einlesen, dynamisch speichern und in Liste eingliedern, dann Liste/Strings mit Zeilennummer und Zeilenlänge ausgeben Aufgabe: Programm erstellen und testen Lösung: slist. c, mit Debugausgaben: slist-d. Dynamische Datenstrukturen — Grundkurs C 0.2.0d Dokumentation. c C-Quelle: slist. c Doppelt verkettete Liste Ablauf: Datentyp für in doppelt verketteter Liste gespeicherte Strings mit Zeilennummer und Zeilenlänge entwerfen, Strings bis EOF einlesen, dynamisch speichern und in Liste eingliedern, dann Liste/Strings mit Zeilennummer und Zeilenlänge vom Ende her ausgeben Lösung: dlist. c, mit Debugausgaben: dlist-d. c C-Quelle: dlist. c
node* createRoot(int data) if (root == NULL) return NULL; root->data = data; return root;} * Hängt am Ende an. Falls nicht der letzte Knoten übergeben wurde, wird das Ende gesucht. * Auf diese Weise kann man einen beliebigen Knoten übergeben. Es wird nicht geprüft, * ob die Daten bereits in der Liste sind. Wenn der erste Parameter NULL ist oder kein * Speicher angefordert werden kann gibt die Funktion NULL zurück. Im Erfolgsfall wird * der neue Knoten zurückgegeben. node* appendNode(node* oldtail, int data) if (oldtail == NULL) return NULL; node *newtail = malloc(sizeof(node)); if (newtail==NULL) return NULL; while (oldtail->next! Verkettete Listen sortieren in C | [HaBo]. = NULL) // ans Ende oldtail = oldtail->next; // nun ist oldtail->next NULL oldtail->next = newtail; newtail->prev = oldtail; newtail->next = NULL; newtail->data = data; return newtail;} * Gibt die Liste ab der Stelle root aus void printList(node* root) for (; root! = NULL; root = root->next) * Geht ans Ende und gibt die Liste rückwärts aus void printListReverse(node* curr) if (curr==NULL) return; for (; curr->next!
= NULL) abgefangen werden kann..
Verkettete Listen (Zeiger in Strukturen) Nächste Seite: Aufgaben Aufwärts: Pointer Vorherige Seite: Vektoren von Zeigern Inhalt Bevor wir in das Thema der dynamischen Datenstrukturen einsteigen, hier noch etwas neue C-Syntax: Gegeben sei struct note { int tonhoehe; double dauer;... }; Dann gibt es natuerlich auch: struct note * np; Wenden wir die bisher bekannten Syntagmen an, müßten wir, um an das Feld tonhoehe des Objektes zu kommen, auf das np zeigt, schreiben: (*np). tonhoehe Dafür gibt es in C eine Abkürzung: np -> tonhoehe Allgemein: p -> f bedeutet: Das Feld f der Struktur, auf die p zeigt. Kombinieren wur einiges, was wir bisher wissen, dann kommen wir zu ganz interessanten Datenstrukturen: Eine Zeigervariable kann ein Feld innerhalb einer Struktur sein. Eine Zeigervariable kann auf Strukturen zeigen. Einfach verkettete listen c span. Eine Zeigervariable als Feld einer Struktur kann auf eine Struktur gleichen Typs zeigen Strukturen können dynamisch alloziert werden. Damit können wir also deklarieren: struct item { struct item * next; int daten;}; struct list { struct item * start; struct item * end;}; und damit Datenstrukturen wie in Abb.
Da das letzte Element keinen Nachfolger hat, wird der Zeiger auf Null gesetzt, damit man später das Listenende erkennen kann. So eine Liste wird als einfach verkettet bezeichnet, da die Elemente untereinander nur eine 1-fache Verbindung haben. Es gibt auch eine doppelt verkettete Liste, aber dazu kommen wir später. Dynamische Datenstrukturen – Einfach verkettete Liste | virtual-maxim. Kommen wir zu der Implementierung. // Definition eines Listenelements struct Listenelement // Das sind die Daten die wir verwalten wollen (Datenbereich) Film film; // Zeiger auf den Nachfolger (Zeiger) Listenelement *nachfolger;}; Damit haben wir ein Listenelement definiert, auf dem wir unsere Liste aufbauen. Wie wir bereits wissen, beginnt die Liste mit einem Listenkopf, also erstellen wir dynamisch einen. // Listenkopf erstellen Listenelement *listenkopf = new Listenelement(); Da der Listenkopf auch ein Element der Liste ist müssen wir es auch mit Daten belegen. // Listenkopf mit Daten belegen listenkopf-> = "Stargate"; listenkopf-> = 2005; listenkopf-> = 1; // Den Zeiger auf Null setzen, da kein weiteres Element in der Liste existiert listenkopf->nachfolger = NULL; Nach dem der Listenkopf erstellt wurde, können weitere Listenelemente in die Liste eingefügt werden.
// aktueller Knoten Listenelement *p = kopf; // solange der Knoten nicht Null ist, also das Ende nicht erreicht ist... while(p! = NULL) //.. ausgeben std::cout << "Titel: "<< p->() << " Jahr: " << p-> << " Genre: " << p-> << std::endl; // der Nachfolger wird zum aktuellen Knoten p = p->nachfolger;}} Der Eifrige hat bereits den Code kompiliert und ausgeführt, doch das war ein etwas zu früh. Warum? Beim Erstellen eines neuen Elementes reservieren mit new Arbeitsspeicher und geben diesen nicht wieder frei. Doch das sollten wir, wenn wir nicht wollen, dass unser Computer wegen eines Arbeitsspeicherfehlers abstürzt. Also bauen wir uns eine Funktion, die die komplette Liste löscht und den reservierten Speicher wieder frei gibt. Einfach verkettete listen c.m. Wir müssen bedenken, dass wir mit dem letzten Element anfangen müssen und dann von hinten nach vorne alle Elemente nacheinander löschen sollten. Würden wir zum Beispiel von vorne anfangen und das erste dynamisch erzeugte Element löschen, würden wir die Adresse zum nächsten Element verlieren und könnten dieses dann nicht finden bzw. löschen.
= 2 && strcmp ( erstes_buch -> titel, titel) == 0) { ausgabe ( erstes_buch); printf ( "\nDieses Buch loeschen? Einfach verkettete listen c.h. \n"); printf ( "1 - Ja --- 2 - Nein\n"); if ( wahl == 1) { struct buecher * tempptr; tempptr = erstes_buch; //Falls noch weitere Buecher in der Liste existieren if ( erstes_buch -> naechstes! = NULL) { erstes_buch = erstes_buch -> naechstes; free ( tempptr);} //Falls das einzigste Buch geloescht wird else { free ( tempptr); return NULL;}}} ein_buch_weiter = erstes_buch -> naechstes; vorheriges_buch = erstes_buch; //Datensatz 2 bis n auf Aequivalenz mit $titel //pruefen und den Nutzer nach einer Loeschung //fragen while ( ein_buch_weiter! = NULL) { wahl = 2; if ( strcmp ( ein_buch_weiter -> titel, titel) == 0) { ausgabe ( ein_buch_weiter); //Falls ein Datensatz n geloescht wird //n-1->naeschstes auf n+1 zeigen lassen //und n loeschen (free()) vorheriges_buch -> naechstes = ein_buch_weiter -> naechstes; free ( ein_buch_weiter);}} //Liste durchlaufen ein_buch_weiter = ein_buch_weiter -> naechstes; //Vorheriges Buch auch in der Liste weiterlaufen lassen //falls Buch n nicht geloescht wurde if ( wahl!