Micha1087 Geschrieben 12. Dezember 2009 Geschrieben 12. Dezember 2009 Hallo! Ich habe folgendes Problem: Es sollen zwei Queues als Listen zu einem Stack erstellt werden. Ich habe nun ein Programm geschrieben wo erst eine Queue erstellt wird und der Benutzer kann angeben wie lang diese sein soll. Wenn er also als Beispiel 5 angibt wird die erste Queue mit den Zahlen 1-5 gefüllt. Anschließend wird die Queue1 bis auf das letzte Element ausgelesen und schreibt die Elemente in Queue2. Das letzte Element wird ausgegeben. Dieses Umschichten findet solange statt bis keine Elemente mehr vorhanden sind. Auf dem Bildschirm wird also der Reihe nach ausgegeben: 5-4-3-2-1 Soweit meine Überlegungen nur leider funktioniert mein Programm nicht. Mein Compiler gibt immer als Fehlermeldung: "Eine Zugriffsverletzung" wie kann man das beheben? Ich würde mich echt tierisch freuen wenn sich hier jemand mal das Programm anschauen könnte und mir evtl weiterhilft. LG und Danke schonmal im Vorraus. MichaAufgabe3fertig.rar Zitieren
konsti4u Geschrieben 12. Dezember 2009 Geschrieben 12. Dezember 2009 Program received signal SIGSEGV, Segmentation fault. 0x08048578 in main () at Aufgabe3fertig.c:29 29 Last ->next =q; Du hast Last nirgendwohin referenziert (zeigt auf nichts) und du versuchst auf einen Wert zuzugreifen... Zitieren
Micha1087 Geschrieben 12. Dezember 2009 Autor Geschrieben 12. Dezember 2009 (bearbeitet) In Zeile 23 hab ich doch mit "First=Last;" Last auf das erste Element gesetzt! Was muss ich denn dann ändern das es funktioniert? Bearbeitet 12. Dezember 2009 von Micha1087 Zitieren
konsti4u Geschrieben 12. Dezember 2009 Geschrieben 12. Dezember 2009 Nein, das hast du nicht, du hast First auf Last gesetzt, also du hast gesagt, dass First nun dorthin zeigen soll wie Last (Last zeigt nirgendwohin. Also zeigt auch First nun auch nirgendwohin) First = Last ist nicht dasselbe wie Last = First! Schau zu dass du das Programm nochmal durchgehst und nach Fehlern suchst, wenn du Linux benutzst, kompilier das Programm mit -g und debugge es mit dem gdb: gdb ./programm dann "start" und "n" für next, dann zeigt er dir den Fehler und in welcher Zeile er im Code ist. MfG Zitieren
Micha1087 Geschrieben 12. Dezember 2009 Autor Geschrieben 12. Dezember 2009 Ich compilier mit Dev C++ unter Windows. Der zeigt auch Fehler an! Aber leider kann ich die nicht interpretieren. Das mit dem Last=First und First=Last war ein guter Tip. Das hab ich bei zwei stellen geändert aber jetzt hängt er laut Compiler in einem printf und ich weis nicht warum! Zitieren
Klotzkopp Geschrieben 12. Dezember 2009 Geschrieben 12. Dezember 2009 Ich compilier mit Dev C++ unter Windows.Keine gute Idee. Diese Entwicklungsumgebung wird seit Jahren nicht mehr weiterentwickelt und hat etliche Bugs. Der zeigt auch Fehler an! Aber leider kann ich die nicht interpretieren.Aber wir können das. Dazu ist es aber notwendig, dass du die Fehlermeldungen hier reinstellst. Denn Hellsehen können wir nicht. Zitieren
Micha1087 Geschrieben 12. Dezember 2009 Autor Geschrieben 12. Dezember 2009 Ich stelle hier noch einmal den Code ein (befindet sich in der rar date da man .c dateien leider nicht hocladen kann! Der Compiler sagt:"Zugriffsverletzung" in Zeile 71. Zitieren
Micha1087 Geschrieben 12. Dezember 2009 Autor Geschrieben 12. Dezember 2009 Code (hab ich eben vergessen)Aufgabe3fertig.rar Zitieren
Klotzkopp Geschrieben 12. Dezember 2009 Geschrieben 12. Dezember 2009 Der Compiler sagt:"Zugriffsverletzung" in Zeile 71.Das kann der Compiler gar nicht, weil das ein Laufzeitfehler ist. Das kann allenfalls der Debugger. Code (hab ich eben vergessen) Das ist derselbe Code wie vorher. Du kannst den Code übrigens auch einfach in [ CODE ]-Tags direkt ins Forum stellen. Dann spart man sich auch das Gehampel mit den Archiven. Aber schon mal ein paar allgemeine Hinweise: Es heißt int main, nicht void main.Den Rückgabewert von malloc soll man nicht casten. Zitieren
konsti4u Geschrieben 12. Dezember 2009 Geschrieben 12. Dezember 2009 [*]Den Rückgabewert von malloc soll man nicht casten. :-O Wie meinste das jetzt? Natürlich sollte man ihn casten... Und zum Code, das ist zuviel Code, brauchen da länger um deinem Gedankengang zu folgen, zwar teilweise kommentiert aber vor allem die Zeigerveränderungen solltest du genauer erklären wo was warum reinkommt... Versuch doch mal den Code Stückchenweise zu testen (prüfen auf NULL-Zeiger, ausgeben der Zahlen in der Liste usw.)... wenn ich beide START = ENDE aus dem ersten COde ändere, dann kommt er in eine Endlosschleife: Temporary breakpoint 1, main () at Aufgabe3fertig.c:17 warning: Source file is more recent than executable. 17 First = NULL; (gdb) n 19 printf("Listenlaenge:"); // Abfragen (gdb) n 20 scanf("%d",&N); // und Einlesen wie lang die Liste wird (gdb) n Listenlaenge:5 23 First = (Zeiger) malloc(sizeof(NODE)); First->zahl=1; First->next = NULL; Last=First; (gdb) n 24 for (i=2; i<=N; i++) (gdb) n 26 q = (Zeiger)malloc(sizeof(NODE)); (gdb) n 27 q->zahl=i; (gdb) n 28 q->next = NULL; (gdb) n 29 Last ->next =q; (gdb) n 30 Last = q; (gdb) n 24 for (i=2; i<=N; i++) (gdb) n 26 q = (Zeiger)malloc(sizeof(NODE)); (gdb) n 27 q->zahl=i; (gdb) n 28 q->next = NULL; (gdb) n 29 Last ->next =q; (gdb) n 30 Last = q; (gdb) n 24 for (i=2; i<=N; i++) (gdb) n 26 q = (Zeiger)malloc(sizeof(NODE)); (gdb) n 27 q->zahl=i; usw Zitieren
Micha1087 Geschrieben 12. Dezember 2009 Autor Geschrieben 12. Dezember 2009 Okay das mit dem wusst ich nicht! Ich kann ja vielleicht meine Gedanken ein bißchen erklären! Also ich greife über die Zeiger auf die Elemente der queue zu! Hinzufügen neuer Elemente geschieht am Ende der Queue dafür wird ein neues Element erstellt und mit dem zeiger q markiert! Anschließend wird dort eine zahl hineingeschrieben. Anschließend wird der next zeiger des neu erstellten Knotens auf Null gesetzt und der next zeiger des elements wo Last drauf zeigt (also das bis dahin letzte Element) auf das neue element wo q drauf zeigt gesetzt. Daraufhin wird dann der Last zeiger auf das neu erstellte Element (da wo q drauf zeigt) verschoben. Das ist das hinzufügen neuer Elemente. Hoffe ihr konntet mir folgen! Zitieren
Klotzkopp Geschrieben 12. Dezember 2009 Geschrieben 12. Dezember 2009 :-O Wie meinste das jetzt? Natürlich sollte man ihn casten...Nein, sollte man nicht. Es ist unnötig und kann unter bestimmten Umständen Fehler verdecken. Wenn man in C90 (z.B. wegen einer vergessenen Includedirektive) malloc ohne Prototyp benutzt, geht der Compiler davon aus, dass die Funktion int zurückgibt. Das kann z.B. dann problematisch sein, wenn man eine Plattform hat, auf der int und Zeiger nicht gleich groß sind. Wenn man malloc dann ohne Cast benutzt, bekommt man eine Fehlermeldung, weil ein int nicht implizit in einen Zeigertyp umgewandelt werden kann. Benutzt man aber einen Cast, gibt es keine Fehlermeldung mehr, das Problem ist aber immer noch da. Schwer zu behebende Laufzeitfehler können die Folge sein. Zitieren
Klotzkopp Geschrieben 12. Dezember 2009 Geschrieben 12. Dezember 2009 Hoffe ihr konntet mir folgen!Zeig doch einfach mal den aktuellen Code. Du hast beim zweiten Mal wieder den alten Code hochgeladen. Zitieren
Micha1087 Geschrieben 12. Dezember 2009 Autor Geschrieben 12. Dezember 2009 Das ist mein aktueller code: // Aufgabe 3b: // Realisieren Sie einen Stack als Liste unter Verwendung zweier Queues in C. // Beachten Sie, dass nur die für Queues erlaubten Funktionen verwendet werden. #include <stdio.h> #include <stdlib.h> typedef struct node *Zeiger; typedef struct node //Alias der Liste = NODE { Zeiger next; int zahl; } NODE; Zeiger p, q, First, Last; //Q1 - First=Anker, Last=Zeiger auf das Ende der Liste, q=Zeiger auf ein neues Element, p=Entnahmezeiger Zeiger x, y, Erstes, Letztes; //Q2 - Erstes=Anker, Letztes=Zeiger auf das Ende der Liste, y=Zeiger auf ein neues Element, x=Entnahmezeiger void main () //Hauptprogramm { int N, i; //N=Länge der Liste, i= Laufindex First = NULL; printf("\n Dieses Programm erstellt eine Queue mit der von Ihnen angegebenen \n"); printf(" Listenlaenge und füllt diese mit den zahlen 1-2-3-4... Diese Zahlen\n"); printf(" werden dann mithilfe von Umschichtprozessen über ein zweites Queue \n"); printf(" in der Reihenfolge eines Stacks ausgegeben\n Bitte geben sie die Laenge ein: "); // Abfragen scanf("%d",&N); // und Einlesen wie lang die Liste wird //Füllen von Queue1 First = (Zeiger) malloc(sizeof(NODE)); First->zahl=1; Last=First; Last->next = NULL; for (i=2; i<=N; i++) { q = (Zeiger)malloc(sizeof(NODE)); q->zahl=i; q->next = NULL; Last->next =q; Last = q; } while (First->next!=NULL || Erstes->next!=NULL) { //Umschichten von 1 in 2 //Anlegen der zweiten queue mit dem ersten Element von q1 Erstes = (Zeiger) malloc(sizeof(NODE)); Erstes->zahl=First->zahl; Letztes=Erstes; Letztes->next = NULL; //Löschen des ersten Elements von q1 p = First; First = First->next; p->next = NULL; free(p); for (i=1; i<=N-1; i++) { //Einlesen der Zahl aus dem ersten Element von q1 y = (Zeiger)malloc(sizeof(NODE)); y->zahl=First->zahl; y->next = NULL; Letztes ->next =y; Letztes = y; //Löschen des ersten Elements von q1 p = First; First = First->next; p->next = NULL; free(p); } //Ausgeben & Löschen des letzten Elements p = First; printf("%5i \n",p->zahl); First = First->next; p->next = NULL; free(p); //Umschichten von 2 in 1 if (Erstes->next!=NULL) { //Anlegen der ersten queue mit dem ersten Element von q2 First = (Zeiger) malloc(sizeof(NODE)); First->zahl=Erstes->zahl; Last=First; Last->next = NULL; //Löschen des ersten Elements von q2 x = Erstes; Erstes = Erstes->next; x->next = NULL; free(x); for (i=1; i<=N-1; i++) { //Einlesen der Zahl aus dem ersten Element von q2 q = (Zeiger)malloc(sizeof(NODE)); q->zahl=Erstes->zahl; q->next = NULL; Last ->next =q; Last = q; //Löschen des ersten Elements von q2 x = Erstes; Erstes = Erstes->next; x->next = NULL; free(x); } //Ausgeben & Löschen des letzten Elements x = Erstes; printf("%5d \n",x->zahl); Erstes = Erstes->next; x->next = NULL; free(x); } } //Ausgeben des letzten Elements: if (Erstes->next=NULL) { printf("%5d \n",Erstes->zahl); //Löschen des letzten Elements x = Erstes; Erstes = Erstes->next; x->next = NULL; free(x); } if (First->next=NULL) { printf("%5d \n",First->zahl); //Löschen des letzten Elements p = First; First = First->next; p->next = NULL; free(p); } system("Pause"); return 0; } Zitieren
Micha1087 Geschrieben 12. Dezember 2009 Autor Geschrieben 12. Dezember 2009 Hab nochmal einige Erklärungen dazu geschrieben: // Aufgabe 3b: // Realisieren Sie einen Stack als Liste unter Verwendung zweier Queues in C. // Beachten Sie, dass nur die für Queues erlaubten Funktionen verwendet werden. #include <stdio.h> #include <stdlib.h> typedef struct node *Zeiger; typedef struct node //Alias der Liste = NODE { Zeiger next; int zahl; } NODE; Zeiger p, q, First, Last; //Q1 - First=Anker, Last=Zeiger auf das Ende der Liste, q=Zeiger auf ein neues Element, p=Entnahmezeiger Zeiger x, y, Erstes, Letztes; //Q2 - Erstes=Anker, Letztes=Zeiger auf das Ende der Liste, y=Zeiger auf ein neues Element, x=Entnahmezeiger void main () //Hauptprogramm { int N, i; //N=Länge der Liste, i= Laufindex First = NULL; printf("\n Dieses Programm erstellt eine Queue mit der von Ihnen angegebenen \n"); printf(" Listenlaenge und füllt diese mit den zahlen 1-2-3-4... Diese Zahlen\n"); printf(" werden dann mithilfe von Umschichtprozessen über ein zweites Queue \n"); printf(" in der Reihenfolge eines Stacks ausgegeben\n Bitte geben sie die Laenge ein: "); // Abfragen scanf("%d",&N); // und Einlesen wie lang die Liste wird //Füllen von Queue1 First = (Zeiger) malloc(sizeof(NODE)); First->zahl=1; //Neuer Speicher Anfordern Last=First; Last->next = NULL; //Last Zeiger auf erstes Element, Next-Zeiger aus Element wo Last drauf zeigt=NULL for (i=2; i<=N; i++) { q = (Zeiger)malloc(sizeof(NODE)); q->zahl=i; //Zahl in das Element von q schreiben q->next = NULL; //Next-Zeiger von Element von q=NULL Last->next =q; //Next-Zeiger von Element wo Last drauf zeigt auf q Last = q; //Last Zeiger auf Element von q schieben } while (First->next!=NULL || Erstes->next!=NULL) { //Umschichten von 1 in 2 //Anlegen der zweiten queue mit dem ersten Element von q1 Erstes = (Zeiger) malloc(sizeof(NODE)); Erstes->zahl=First->zahl; //Zahl aus dem Element wo "First" drauf zeigt in Element wo "Erstes" drauf zeigt schreiben Letztes=Erstes; Letztes->next = NULL; //"Letztes" Zeiger auf erstes Element, Next-Zeiger aus Element wo "Letztes" drauf zeigt=NULL //Löschen des ersten Elements von q1 p = First; //Element wo First drauf zeigt mit p markieren, First = First->next; //First auf nächstes Element (Wo Next-Zeiger von mit First markiertem Elemen drauf gezeigt hat) schieben p->next = NULL; free(p); //Next-Zeiger von Elemt wo p drauf zeigt=NULL; Speicher freigeben for (i=1; i<=N-1; i++) { //Einlesen der Zahl aus dem ersten Element von q1 y = (Zeiger)malloc(sizeof(NODE)); y->zahl=First->zahl; y->next = NULL; Letztes ->next =y; Letztes = y; //Löschen des ersten Elements von q1 p = First; First = First->next; p->next = NULL; free(p); } //Ausgeben & Löschen des letzten Elements p = First; printf("%5i \n",p->zahl); First = First->next; p->next = NULL; free(p); //Umschichten von 2 in 1 if (Erstes->next!=NULL) { //Anlegen der ersten queue mit dem ersten Element von q2 First = (Zeiger) malloc(sizeof(NODE)); First->zahl=Erstes->zahl; Last=First; Last->next = NULL; //Löschen des ersten Elements von q2 x = Erstes; Erstes = Erstes->next; x->next = NULL; free(x); for (i=1; i<=N-1; i++) { //Einlesen der Zahl aus dem ersten Element von q2 q = (Zeiger)malloc(sizeof(NODE)); q->zahl=Erstes->zahl; q->next = NULL; Last ->next =q; Last = q; //Löschen des ersten Elements von q2 x = Erstes; Erstes = Erstes->next; x->next = NULL; free(x); } //Ausgeben & Löschen des letzten Elements x = Erstes; printf("%5d \n",x->zahl); //Ausgeben der Zahl aus dem Element wo x drauf zeigt Erstes = Erstes->next; x->next = NULL; free(x); } } //Ausgeben des letzten Elements: if (Erstes->next=NULL) { printf("%5d \n",Erstes->zahl);//Ausgeben der Zahl aus dem Element wo "Erstes" drauf zeigt //Löschen des letzten Elements x = Erstes; Erstes = Erstes->next; x->next = NULL; free(x); } if (First->next=NULL) { printf("%5d \n",First->zahl);//Ausgeben der Zahl aus dem Element wo "First" drauf zeigt //Löschen des letzten Elements p = First; First = First->next; p->next = NULL; free(p); } system("Pause"); return 0; } Zitieren
Klotzkopp Geschrieben 12. Dezember 2009 Geschrieben 12. Dezember 2009 Du hast da ein Logikproblem. Wenn du aus einer Liste mit N Elementen erst eins löschst, und dann noch N-1 weitere, ist die Liste leer. Ein nachfolgendes "Ausgeben & Löschen des letzten Elements" kann dann nur in die Hose gehen, weil es kein letztes Element mehr gibt. Zitieren
Micha1087 Geschrieben 12. Dezember 2009 Autor Geschrieben 12. Dezember 2009 Aber das tu ich doch garnicht! Ich schreibe erst daten in die erste Queue und lese dann element für element aus! und schreibe sie gleichzeitig in die zweite queue! Nach dem auslese lösch ich das element! Nach und nach immer das erste! Zitieren
konsti4u Geschrieben 12. Dezember 2009 Geschrieben 12. Dezember 2009 Könntest du vll noch ein Bsp. machen, habe die Aufgabe immernoch nicht 100% durchgeblickt, also du erstellst eine x-Elementige liste und dann tust du diese in eine Warteschlange umbauen, also da wo man immer das Element vorne einfügt und rausnimmt, stimmts? Darfst du nicht gleich eine Queue implementieren? Wäre viel weniger zu schreiben... Zitieren
Klotzkopp Geschrieben 12. Dezember 2009 Geschrieben 12. Dezember 2009 //Löschen des ersten Elements von q1 p = First; First = First->next; p->next = NULL; free(p);[/code] Hier löschst du ein Element aus q1. [code] for (i=1; i<=N-1; i++) { //Einlesen der Zahl aus dem ersten Element von q1 y = (Zeiger)malloc(sizeof(NODE)); y->zahl=First->zahl; y->next = NULL; Letztes ->next =y; Letztes = y; //Löschen des ersten Elements von q1 p = First; First = First->next; p->next = NULL; free(p); } Hier löschst du nochmal N-1 Elemente aus q1. Damit hast du N Elemente gelöscht, genauso viele, wie drin waren. Danach ist q1 LEER, First ist NULL. //Ausgeben & Löschen des letzten Elements p = First; printf("%5i \n",p->zahl); [/code]Und hier knallt's dann, wie erwartet. p ist NULL, weil First NULL ist, der Zugriff auf p->zahl ist undefiniert. Zitieren
Micha1087 Geschrieben 12. Dezember 2009 Autor Geschrieben 12. Dezember 2009 Könntest du vll noch ein Bsp. machen, habe die Aufgabe immernoch nicht 100% durchgeblickt, also du erstellst eine x-Elementige liste und dann tust du diese in eine Warteschlange umbauen, also da wo man immer das Element vorne einfügt und rausnimmt, stimmts? Darfst du nicht gleich eine Queue implementieren? Wäre viel weniger zu schreiben... Ich soll mithilfe von zwei Queues ein stack machen! Zitieren
Micha1087 Geschrieben 12. Dezember 2009 Autor Geschrieben 12. Dezember 2009 //Löschen des ersten Elements von q1 p = First; First = First->next; p->next = NULL; free(p); Hier löschst du ein Element aus q1. for (i=1; i<=N-1; i++) { //Einlesen der Zahl aus dem ersten Element von q1 y = (Zeiger)malloc(sizeof(NODE)); y->zahl=First->zahl; y->next = NULL; Letztes ->next =y; Letztes = y; //Löschen des ersten Elements von q1 p = First; First = First->next; p->next = NULL; free(p); } Hier löschst du nochmal N-1 Elemente aus q1. Damit hast du N Elemente gelöscht, genauso viele, wie drin waren. Danach ist q1 LEER, First ist NULL. //Ausgeben & Löschen des letzten Elements p = First; printf("%5i \n",p->zahl); Und hier knallt's dann, wie erwartet. p ist NULL, weil First NULL ist, der Zugriff auf p->zahl ist undefiniert. Demnach müsste man ja dort einfach nur N-2 einsetzen! Ich probiers mal! Trotzdem hier nochmal der Zeile für Zeile kommentierte Code: // Aufgabe 3b: // Realisieren Sie einen Stack als Liste unter Verwendung zweier Queues in C. // Beachten Sie, dass nur die für Queues erlaubten Funktionen verwendet werden. #include <stdio.h> #include <stdlib.h> typedef struct node *Zeiger; typedef struct node //Alias der Liste = NODE { Zeiger next; int zahl; } NODE; Zeiger p, q, First, Last; //Q1 - First=Anker, Last=Zeiger auf das Ende der Liste, q=Zeiger auf ein neues Element, p=Entnahmezeiger Zeiger x, y, Erstes, Letztes; //Q2 - Erstes=Anker, Letztes=Zeiger auf das Ende der Liste, y=Zeiger auf ein neues Element, x=Entnahmezeiger void main () //Hauptprogramm { int N, i; //N=Länge der Liste, i= Laufindex First = NULL; printf("\n Dieses Programm erstellt eine Queue mit der von Ihnen angegebenen \n"); printf(" Listenlaenge und füllt diese mit den zahlen 1-2-3-4... Diese Zahlen\n"); printf(" werden dann mithilfe von Umschichtprozessen über ein zweites Queue \n"); printf(" in der Reihenfolge eines Stacks ausgegeben\n Bitte geben sie die Laenge ein: "); // Abfragen scanf("%d",&N); // und Einlesen wie lang die Liste wird //Füllen von Queue1 First=(Zeiger) malloc(sizeof(NODE)); First->zahl=1; //Neuer Speicher Anfordern Last=First; Last->next = NULL; //Last Zeiger auf erstes Element, Next-Zeiger aus Element wo Last drauf zeigt=NULL for (i=2; i<=N; i++) { q = (Zeiger)malloc(sizeof(NODE)); q->zahl=i; //Zahl in das Element von q schreiben q->next = NULL; //Next-Zeiger von Element von q=NULL Last->next =q; //Next-Zeiger von Element wo Last drauf zeigt auf q Last = q; //Last Zeiger auf Element von q schieben } while (First->next!=NULL || Erstes->next!=NULL) //Solange der Next-Zeiger von Element wo First drauf zeigt oder Element wo "Erstes" drauf zeigt ungleich NULL sind tue das { //Umschichten von 1 in 2 //Anlegen der zweiten queue mit dem ersten Element von q1 Erstes=(Zeiger) malloc(sizeof(NODE));//Neuer Speicher Anfordern Erstes->zahl=First->zahl; //Zahl aus dem Element wo "First" drauf zeigt in Element wo "Erstes" drauf zeigt schreiben Letztes=Erstes; Letztes->next = NULL;//"Letztes" Zeiger auf erstes Element, Next-Zeiger aus Element wo "Letztes" drauf zeigt=NULL //Löschen des ersten Elements von q1 p = First; //Element wo First drauf zeigt mit p markieren, First = First->next; //First auf nächstes Element (Wo Next-Zeiger von mit First markiertem Elemen drauf gezeigt hat) schieben p->next = NULL; free(p); //Next-Zeiger von Element wo p drauf zeigt=NULL; Speicher freigeben for (i=1; i<=N-1; i++) { //Einlesen der Zahl aus dem ersten Element von q1 y = (Zeiger)malloc(sizeof(NODE)); //Neuer Speicher Anfordern y->zahl=First->zahl; //Die zahl aus dem Element wo "First" drauf zeigt in das Element wo y drauf zeigt schreiben y->next = NULL; //Next-Zeiger von Element wo y drauf zeigt=NULL Letztes ->next =y; //Next-Zeiger von Element wo "Letztes" drauf zeigt auf y Letztes = y; //"Letztes" Zeiger auf Element von y schieben //Löschen des ersten Elements von q1 p = First; //Element wo First drauf zeigt mit p markieren, First = First->next; //First auf nächstes Element (Wo Next-Zeiger von mit First markiertem Elemen drauf gezeigt hat) schieben p->next = NULL; //Next-Zeiger von Element wo p drauf zeigt=NULL; free(p); //Speicher freigeben } //Ausgeben & Löschen des letzten Elements p = First; //Element wo First drauf zeigt mit p markieren, printf("%5i \n",p->zahl); //Ausgeben von Zahl aus Element wo p drauf steht First = First->next; //First auf nächstes Element (Wo Next-Zeiger von mit First markiertem Elemen drauf gezeigt hat) schieben p->next = NULL; //Next-Zeiger von Element wo p drauf zeigt=NULL; free(p); //Speicher freigeben //Umschichten von 2 in 1 if (Erstes->next!=NULL) //Wenn Next Zeiger von Element wo "Erstes" drauf zeigt ungleich NULL ist tue das: { //Anlegen der ersten queue mit dem ersten Element von q2 First = (Zeiger) malloc(sizeof(NODE)); First->zahl=Erstes->zahl;//Neuer Speicher Anfordern Last=First; Last->next = NULL; //Last Zeiger auf erstes Element, Next-Zeiger aus Element wo Last drauf zeigt=NULL //Löschen des ersten Elements von q2 x = Erstes; //Element wo "Erstes" drauf zeigt mit x markieren Erstes = Erstes->next; //"Erstes" auf nächstes Element (Wo Next-Zeiger von mit "Erstes" markiertem Element drauf gezeigt hat) schieben x->next = NULL; free(x); //Next-Zeiger von Element wo x drauf zeigt=NULL; Speicher freigeben for (i=1; i<=N-1; i++) { //Einlesen der Zahl aus dem ersten Element von q2 q = (Zeiger)malloc(sizeof(NODE)); //Neuer Speicher Anfordern q->zahl=Erstes->zahl; //Die zahl aus dem Element wo "Erstes" drauf zeigt in das Element wo q drauf zeigt schreiben q->next = NULL; //Next-Zeiger von Element wo q drauf zeigt=NULL Last ->next =q; //Next-Zeiger von Element wo Last drauf zeigt auf q Last = q; //Last Zeiger auf Element von q schieben //Löschen des ersten Elements von q2 x = Erstes; //Element wo "Erstes" drauf zeigt mit x markieren, Erstes = Erstes->next; //"Erstes" auf nächstes Element (Wo Next-Zeiger von mit "Erstes" markiertem Element drauf gezeigt hat) schieben x->next = NULL; free(x); //Next-Zeiger von Element wo x drauf zeigt=NULL; Speicher freigeben } //Ausgeben & Löschen des letzten Elements x = Erstes; //Element wo "Erstes" drauf zeigt mit x markieren printf("%5d \n",x->zahl); //Ausgeben der Zahl aus dem Element wo x drauf zeigt Erstes = Erstes->next; //"Erstes" auf nächstes Element (Wo Next-Zeiger von mit "Erstes" markiertem Element drauf gezeigt hat) schieben x->next = NULL; ree(x); //Next-Zeiger von Element wo x drauf zeigt=NULL; Speicher freigeben } } //Ausgeben des letzten Elements: if (Erstes->next=NULL) //Wenn Next-Zeiger wo "Erstes" drauf zeigt=NULL tue das: { printf("%5d \n",Erstes->zahl);//Ausgeben der Zahl aus dem Element wo "Erstes" drauf zeigt //Löschen des letzten Elements x = Erstes; //Element wo "Erstes" drauf zeigt mit x markieren Erstes = Erstes->next; //"Erstes" auf nächstes Element (Wo Next-Zeiger von mit "Erstes" markiertem Element drauf gezeigt hat) schieben x->next = NULL; //Next-Zeiger von Element wo x drauf zeigt=NULL free(x); //Speicher freigeben } if (First->next=NULL) //Wenn Next-Zeiger wo First drauf zeigt=NULL tue das: { printf("%5d \n",First->zahl);//Ausgeben der Zahl aus dem Element wo "First" drauf zeigt //Löschen des letzten Elements p = First; //Element wo First drauf zeigt mit p markieren First = First->next; //First auf nächstes Element (Wo Next-Zeiger von mit First markiertem Element drauf gezeigt hat) schieben p->next = NULL; //Next-Zeiger von Element wo p drauf zeigt=NULL free(p); //Speicher freigeben } system("Pause"); return 0; } Zitieren
Micha1087 Geschrieben 12. Dezember 2009 Autor Geschrieben 12. Dezember 2009 Danke schonmal für den Tip! Jetzt komm ich ein Printf weiter :-D Zitieren
Micha1087 Geschrieben 12. Dezember 2009 Autor Geschrieben 12. Dezember 2009 Vielen Dank für den guten Tip! Das Programm gibt mir soweit schonmal richtige Zahlen aus! Nur die letzte Zahl wird nicht ausgegeben! Vll kannst du mir ja da auch noch einmal helfen woran das liegt! Man aktueller code: // Aufgabe 3b: // Realisieren Sie einen Stack als Liste unter Verwendung zweier Queues in C. // Beachten Sie, dass nur die für Queues erlaubten Funktionen verwendet werden. #include <stdio.h> #include <stdlib.h> typedef struct node *Zeiger; typedef struct node //Alias der Liste = NODE { Zeiger next; int zahl; } NODE; Zeiger p, q, First, Last; //Q1 - First=Anker, Last=Zeiger auf das Ende der Liste, q=Zeiger auf ein neues Element, p=Entnahmezeiger Zeiger x, y, Erstes, Letztes; //Q2 - Erstes=Anker, Letztes=Zeiger auf das Ende der Liste, y=Zeiger auf ein neues Element, x=Entnahmezeiger int main () //Hauptprogramm { int N, i; //N=Länge der Liste, i= Laufindex First = NULL; printf("\n Dieses Programm erstellt eine Queue mit der von Ihnen angegebenen \n"); printf(" Listenlaenge und füllt diese mit den zahlen 1-2-3-4... Diese Zahlen\n"); printf(" werden dann mithilfe von Umschichtprozessen über ein zweites Queue \n"); printf(" in der Reihenfolge eines Stacks ausgegeben\n Bitte geben sie die Laenge ein: "); // Abfragen scanf("%d",&N); // und Einlesen wie lang die Liste wird //Füllen von Queue1 First=(Zeiger) malloc(sizeof(NODE)); First->zahl=1; //Neuer Speicher Anfordern Last=First; Last->next = NULL; //Last Zeiger auf erstes Element, Next-Zeiger aus Element wo Last drauf zeigt=NULL for (i=2; i<=N; i++) { q = (Zeiger)malloc(sizeof(NODE)); q->zahl=i; //Zahl in das Element von q schreiben q->next = NULL; //Next-Zeiger von Element von q=NULL Last->next =q; //Next-Zeiger von Element wo Last drauf zeigt auf q Last = q; //Last Zeiger auf Element von q schieben } while (First->next!=NULL || Erstes->next!=NULL) //Solange der Next-Zeiger von Element wo First drauf zeigt oder Element wo "Erstes" drauf zeigt ungleich NULL sind tue das { //Umschichten von 1 in 2 //Anlegen der zweiten queue mit dem ersten Element von q1 Erstes=(Zeiger) malloc(sizeof(NODE));//Neuer Speicher Anfordern Erstes->zahl=First->zahl; //Zahl aus dem Element wo "First" drauf zeigt in Element wo "Erstes" drauf zeigt schreiben Letztes=Erstes; Letztes->next = NULL;//"Letztes" Zeiger auf erstes Element, Next-Zeiger aus Element wo "Letztes" drauf zeigt=NULL //Löschen des ersten Elements von q1 p = First; //Element wo First drauf zeigt mit p markieren, First = First->next; //First auf nächstes Element (Wo Next-Zeiger von mit First markiertem Elemen drauf gezeigt hat) schieben p->next = NULL; free(p); //Next-Zeiger von Element wo p drauf zeigt=NULL; Speicher freigeben for (i=1; i<=N-2; i++) { //Einlesen der Zahl aus dem ersten Element von q1 y = (Zeiger)malloc(sizeof(NODE)); //Neuer Speicher Anfordern y->zahl=First->zahl; //Die zahl aus dem Element wo "First" drauf zeigt in das Element wo y drauf zeigt schreiben y->next = NULL; //Next-Zeiger von Element wo y drauf zeigt=NULL Letztes ->next =y; //Next-Zeiger von Element wo "Letztes" drauf zeigt auf y Letztes = y; //"Letztes" Zeiger auf Element von y schieben //Löschen des ersten Elements von q1 p = First; //Element wo First drauf zeigt mit p markieren, First = First->next; //First auf nächstes Element (Wo Next-Zeiger von mit First markiertem Elemen drauf gezeigt hat) schieben p->next = NULL; //Next-Zeiger von Element wo p drauf zeigt=NULL; free(p); //Speicher freigeben } //Ausgeben & Löschen des letzten Elements p = First; //Element wo First drauf zeigt mit p markieren, printf("%5i \n",p->zahl); //Ausgeben von Zahl aus Element wo p drauf steht First = First->next; //First auf nächstes Element (Wo Next-Zeiger von mit First markiertem Elemen drauf gezeigt hat) schieben p->next = NULL; //Next-Zeiger von Element wo p drauf zeigt=NULL; free(p); //Speicher freigeben N--; //Listenlänge um 1 verringern //Umschichten von 2 in 1 if (Erstes->next!=NULL) //Wenn Next Zeiger von Element wo "Erstes" drauf zeigt ungleich NULL ist tue das: { //Anlegen der ersten queue mit dem ersten Element von q2 First = (Zeiger) malloc(sizeof(NODE)); First->zahl=Erstes->zahl;//Neuer Speicher Anfordern Last=First; Last->next = NULL; //Last Zeiger auf erstes Element, Next-Zeiger aus Element wo Last drauf zeigt=NULL //Löschen des ersten Elements von q2 x = Erstes; //Element wo "Erstes" drauf zeigt mit x markieren Erstes = Erstes->next; //"Erstes" auf nächstes Element (Wo Next-Zeiger von mit "Erstes" markiertem Element drauf gezeigt hat) schieben x->next = NULL; free(x); //Next-Zeiger von Element wo x drauf zeigt=NULL; Speicher freigeben for (i=1; i<=N-2; i++) { //Einlesen der Zahl aus dem ersten Element von q2 q = (Zeiger)malloc(sizeof(NODE)); //Neuer Speicher Anfordern q->zahl=Erstes->zahl; //Die zahl aus dem Element wo "Erstes" drauf zeigt in das Element wo q drauf zeigt schreiben q->next = NULL; //Next-Zeiger von Element wo q drauf zeigt=NULL Last ->next =q; //Next-Zeiger von Element wo Last drauf zeigt auf q Last = q; //Last Zeiger auf Element von q schieben //Löschen des ersten Elements von q2 x = Erstes; //Element wo "Erstes" drauf zeigt mit x markieren, Erstes = Erstes->next; //"Erstes" auf nächstes Element (Wo Next-Zeiger von mit "Erstes" markiertem Element drauf gezeigt hat) schieben x->next = NULL; free(x); //Next-Zeiger von Element wo x drauf zeigt=NULL; Speicher freigeben } //Ausgeben & Löschen des letzten Elements x = Erstes; //Element wo "Erstes" drauf zeigt mit x markieren printf("%5d \n",x->zahl); //Ausgeben der Zahl aus dem Element wo x drauf zeigt Erstes = Erstes->next; //"Erstes" auf nächstes Element (Wo Next-Zeiger von mit "Erstes" markiertem Element drauf gezeigt hat) schieben x->next = NULL; free(x); //Next-Zeiger von Element wo x drauf zeigt=NULL; Speicher freigeben N--; //Listenlänge um 1 verringern } } //Ausgeben des letzten Elements: if (Erstes->next=NULL) //Wenn Next-Zeiger wo "Erstes" drauf zeigt=NULL tue das: { printf("%5d \n",Erstes->zahl);//Ausgeben der Zahl aus dem Element wo "Erstes" drauf zeigt //Löschen des letzten Elements x = Erstes; //Element wo "Erstes" drauf zeigt mit x markieren Erstes = Erstes->next; //"Erstes" auf nächstes Element (Wo Next-Zeiger von mit "Erstes" markiertem Element drauf gezeigt hat) schieben x->next = NULL; //Next-Zeiger von Element wo x drauf zeigt=NULL free(x); //Speicher freigeben } if (First->next=NULL) //Wenn Next-Zeiger wo First drauf zeigt=NULL tue das: { printf("%5d \n",First->zahl);//Ausgeben der Zahl aus dem Element wo "First" drauf zeigt //Löschen des letzten Elements p = First; //Element wo First drauf zeigt mit p markieren First = First->next; //First auf nächstes Element (Wo Next-Zeiger von mit First markiertem Element drauf gezeigt hat) schieben p->next = NULL; //Next-Zeiger von Element wo p drauf zeigt=NULL free(p); //Speicher freigeben } system("Pause"); return 0; } Zitieren
konsti4u Geschrieben 12. Dezember 2009 Geschrieben 12. Dezember 2009 Code nicht angeschaut, aber unter debugger ist der Fehler hier: (gdb) n 114 x->next = NULL; free(x); //Next-Zeiger von Element wo x drauf zeigt=NULL; Speicher freigeben (gdb) n 115 N--; //Listenl�nge um 1 verringern (gdb) n 41 while (First->next!=NULL || Erstes->next!=NULL) (gdb) n Program received signal SIGSEGV, Segmentation fault. 0x080488b1 in main () at Aufgabe3fertig.c:41 Ich denke irg.wann zeigt das x auf First oder Erstes, du tust x freigeben, damit auch das worauf First oder Erstes hinzeigt und beim Zugriff auf das bereits gefreete Element gibts den segmentation fault. Zitieren
Klotzkopp Geschrieben 12. Dezember 2009 Geschrieben 12. Dezember 2009 while (First->next!=NULL || Erstes->next!=NULL) Diese Schleifenbedingung solltest du nochmal prüfen. Gegen Ende ist da nämlich First NULL, und der Zugriff auf First->next damit undefiniert. Zitieren
Empfohlene Beiträge
Dein Kommentar
Du kannst jetzt schreiben und Dich später registrieren. Wenn Du ein Konto hast, melde Dich jetzt an, um unter Deinem Benutzernamen zu schreiben.