Zum Inhalt springen

Micha1087

Mitglieder
  • Gesamte Inhalte

    16
  • Benutzer seit

  • Letzter Besuch

  1. Für alle die mir geholfen haben: Vielen Dank! Ich poste hier auch nochmal den fertigen funktionierenden 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(" Listenl\x84nge und f\x81llt diese mit den Zahlen 1-2-3-4.... Diese Zahlen\n"); printf(" werden dann mit Hilfe von Umschichtprozessen \x81\x62\x65r ein zweites Queue \n"); printf(" in der Reihenfolge eines Stacks ausgegeben\n Bitte geben sie die L\x84nge ein: "); // Abfragen scanf("%d",&N); // und Einlesen wie lang die Liste wird printf(" \n Der Stack sieht folgenderma\xE1\x65n aus: \n\n"); //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 (N>=2) //Solange die Länge der Liste größer oder gleich 2 ist 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(" \xBA %i \xBA\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(" \xBA %i \xBA\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!=NULL) //Wenn "Erstes" nicht NULL ist tue das: { printf(" \xBA %i \xBA\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!=NULL) //Wenn First nicht NULL ist tue das: { printf(" \xBA %i \xBA\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 } printf(" \xC8\xCD\xCD\xCD\xBC\n\n"); system("Pause"); return 0; }
  2. Habs gelöst! Hab einfach die folgenden Buchstaben auch mit ASCII Zeichen dargestellt! Ist zwar nicht sooo elegant aber ich denke es reicht aus! über sieht z.B. jetzt so aus: \x81\x62\x65r
  3. Habe mein Programm sowei fertig! Jetzt bin ich grade an den Umlauten am tüfteln! Hab mich entschieden es mithilfe von z.B. \x81 für ü zu lösen! Nur mein Problem ist, dass wenn ich nun als Beispiel "über" schreiben will er mir das nicht als ü schreibt weil vermutlich \x81e ein anderes Zeichen ist. Wie kann ich das lösen ohne das ich ein Leerzeichen üm Wort machen muss?
  4. 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; }
  5. Danke schonmal für den Tip! Jetzt komm ich ein Printf weiter :-D
  6. 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; }
  7. Ich soll mithilfe von zwei Queues ein stack machen!
  8. 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!
  9. 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; }
  10. 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; }
  11. 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!
  12. Code (hab ich eben vergessen) Aufgabe3fertig.rar
  13. 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.
  14. 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!
  15. In Zeile 23 hab ich doch mit "First=Last;" Last auf das erste Element gesetzt! Was muss ich denn dann ändern das es funktioniert?

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.

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