Zum Inhalt springen

Zwei Queues zu einem Stack Fehler im Programm

Micha1087

Von Micha1087
in C und C++

 Teilen

Empfohlene Beiträge

Micha1087

Micha1087

Geschrieben
Geschrieben

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.

Micha

Aufgabe3fertig.rar

Link zu diesem Kommentar
Auf anderen Seiten teilen
konsti4u

konsti4u

Geschrieben
Geschrieben

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

Link zu diesem Kommentar
Auf anderen Seiten teilen
Klotzkopp

Klotzkopp

Geschrieben
Geschrieben
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.
Link zu diesem Kommentar
Auf anderen Seiten teilen
Klotzkopp

Klotzkopp

Geschrieben
Geschrieben
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.

Link zu diesem Kommentar
Auf anderen Seiten teilen
konsti4u

konsti4u

Geschrieben
Geschrieben

[*]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

Link zu diesem Kommentar
Auf anderen Seiten teilen
Micha1087

Micha1087

Geschrieben
  • Autor
Geschrieben

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!

Link zu diesem Kommentar
Auf anderen Seiten teilen
Klotzkopp

Klotzkopp

Geschrieben
Geschrieben
:-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.

Link zu diesem Kommentar
Auf anderen Seiten teilen
Micha1087

Micha1087

Geschrieben
  • Autor
Geschrieben

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;   

}

Link zu diesem Kommentar
Auf anderen Seiten teilen
Micha1087

Micha1087

Geschrieben
  • Autor
Geschrieben

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;   

}

Link zu diesem Kommentar
Auf anderen Seiten teilen
konsti4u

konsti4u

Geschrieben
Geschrieben

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

Link zu diesem Kommentar
Auf anderen Seiten teilen
Klotzkopp

Klotzkopp

Geschrieben
Geschrieben 

        //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.
Link zu diesem Kommentar
Auf anderen Seiten teilen
Micha1087

Micha1087

Geschrieben
  • Autor
Geschrieben
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!

Link zu diesem Kommentar
Auf anderen Seiten teilen
Micha1087

Micha1087

Geschrieben
  • Autor
Geschrieben 
        //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;   

}

Link zu diesem Kommentar
Auf anderen Seiten teilen
Micha1087

Micha1087

Geschrieben
  • Autor
Geschrieben

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;   

}

Link zu diesem Kommentar
Auf anderen Seiten teilen
konsti4u

konsti4u

Geschrieben
Geschrieben

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.

Link zu diesem Kommentar
Auf anderen Seiten teilen

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.

Gast
Auf dieses Thema antworten...

×   Du hast formatierten Text eingefügt.   Formatierung wiederherstellen

  Nur 75 Emojis sind erlaubt.

×   Dein Link wurde automatisch eingebettet.   Einbetten rückgängig machen und als Link darstellen

×   Dein vorheriger Inhalt wurde wiederhergestellt.   Editor leeren

×   Du kannst Bilder nicht direkt einfügen. Lade Bilder hoch oder lade sie von einer URL.

×
 Teilen
Zur Themenübersicht

Fachinformatiker.de, 2024 by SE Internet Services

fidelogo_small.png

Schicke uns eine Nachricht!

Fachinformatiker.de ist die größte IT-Community
rund um Ausbildung, Job, Weiterbildung für IT-Fachkräfte.

Links

Fachinformatiker.de App

Download on the App Store
Get it on Google Play

Kontakt

Hier werben?
Oder sende eine E-Mail an

Social media u. feeds

Jobboard für Fachinformatiker und IT-Fachkräfte

×
×
  • Neu erstellen...