Zwei Queues zu einem Stack



  • ;fricky schrieb:

    Mike1087 schrieb:

    Also wenn das hier noch irgend ein Programmiergott sieht! Wär es nicht möglich ein simplen code zum erstellen einer Queue zu posten?

    auf doof:

    #define SIZE <beliebiges hier einsetzen>
    
    unsigned char mem[SIZE];
    int r, w;
    
    int put (unsigned char v)
    {
        if ((w+1)%SIZE == r)
            return -1;  // voll
        mem[w=(w+1)%SIZE] = v;
        return 0;
    }
    
    int get (void)
    {
        if (w == r)
            return -1;   // leer
        return mem[r=(r+1)%SIZE];
    }
    

    ^^geht bestimmt noch etwas einfacher, darfst mich aber trotzdem 'gott' nennen *fg*
    🙂

    Was soll das denn sein? Also das hat mit dem was ICH zu Listen gelernt habe so gut wie garnichts zu tun!



  • µngbd schrieb:

    #define Put    q = (Zeiger)malloc(sizeof(NODE)); q->next = NULL; q->zahl=i+2; Last ->next =q;
    

    Was soll denn das? 😕

    Das ist das Hinzufügen eines neuen Listenknotens! Hab ich als Put definiert damit man im Prgramm sich die Schreibarbeit erspart und gleich Put nehmen kann!



  • Irgendwo ist da ein Fehler! Ich finde Ihn nicht!
    Mein Compiler sagt "Zugriffsverletzung" was heist das?

    #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;   //First=Anker, Last=Zeiger auf das Ende der Liste, q=Zeiger auf ein neues Element, p=Entnahmezeiger
    
    void main ()                //Hauptprogramm
    {
         int N, i;
         First = NULL;
    
         printf("Listenlaenge:"); // Abfragen und Einlesen wie lang die Liste wird
         scanf("%d",&N);
    
         //Füllen von Queue1
         First = (Zeiger) malloc(sizeof(NODE)); First->zahl=1; First->next = NULL; First=Last;
         for (i=2; i<=N; i++)
         {
             q = (Zeiger)malloc(sizeof(NODE)); 
             q->zahl=i; 
             q->next = NULL; 
             Last ->next =q; 
             Last = q;
         }
    
         //Ausgeben der Daten von Queue1
    
         printf("In Queue 1 wurden folgende Daten geschrieben:");
    
         for (i=0; i<=N; i++)
         {
             p = First; 
             printf("%5d \n",p->zahl); 
             First = First->next; 
             p->next = NULL; 
             free(p);
         }
    
        system("Pause");
        return 0;   
    }
    


  • So! Programm soweit fertig! Nur es kommt halt immernoch diese Fehlermeldung! Wenn mir da einer weiterhelfen könnte wär das echt sehr nett!

    #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("Listenlaenge:");  // Abfragen
         scanf("%d",&N);           // und Einlesen wie lang die Liste wird
    
         //Füllen von Queue1
         First = (Zeiger) malloc(sizeof(NODE)); First->zahl=1; First->next = NULL; First=Last;
         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; Erstes->next = NULL; Erstes=Letztes;
            //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); 
            }
            //Letztes Element von q1
            printf("%5d \n",First->zahl);
            //Löschen des letzten Elements
            p = First;
            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; First->next = NULL; Erstes=Letztes;
              //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); 
              }
              //Letztes Element von q2
              printf("%5d \n",Erstes->zahl);
              //Löschen des letzten Elements
              x = Erstes;
              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;   
    }
    


  • Jetzt haben wir dir Abhandlungen geschrieben, Links gesucht und zwei fast fertige Lösungen gebaut: und du wirfst immer noch mit dem Spaghetticode um dich. Ich geb's auf.



  • Was sollen denn die zwei fast fertigen Lösungen sein?



  • Ich habe nicht alles durchgesehen, aber hier guck mal:

    First = (Zeiger) malloc(sizeof(NODE)); First->zahl=1; First->next = NULL; First=Last;
    

    Du setzt First auf 0, damit ist die von malloc zugeteilte Adresse nicht mehr erreichbar.
    Außerdem: den Rückgabewert von malloc stets prüfen, und nicht casten.



  • Mike1087 schrieb:

    Was soll das denn sein? Also das hat mit dem was ICH zu Listen gelernt habe so gut wie garnichts zu tun!

    das was du wolltest, ein 'simpler code für eine queue', nix mit listen.
    🙂



  • Hello! egeeebb interesting egeeebb site!



  • Hello! bdcgged interesting bdcgged site!


Anmelden zum Antworten