Übungspaket 32 Einfach verkettete, sortierte Liste

Transkript

1 Übungspaket 32 Einfach verkettete, sortierte Liste Übungsziele: Skript: 1. Aufbau einer einfach verketteten, sortierten Liste 2. Traversieren von Listen 3. Vereinfachung durch ein Dummy-Element Kapitel: 75 und insbesondere Übungspaket 29 und 31 Semester: Wintersemester 2015/16 Betreuer: Matthias, Kevin und Ralf 2 Synopsis: In diesem Übungspaket werden wir endlich eine einfach verkettete, sortierte Liste programmieren. Dabei orientieren wir uns an der in der Vorlesung vorgestellten Wirth schen Variante, die das Programmieren deutlich vereinfacht. Da das Programmieren sortierter Listen erst mal recht komplex ist, werden wir die wesentlichen Aspekte wiederholen bzw. gezielt darauf hin arbeiten. Also, nicht verzweifeln, sondern einfach probieren...

2 Teil I: Stoffwiederholung Aufgabe 1: Allgemeine Fragen zu Listen Erkläre mit eigenen Worten, was eine einfach verkettete, sortierte Liste ist. Eine Liste besteht aus Elementen, die hintereinander aufgereiht sind. Der Begriff linear besagt, dass es in dieser Liste keinerlei Verzweigungen oder dergleichen gibt. Mit Ausnahme von Anfang und Ende gibt es also immer genau einen Nachfolger sowie einen Vorgänger. Schließlich besagt sortiert, dass die einzelnen Elemente hinsichtlich irgendeines Kriteriums auf- oder absteigend sortiert sind. Was versteht man unter Traversieren? Traversieren bedeutet, dass man eine komplexe Datenstruktur elementweise abarbeitet. Ein Beispiel wäre, dass man eine lineare Liste Element für Element ausgibt. Traversieren könnte aber auch sein, dass man Element für Element löscht. Was ist der Unterschied zwischen einer linearen, sortierten Liste und einem Stack? Von der Struktur her sind beide identisch. Ausgehend von einem Startzeiger folgt Element nach Element, bis man das Ende der Liste erreicht hat. Der einzige Unterschied betrifft die Stelle, an der man neue Elemente einfügt (und wieder entfernt). Bei einem Stack wird immer vorne eingefügt und auch wieder entfernt, weshalb man einen Stack auch mit dem Begriff FIFO für first in first out attributiert. In einer sortierte Liste hingegen, werden die neuen Elemente immer nur dort eingefügt, wo sie die Eigenschaft sortiert aufrecht erhalten; dies kann prinzipiell also an jeder beliebigen Stelle der Liste sein. Aufgabe 2: Detailfragen zu Listen Die folgenden Fragen beziehen sich immer auf eine einfach verkettete, sortierte Liste oder deren Elemente. Wie viele Nachfolger hat jedes Element? Wie viele Vorgänger hat jedes Element? Woran erkennt man das Listenende? Wie findet man den Listenanfang? Wie kann man eine Liste ausgeben? Wie kann man sie invertiert ausgeben? Wie muss man sich das vorstellen? Eines, mit Ausnahme des letzten Elementes Eines, mit Ausnahme des ersten Elementes Der next -Zeiger ist ein Null-Zeiger Mittels eines Startzeigers Am einfachsten mit einer for-schleife Am einfachsten rekursiv Erst den Rest, dann das aktuelle Element 32-1 Wintersemester 2015/16, Einführung in die Praktische Informatik

3 Aufgabe 3: Einfügen neuer Elemente in eine Liste Im Skript haben wir recht ausführlich über die algorithmische Umsetzung des sortierten Einfügens geschrieben. Zur Rekapitulation haben wir eine Reihe von Fragen zusammengetragen. Welche vier Fälle muss man beim Einfügen neuer Elemente beachten? 1. Die Liste kann leer sein; der Startzeiger ist ein Null-Zeiger 2. Das neue Element kommt vor das erste Element 3. Das neue Element kommt irgendwo mitten drin hinein 4. Das neue Element muss an das Ende angehängt werden In wie vielen Fällen wird der Startzeiger verändert? Ist das programmiertechnisch gut oder schlecht? Warum? 2 (zwei) It s: Pain in the Ass Man benötigt Zeiger auf Zeiger In den meisten Fällen benutzt man eine Schleife, um diejenige Stelle zu finden, an der man einfügen möchte. Welches Programmierproblem ergibt sich dadurch? In der Regel bleibt man ein Element zu spät stehen. Daher benötigt man entweder einen zweiten Zeiger, der ein Element hinterher hinkt, oder muss bei der Schleifenbedingung ein weiteres Element vorausschauen. Beides ist nicht besonders schön, lässt sich aber im Standardalgorithmus nicht vermeiden. Aufgabe 4: Die Wirth sche Variante Im Skript haben wir auch die Variante von Wirth diskutiert. Was ist die wesentliche Idee? Es gibt ein zusätzliches Element, das immer am Ende der Liste zu finden ist. Dieses Element gehört zwar technisch zur Liste, ist aber nicht Bestandteil der Datenelemente. Die Wirth sche Idee hat einige Besonderheiten und Vorteile. Hierzu folgende Fragen: Wird der Startzeiger verändert? Wie viele Fälle werden unterschieden? Wofür ist das Dummy Element? Wo bleibt der Suchzeiger stehen? Wie wird dann aber eingefügt? Welchen Algorithmus nehmen wir? Nein, nie, er zeigt immer auf das selbe Element Es gibt nur einen Fall Der Suchzeiger bleibt spätestens hier stehen Ein Element zu spät Durch geschicktes Vertauschen 100-pro den Wirth schen: intelligent und einfach Einführung in die Praktische Informatik, Wintersemester 2015/

4 Teil II: Quiz Aufgabe 1: Positionierung innerhalb von Listen Nehmen wir an, wir haben die folgende Definition einer Liste sowie die folgende Funktion zur Positionierung eines Zeigers. 1 typedef struct user { int i; } DATA ; 2 3 typedef struct _element { 4 struct _element * next ; 5 DATA data ; 6 } ELEMENT, *EP; 7 8 EP position ( EP listp, int val ) 9 { 10 while ( listp -> data.i < val ) 11 listp = listp -> next ; 12 return listp ; 13 } Nun gehen wir davon aus, dass wir bereits die folgende Liste (in unserem Hauptprogramm) aufgebaut haben: start i : 1 i : 3 i : 5 i : 7 Auf welche Elemente zeigen die Zeiger start und p nach folgenden Funktionsaufrufen: Funktionsaufruf start p Anmerkung p = position( start, 3 ) Element 3 p = position( start, -1 ) Element 1 p = position( start->next, -1 ) Element 3 p = position( start, 6 ) Element 7 p = position( start, 7 ) Element 7 p = position( start, 8 ) Programmabsturz: Dereferenzieren eines Null-Zeigers Schlussfolgerung: Programmabsturz, falls val größer als der größte Listenwert ist Wintersemester 2015/16, Einführung in die Praktische Informatik

5 Aufgabe 2: Positionierung: zweiter Versuch Aufgrund des vorherigen Programmabsturzes bei Suchwerten, die größer als das größte Element der Liste waren, haben wir unser Programm wie folgt verändert: 1 typedef struct user { int i; } DATA ; 2 3 typedef struct _element { 4 struct _element * next ; 5 DATA data ; 6 } ELEMENT, *EP; 7 8 EP position ( EP listp, int val ) 9 { 10 while ( listp ->next -> data.i < val ) 11 listp = listp -> next ; 12 return listp ; 13 } Wir betrachten wieder die gleiche Liste sowie die gleichen Funktionsaufrufe: start i : 1 i : 3 i : 5 i : 7 Funktionsaufruf start p Anmerkung p = position( start, 3 ) Element 1 p = position( start, -1 ) Element 1 p = position( start->next, -1 ) Element 3 p = position( start, 6 ) Element 5 p = position( start, 7 ) Element 5 p = position( start, 8 ) Programmabsturz: Dereferenzieren eines Null-Zeigers Schlussfolgerung: Wieder Programmabsturz, falls val größer als der größte Listenwert ist. Der Versuch ging nach hinten los, meint unser Team von Star-Programmierern ;-)) Einführung in die Praktische Informatik, Wintersemester 2015/

6 Aufgabe 3: Positionierung: dritter Versuch So richtig schön waren die beiden vorherigen Versuche nicht. Versuchen wir es also nochmals, diesmal mit einem etwas modifiziertem Algorithmus sowie einer modifizierten Liste. 1 typedef struct user { int i; } DATA ; 2 3 typedef struct _element { 4 struct _element * next ; 5 DATA data ; 6 } ELEMENT, *EP; 7 8 EP position ( EP listp, int val ) 9 { 10 while ( listp -> data.i < val && listp -> next!= 0 ) 11 listp = listp -> next ; 12 return listp ; 13 } start i : 1 i : 5 i : 7 i : BIG Auf welche Elemente zeigen die Zeiger start und p nach folgenden Funktionsaufrufen: Funktionsaufruf start p Anmerkung p = position( start, 3 ) Element 5 p = position( start, -1 ) Element 1 p = position( start, 6 ) Element 7 p = position( start, 7 ) Element 7 p = position( start, 8 ) Element BIG Spätestens bei diesem Element bleibt p stehen. Schlussfolgerung: Kein Programmabsturz :-) Position von p: Beim gesuchten oder nächstgrößeren Element 32-5 Wintersemester 2015/16, Einführung in die Praktische Informatik

7 Aufgabe 4: Speicherallokation Gegeben sei folgendes Programmstück: 1 typedef struct user { int i; } DATA ; 2 3 typedef struct _element { 4 struct _element * next ; 5 DATA data ; 6 } ELEMENT, *EP; 7 8 EP newelement ( int val, EP next ) 9 { 10 EP new = malloc ( sizeof ( ELEMENT ) ); 11 if ( new ) 1 13 new -> data.i = val ; new -> next = next ; 14 } 15 return new ; 16 } Vervollständige das Speicherbild für die folgenden beiden Aufrufe von newelement(). Wie bei fast allen Übungen gehen wir davon aus, dass sowohl int-werte als auch Zeiger immer vier Bytes im Arbeitsspeicher belegen. Ferner nehmen wir an, dass der Aufruf der Funktion newelement() die Adresse 0xFA00 liefert. 1. EP p = newelement( 4711, 0 ); Segment: Stack Adresse Variable Wert 0xFE7C EP p: 0xFA00 Segment: Heap Adresse Wert 0xFA xFA00 0x ELEMENT el; EP p = newelement( 815, & el ); Segment: Stack Adresse Variable Wert 0xFE7C el.data.i: xFE78 el.next : xFE74 EP p : 0xFA00 Segment: Heap Adresse Wert 0xFA xFA00 0xFE78 Vielen hilft es beim Verstehen, wenn sie zusätzlich noch die Zeiger in die Speicherbildchen einzeichnen. Einführung in die Praktische Informatik, Wintersemester 2015/

8 Aufgabe 5: Elemente einfügen Für die beiden letzten Quizaufgaben haben wir den Positionierungsalgorithmus aus Aufgabe 3 um ein paar Zeilen erweitert. Der erste Parameter dieser neuen Funktion ist die bisher im Arbeitsspeicher aufgebaute Liste. Der zweite Parameter ist ein Zeiger auf ein neues Element, wie wir es gerade eben in der vorherigen Aufgabe gesehen haben: 1 void insertelement ( EP list, EP new ) 3 DATA tmp ; 4 while ( list -> data.i < new -> data.i && list -> next!= 0 ) 5 list = list -> next ; 6 tmp = new -> data ; 7 * new = * list ; 8 list -> next = new ; 9 list -> data = tmp ; 10 } In den beiden folgenden Aufgaben wird die Funktion insertelement() immer mit der selben Liste aufgerufen. Sie hat nur ein Datenelement. Beim ersten Mal wird das Datenelement 5, beim zweiten Mal 13 eingefügt. Der in den Abbildungen verwendete start-zeiger ist der im Hauptprogramm verwaltete Startzeiger der Liste. Er dient nur zur Illustierung und wird nicht weiter verwendet. Bearbeite nun die beiden Fälle: 1. Einfügen des Datenelementes 5: Zeile 3: start new i : 9 i : 5 i : BIG Ende Zeile 9: list start new i : 5 i : 9 i : BIG 32-7 Wintersemester 2015/16, Einführung in die Praktische Informatik

9 2. Einfügen des " Datenelementes\ 13: Zeile 3: start new i : 9 i : 13 i : BIG Ende Zeile 9: list start new i : 9 i : BIG i : 13 Damit wären wir jetzt für den Anwendungsfall gerüstet. Einführung in die Praktische Informatik, Wintersemester 2015/

10 Teil III: Fehlersuche Aufgabe 1: Ausgabe von Listen Die meisten Fehler- und Problemfälle haben wir bereits besprochen. Doch Dr. L. Ist- Wirth hat das Ausgeben Wirth scher Listen noch nicht im Griff. Was lief hier schief...? 1 void prtlist ( EP p ) 3 printf ( " Liste :" ); 4 do { 5 p = p-> next ; 6 printf ( " %i", p-> data.i ); 7 } while ( p!= 0 ); 8 printf ( "\n" ); 9 } Leider erscheinen hier einige Anweisungen in genau der falschen Reihenfolge. Zeile Fehler Erläuterung Korrektur 7 Hier wird bereits zum nächsten Element weiter gegangen. Das wäre eigentlich nicht so schlimm, doch ist bis hier beim ersten Schleifendurchlauf noch nicht ausgegeben worden. Insofern würde das erste Datenelement verborgen bleiben. auf später verschieben Die Schleife läuft so lange, wie der Zeiger p kein Null- Zeiger ist. Dadurch wird auch das letzte Element der Liste ausgeben. In einer Wirth schen Liste ist dies aber das Dummy-Element und gehört nicht zum Datenbestand und sollte auch nicht ausgegeben werden. Programm mit Korrekturen: 1 # include <stdio.h> 2 3 void prtlist ( EP p ) 4 { 5 printf ( " Liste :" ); 6 for ( ; p-> next ; p = p-> next ) 7 printf ( " %i", p-> data.i ); 8 printf ( "\n" ); 9 } p->next!= Wintersemester 2015/16, Einführung in die Praktische Informatik

11 Teil IV: Anwendungen Aufgabe 1: Definition einer geeigneten Datenstruktur 1. Aufgabenstellung Definiere eine Datenstruktur für lineare Listen, in der jedes Element ein einzelnes Zeichen aufnehmen kann. 2. Kodierung In Anlehnung an Übungspaket 31 definieren wir folgende Datenstruktur: 1 typedef struct user { 2 char c; 3 } DATA, *DP; // the user data 4 5 typedef struct _list_element { 6 struct _list_element * next ; // the admin part 7 DATA data ; // the user data part 8 } ELEMENT, *EP; Aufgabe 2: Allokation eines neuen Elementes 1. Aufgabenstellung Entwickle eine Funktion, die dynamisch ein neues Listenelement generiert. 2. Entwurf Deklaration: neues Element alloziieren: EP newelement( char c, EP next ); 3. Kodierung 1 EP newelement ( char c, EP next ) 3 EP p = malloc ( sizeof ( ELEMENT ) ); 4 if ( p ) // do we have a new element? 5 { 6 p-> data.c = c; p-> next = next ; // initialize 7 } 8 return p; 9 } Einführung in die Praktische Informatik, Wintersemester 2015/

12 Aufgabe 3: Sortiertes Einfügen eines neuen Elementes 1. Aufgabenstellung Nun wird s ernst. Entwickle eine Funktion, die ein neues Element an der richtigen Stelle in die Liste einfügt. Wir gehen wieder davon aus, dass die Elemente der Liste aufsteigend sortiert werden sollen. 2. Entwurf Vervollständige zunächst die Funktionsdeklaration: Neues Element einfügen: void insertelement( EP oldlist, EP newelement ); 3. Kodierung 1 void insertelement ( EP oldlist, EP newelement ) 3 DATA tmp = newelement - > data ; 4 while ( oldlist -> next 5 && newelement -> data.c > oldlist -> data.c ) 6 oldlist = oldlist - > next ; 7 * newelement = * oldlist ; 8 oldlist - > next = newelement ; 9 oldlist -> data = tmp ; 10 } Um später die Daten leichter einfügen zu können, schreiben wir uns gleich noch eine kleine Hilfsfunktion, die das Ausgeben möglicher Fehlermeldungen kapselt. Damit können wir uns jederzeit ein paar sinnvolle Testausgaben generieren, um beispielsweise den aktuellen Zustand der Liste zu erfragen. 1 int insertdata ( EP list, char c ) 3 EP p = newelement ( c, 0 ); // a new element 4 if ( p == 0 ) // ran out of memory? 5 { 6 fprintf ( stderr, " can t insert %c", c ); 7 fprintf ( stderr, "; no space available \ n" ); 8 } 9 else insertelement ( list, p ); // ok, all clear 10 return p!= 0; 11 } Durch den Ausdruck der return-anweisung in Zeile 10 erfährt die aufrufende Stelle, ob die Daten eingefügt werden konnten Wintersemester 2015/16, Einführung in die Praktische Informatik

13 Aufgabe 4: Ausgabe der Liste 1. Aufgabenstellung Entwickle eine Funktion, die nacheinander alle Elemente einer übergebenen Liste ausgibt. 2. Entwurf Vervollständige zunächst die Funktionsdeklaration: Liste ausgeben: void prtlist( EP list ); 3. Kodierung Diese Funktion ist sehr einfach. Wir müssen nur alle Elemente außer dem letzten in einer Schleife ausgeben. Das letzte Element erkennen wir daran, dass sein next-zeiger ein Null-Zeiger ist. 1 void prtlist ( EP p ) 3 printf ( " Liste :" ); 4 for ( ; p-> next ; p = p-> next ) 5 printf ( " %c", p-> data.c ); 6 printf ( "\n" ); 7 } Aufgabe 5: Initialisierung der Liste 1. Aufgabenstellung Jetzt fehlt noch die richtige Initialisierung einer neuen Liste. Im Skript haben wir gesehen, dass der konkrete Datenwert des Dummys unerheblich ist. Wichtig ist hingegen, dass der Next-Zeiger ein Null-Zeiger ist. Dies lässt sich einfach realisieren. 2. Kodierung 1 EP first = newelement ( x, 0 ); // dummy element Zur Erinnerung: Bei der Wirth schen Alternative ist es egal, was für ein Wert im letzten Element steht. Wir haben hier völlig willkürlich ein x gewählt; es hätte auch jeder beliebige andere Wert sein können. Der entscheidende Punkt ist, wie bereits mehrfach gesagt, dass der Next-Zeiger ein Null-Zeiger ist. Einführung in die Praktische Informatik, Wintersemester 2015/

14 Aufgabe 6: Ein Hauptprogramm zum Testen Den bereits erlernten argc/argv Mechanismus (siehe auch Übungspaket 25) können wir hier sehr gut zum intelligenten Testen unseres Listen-Programms verwenden. Wenn wir auf diesen Mechanismus zurückgreifen, brauchen wir nicht alles fest im Hauptprogramm zu kodieren und können leicht und umfangreich testen. 1. Aufgabenstellung Entwickle ein Hauptprogramm, mit dessen Hilfe wir unsere Listen-Funktionen in geeigneter Art und Weise testen können. Mit Hilfe des argc/argv-mechanismus soll das Hauptprogramm die folgenden Funktionalitäten anbieten: 1. Egal, wie wir unser Programm aufrufen, soll es die Liste direkt nach der Initialisierung sowie vor dem Programmende ausgeben. 2. Das erste Argument (argv[1]) soll alle Zeichen enthalten, die wir in die Liste aufnehmen. Beispiel:./myListe vacation soll am Ende zu folgender Ausgabe führen: a a c i n o t v 3. Sollte noch ein zweites Argument (argv[2]) angegeben werden, dann soll die Liste nach jedem Einfügen ausgegeben werden. Mittels der bisherigen Vorübungen, insbesondere Übungspaket 25, sollte die Umsetzung keine größeren Schwierigkeiten bereiten. 2. Kodierung 1 int main ( int argc, char ** argv ) 3 char *p; 4 EP first = newelement ( x, 0 ); // dummy element 5 prtlist ( first ); // check after initialization 6 if ( argc > 1 ) 7 { 8 for ( p = argv [ 1 ]; *p; p++ ) 9 { 10 insertdata ( first, * p ); 11 if ( argc > 2 ) // debug mode 12 prtlist ( first ); 13 } 14 prtlist ( first ); 15 } 16 else printf ( " sorry, keine Daten vorhanden \ n" ); 17 } Die nächsten beiden Seiten geben das Programm nochmals vollständig wieder Wintersemester 2015/16, Einführung in die Praktische Informatik

15 Definition der Datenstrukturen: 1 # include <stdio.h> // for I/O 2 # include < stdlib. h > // for malloc () 3 4 typedef struct user { 5 char c; 6 } DATA, *DP; // the user data 7 8 typedef struct _list_element { 9 struct _list_element * next ; // the admin part 10 DATA data ; // the user data part 11 } ELEMENT, *EP; Allokation eines neuen Elementes: 13 EP newelement ( char c, EP next ) 14 { 15 EP p = malloc ( sizeof ( ELEMENT ) ); 16 if ( p ) // do we have a new element? 17 { 18 p-> data.c = c; p-> next = next ; // initialize 19 } 20 return p; 21 } Einfügen eines neuen Elementes: 23 void insertelement ( EP oldlist, EP newelement ) 24 { 25 DATA tmp = newelement - > data ; 26 while ( oldlist - > next 27 && newelement -> data.c > oldlist -> data.c ) 28 oldlist = oldlist - > next ; 29 * newelement = * oldlist ; 30 oldlist - > next = newelement ; 31 oldlist -> data = tmp ; 32 } Einführung in die Praktische Informatik, Wintersemester 2015/

16 Einfügen neuer Daten: 34 int insertdata ( EP list, char c ) 35 { 36 EP p = newelement ( c, 0 ); // a new element 37 if ( p == 0 ) // ran out of memory? 38 { 39 fprintf ( stderr, " can t insert %c", c ); 40 fprintf ( stderr, "; no space available \ n" ); 41 } 42 else insertelement ( list, p ); // ok, all clear 43 return p!= 0; 44 } Ausgabe der Liste: 46 void prtlist ( EP p ) 47 { 48 printf ( " Liste :" ); 49 for ( ; p-> next ; p = p-> next ) 50 printf ( " %c", p-> data.c ); 51 printf ( "\n" ); 52 } Das Hauptprogramm: 54 int main ( int argc, char ** argv ) 55 { 56 char *p; 57 EP first = newelement ( x, 0 ); // dummy element 58 prtlist ( first ); // check after initialization 59 if ( argc > 1 ) 60 { 61 for ( p = argv [ 1 ]; *p; p++ ) 6 63 insertdata ( first, * p ); 64 if ( argc > 2 ) // debug mode 65 prtlist ( first ); 66 } 67 prtlist ( first ); 68 } 69 else printf ( " sorry, keine Daten vorhanden \ n" ); 70 } Endlich fertig :-) Wintersemester 2015/16, Einführung in die Praktische Informatik

17 Nachlese Die meisten werden froh sein, die Listenverarbeitung halbwegs hinbekommen zu haben. Wenn man sich aber die Lösung mit etwas zeitlichem Abstand nochmals anschaut, wird man die eine oder andere Stelle finden, die nicht ganz so schön geworden ist. Dies betrifft insbesondere die Funktionen newelement() und insertelement(). Warum? Ganz einfach. Ein Teil dieser Funktionen ist recht generisch, d.h. auch bei anderen Aufgaben einsetzbar. Andererseits sind einige Komponenten genau auf die gestellte Aufgabe zugeschnitten. Also nix da mit Kopieren, wenn man die Algorithmen für die nächste Aufgabe verwenden möchte. Im Umkehrschluss heißt das: Für die Wiederverwendbarkeit wäre es schön, wenn wir einen aufgabenspezifischen und einen generellen (auch generisch genannten) Teil hätten. Und das ist gar nicht so schwer. Wenn man erst einmal die richtige Position hat (Zeiger pos wie im Quiz), kann man das Erzeugen und Einfügen eines neuen Elementes wie folgt realisieren: 1 EP newelement ( DATA data, EP next ) // generic 3 EP p = malloc ( sizeof ( ELEMENT ) ); 4 if ( p ) // do we have a new element? 5 { 6 p-> data = data ; p-> next = next ; // initialize 7 } 8 return p; 9 } int insertelement ( EP pos, DATA data ) // generic 1 13 EP new = newelement ( pos ->data, pos -> next ); 14 if ( new ) 15 { 16 pos -> next = new ; 17 pos -> data = data ; 18 } 19 return new!= 0; 20 } Für unsere Zeichen-Liste ist das Finden der richtigen Position sehr einfach: 1 EP findposition ( EP liste, char c ) // specific : based on c 3 while ( liste -> data.c < c && liste -> next ) 4 liste = liste -> next ; 5 return liste ; 6 } Einführung in die Praktische Informatik, Wintersemester 2015/

18 Um ein neues Zeichen in die Liste einzufügen, müssen wir nun alle drei Funktionen in der richtigen Art und Weise verknüpfen. Dabei nutzen wir aus, dass wir das neue Element nicht mit irgendwelchen Daten vorinitialisieren sonder das gefundene Element einfach duplizieren: 1 int insertdata ( EP list, char c ) // specific 3 DATA data = { c }; // wrapping into struct 4 if (! insertelement ( findposition ( list, c ), data )) 5 { 6 fprintf ( stderr, " can t insert %c", c ); 7 fprintf ( stderr, "; no space available \ n" ); 8 return 0; 9 } 10 return 1; 11 } Und der Rest bleibt unverändert: 1 void prtlist ( EP p ) 3 printf ( " Liste :" ); 4 for ( ; p-> next ; p = p-> next ) 5 printf ( " %c", p-> data.c ); 6 printf ( "\n" ); 7 } 8 9 int main ( int argc, char ** argv ) 10 { 11 char *p; 12 DATA data = { x }; 13 EP first = newelement ( data, 0 ); // dummy element 14 prtlist ( first ); // check after initialization 15 if ( argc > 1 ) 16 { 17 for ( p = argv [ 1 ]; *p; p++ ) 18 { 19 insertdata ( first, * p ); 20 if ( argc > 2 ) // debug mode 21 prtlist ( first ); 22 } 23 prtlist ( first ); 24 } 25 else printf ( " sorry, keine Daten vorhanden \ n" ); 26 } Wintersemester 2015/16, Einführung in die Praktische Informatik

19 Aufgabe 7: Doppelt verkettete Listen In dieser letzten Übungsaufgabe geht es um doppelt verkettete Listen. Die Bearbeitung ist vor allem theoretischer Natur, weshalb das Implementieren und Testen am Rechner freiwillig sind. Wohin zeigen die Zeiger bei doppelt verketteten Listen? Bei einer doppelt verketteten Liste benötigt man immer zwei Zeiger, einer zeigt zum Nachfolger, der andere zum Vorgänger. Definiere eine Datenstruktur für ein Element einer doppelt verketteten Liste, die ein int und zwei double Variablen aufnehmen kann. 1 typedef struct user 3 int i; 4 double d1, d2; 5 } DATA, *DP; 6 7 typedef struct _element 8 { 9 struct _element * previous, * next ; 10 DATA data ; 11 } D_LIST, * DLP ; Skizziere an einem Beispiel, welche Zeiger beim Einfügen eines neuen Elementes in eine bereits vorhandene Liste in welcher Form umgehängt werden müssen. Die Grafik zeigt zwei Elemente einer doppelt verketteten Liste. Der Zeiger q zeigt auf das neue Element, das hinter das Element eingefügt werden soll, auf das p zeigt. Die Nummern beziehen sich auf folgendem Programmausschnitt. p q (4) (3) (2) (1) 1 p->next -> previous = q; 2 q-> previous = p; 3 q-> next = p-> next ; 4 p-> next = q; Einführung in die Praktische Informatik, Wintersemester 2015/