IltisvdT

Daran lag es in der Tat! Danke sehr. Programm funktioniert nun wie gewünscht.

Ok, size haben vor das return gesetzt. Haben uns Index und size printen lassen, verstehen aber nicht, wo da das Problem liegen soll. Kannst du das etwas präzisieren?

Also das Problem mit dem sizeof haben wir gelöst. stack=malloc(a*sizeof(int)); hoffe das ist auch gut gelöst:D Nun bleibt das Problem, dass beim letzten Aufruf von top der falsche Wert geliefert wird. Es wird ja wahrscheinlich mit dem Wert des Index zusammenhängen, aber dieser ist bei den vorherigen Funktionsaufrufen ja richtig. Oder sehen wir das falsch?

Korrigiert mich, wenn ich irre, aber soweit ich weiß liefert malloc eine Zeiger auf eine Adresse wo ein freier speicherbereich der in malloc geforderten Größe beginnt. Und auf diese Adresse soll auch der stack-pointer zeigen. Ich weiß nicht genau, wo da vollkommen undefiniertes Verhalten sein soll. Aber ich habe nicht genug Ahnung davon um das so beurteilen zu können, aber speziell bei der ersten if-bedingung (aus der ja diese Zeile stammt) bin ich mir recht sicher....

Also gegeben sind Aufg1.c und stack.h, stack.c sollen wir selbst schreiben. a haben wir eingeführt um den anzufordernden Speicher jeweils um 5 zu erweitern. bin soll lediglich als eine Art Schalter fungieren, sodass der anfangs benötigte Speicher nur einmal bereitgestellt wird und die if-Bedingung nicht wieder gestartet wird. Ja, dass mit dem falschen Wert bei pop hatten wir auch. Das mit dem nicht allozierten Speicher haben wir uns schon gedacht, allerdings haben wir doch den benötigten Speicher immer vorher per malloc angefordert?! Die printfs sind lediglich um zuschauen, an welcher Stelle er abstürzt..

Hallo, ich mal wieder... Wir sollen ein stack als array speichern. Mit malloc den Speicherplatz in 5er Schritten allokieren und das ganze mit push, pop und top "verarbeiten". Dazu haben wir folgende Codes(z.T. vorgegeben bekommen): Aufg1.c #include <stdio.h> #include <stdlib.h> #include "stack.h" int main() { push(6); push(5); push(35); push(34); printf("Top: %d \n", top()); push(3); printf("Top: %d \n", top()); push(5); printf("Top: %d \n", top()); push(10); printf("Pop: %d \n", pop()); printf("Pop: %d \n", pop()); printf("Top: %d \n", top()); return 0; } stack.h: void push(int); int pop(); int top(); stack.c(unser Programm): #include <stdio.h> #include <stdlib.h> #include "stack.h" static int *stack; static int index=0; static int size=0,a=5,bin=0; void push(int element) { int i=size; int *temp; int b; if(bin==0) { stack=malloc(sizeof(stack[a])); bin=1; } if(size>a) { temp=malloc(sizeof(stack[a+5])); printf("oooo"); for(b=0; b<(size-1); b++) temp[b]=stack[b]; printf("test"); free(stack); stack=malloc(sizeof(stack[a+5])); printf("SSSSSSSSSSSS"); for(b=0; b<size; b++) stack[b]=temp[b]; free(temp); a+=5; } stack[index++]=element; size++; } int pop() { return stack [--index]; size--; } int top() { return stack[index-1]; } Das Programm stürzt immer ab. Und zwar nach dem printf("test"). Nehme ich die pops raus aus der Aufg1, dann passiert folgendes: Eigenartiger Weise stürzt er mal früher und mal später, an verschiedenen Stellen, u.a. direkt vor dem return (0) ab.. Wieso stürzt ein Programm an verschiedenen Stellen ab, ohne jegliche Veränderung und nur bei einem erneuten Aufruf? Und an welcher Stelle liegt unser Problem?

Ihr seid die besten....alles läuft...supergut. Bin total glücklich. Das war aber auch ne schwere Geburt..danke danke danke....

Habe jetzt in dem if, wo das break drin ist aus Tail->next ein Tail gemacht, jetzt stürzt es ab, wenn ein Eintrag länger ist als alle anderen. Kürzer geht, nur länger nicht...

@flashpixx Das hatte ich auch schon zu einem früheren Zeitpunkt überlegt. Aber im Moment ist es so, dass das ganze ding funktioniert, nur, dass er das erste Listenelemnt nicht mitsortiert. Und deswegen alles funktionierende in die Tone zu treten widerstrebt mir etwas. Mein sortiert einfügen ist jetzt so: void sortiert_einfuegen(struct stringList **liste, struct stringList *Neu) { struct stringList *Tail; struct stringList *Tail2=NULL; if (*liste == NULL) {*liste = Neu; printf("01\n"); } else { Tail=*liste; printf("02\n"); while ((strlen((Tail)->zeichen))<(strlen(Neu->zeichen))) {printf("06\n"); if(Tail->next==NULL) break; Tail2=Tail; Tail = Tail->next;} printf("07\n"); if(Tail2==NULL) { Neu->next=Tail; *liste=Neu; } else { Neu->next = Tail; Tail2->next=Neu; } } } das muss doch irgendwie funktionieren...nur sortiert er nciht richtig. Aber wenigstens stürzt er nciht ab...

so, jetzt hab ichs so: else { Tail=*liste; printf("02\n"); while ((strlen((Tail)->zeichen))<(strlen(Neu->zeichen))) {printf("06\n"); if(Tail->next==NULL) break; Tail2=Tail; Tail = Tail->next;} printf("07\n"); Neu->next = Tail; Neu=Tail2->next; Und es geht garnichts mehr...:-/ Die Einträge dürfen nie länger oder kürzer sein als der vorherige und sie werden auch, wenn ich sie ausgeben lasse nicht gespeichert. Es ist also nur der erste da. Und wie ich das am Anfang einfüge weiß ich noch nicht. Würde da ne if-Bedingung machen und die strlen von liste->zeichen mit der neu->zeichen vergleichen und wenn da rauskommt, dass der neue an den anfang muss, ist *liste=Neu und *liste->next der alte Eintrag von liste, den muss ich also auch irgendwo noch speichern. Is das vom Prinzip her richtig?

Jetzt hab ichs wieder auf Tail gebaut. void sortiert_einfuegen(struct stringList **liste, struct stringList *Neu) { struct stringList *Tail; if (*liste == NULL) {*liste = Neu; printf("01\n"); } else { Tail=*liste; printf("02\n"); while ((strlen((Tail)->zeichen)<strlen(Neu->zeichen)) && (strlen(((Tail)->next)->zeichen)>=strlen(Neu->zeichen))) {printf("06"); Tail = (Tail)->next;} Neu->next = Tail->next; Tail->next = Neu; } } Selbe Problematik...er hängt in der while-Schleife, wenn der 2. Eintrag länger ist als der erste und beim sortieren nimmt er den ersten nicht mit. Ich hab jetzt den Speicher freigegebn mit free(loesch) und free(loesch->zeichen), das sind ja die beiden, die ich mit malloc angefordert habe, geht das?

Habe nun die loeschen fkt geändert. Habe einfach die Zeile mit liste=tmp3 rausgeschmissen und voila, es funktioniert. Den Speicher freigeben mache ich mit free(zeichenkette), oder? Ich bin so glücklich, weil das Programm so gut wie läuft, nur das sortieren funktioniert nicht. Und zwar stürzt das Programm ab, wenn die zweite eingabe länger ist als die erste, danach ist alles egal. Er printet dann einmal die 02 und dann hängt er, also macht ihm die while-schleife probleme. die dritte kann ruhig länger sein als die zweite und erste usw. Außerdem sortiert er die erste eingabe nicht. Also wenn ich zehn eingaben machen sortiert er die richtig der länge nach, nur die erste bleibt fest. Außerdem tut er sich schwer beim zahlen sortieren, aber das ist nciht so wichtig, denke ich. Vermutlich lassen sich ja die beiden Fehler auf den selben Fehler im Code begründen. Anbei der Code für die sortieren-Fkt: void sortiert_einfuegen(struct stringList **liste, struct stringList *Neu) { struct stringList *Tail; if (*liste == NULL) {*liste = Neu; printf("01\n"); } else { printf("02\n"); while ((strlen((*liste)->zeichen)<strlen(Neu->zeichen)) && (strlen(((*liste)->next)->zeichen)>=strlen(Neu->zeichen))) {printf("06"); *liste = (*liste)->next;} Neu->next = (*liste)->next; (*liste)->next = Neu; } } Und zu dem einrücken: Ich schicke das mit nem Kumpel immer hin und her und scheinbar passen die editoren nciht so gut zusammen und das haut alles durchnander. aber ich gebe mir größte Mühe mich zu bessern.

So, haben unsere loeschen-fkt geändert. Sieht nun so aus: void loeschen(struct stringList **liste, char *zeichenkette) { struct stringList *loesch= *liste; // struct stringList *tmp2= *liste; struct stringList *tmp3= *liste; if (strcmp(zeichenkette, tmp2->zeichen) ==0){ loesch=tmp2->next; free(liste); // *liste=loesch; printf("1."); } else { while(strcmp(zeichenkette, tmp2->zeichen) !=0){ tmp3=tmp2; tmp2=tmp2->next; if(tmp2==NULL) printf("nicht vorhanden"); if(strcmp(zeichenkette, tmp2->zeichen) ==0){ loesch=tmp3->next; tmp3->next=tmp3->next->next; *liste=tmp3; free(loesch); printf("2."); break; }; } } }Er löscht auch brav das angegebene element, jedoch löscht er auch alle vorherigen, bis auf den direkten Vorgänger. zB ist die Liste 1 2 3 4 5 und er soll die 4 löschen, dann bleiben 3 und 5 über. Das liegt ja daran, dass wir liste=tmp3 speichern und tmp3 ja erst bei dem direkten Vorgänger beginnt. Wie kann man das lösen?

Die ausgabe läuft nun sauber, habe das fgets in die if gepackt. Um das erste Element zu löschen habe ich eine weiter if-Prüfung eingebaut und darin versucht, den Zeiger auf das 2. Element mittels "Hilfsvariable" zu sichern, dann den Speicherplatz des ersten Elements freizugeben und anschließend das erste Element gleich dem 2. zusetzen. Ähnlich habe ich eine weitere Variable eingefügt um mir den Vorgänger des zulöschenden Elements zu merken. Ich denke, dass er in beiden Fällen nicht aus der while-Schleife rauskommt, da er kein Ende findet.. Seh ich das Problem richtig? und wenn wie schaffe ich es dass er ein Ende findet? #ifndef a_h #define a_h #include <stdio.h> #include <stdlib.h> #include <string.h> struct stringList { struct stringList *next; char *zeichen; }; struct stringList *neuesElement(char *zeichenkette) { struct stringList *Neu; Neu = malloc(sizeof(struct stringList)); Neu->zeichen=malloc(strlen(zeichenkette)+1); Neu->next = NULL; strcpy(Neu->zeichen,zeichenkette); return Neu; } void sortiert_einfuegen(struct stringList **liste, struct stringList *Neu) { struct stringList *Tail; if (*liste == NULL) {*liste = Neu; printf("01");} else { Tail = *liste; printf("02"); while (Tail->next != NULL) Tail = Tail->next; Neu->next = Tail->next; Tail->next = Neu; } } void ausgabe(struct stringList **liste) { struct stringList *Tail = *liste; while (Tail != NULL) { printf("%s\n", Tail->zeichen); Tail = Tail->next; } } int suchen(struct stringList **liste, char *zeichenkette ) { int i=1; struct stringList *tmp = *liste; while(strcmp( zeichenkette, tmp->zeichen ) != 0 ) { tmp = tmp->next; i++; if( tmp == NULL ) { printf("nicht vorhanden"); return(-1); } } printf("sucheingabe war%s i=%d", zeichenkette, i); return(i); } void loeschen(struct stringList **liste, char *zeichenkette) { struct stringList *loesch= *liste; // struct stringList *tmp2= *liste; struct stringList *tmp3= *liste; if (strcmp(zeichenkette, tmp2->zeichen) ==0){ loesch=tmp2->next; free(tmp2); // tmp2=loesch; } else { while(strcmp(zeichenkette, tmp2->zeichen) !=0){ tmp3=tmp2; tmp2=tmp2->next; if(tmp2==NULL) printf("nicht vorhanden"); if(strcmp(zeichenkette, tmp2->zeichen) ==0){ loesch=tmp3->next; tmp3->next=tmp3->next->next; free(loesch); }; } } } #endif

Bin etwas weiter gekommen.. zum Einen hakt es immernoch an der Ausgabe des letzten Elements, finde aber einfach keinen Fehler:/ Habe nun eine Header-Datei draus gemacht und die Funktionen kann ich auch mit einer weiteren Datei aufrufen. Nun wollte ich mich an das loeschen eines Elements machen, nur leider wird immer das darauffolgende Element gelöscht, denke es liegt an der while-Schleife die tmp2 halt einen zuweit setzt, komme aber nicht drauf wie ich das verhindere... habe es mit einem weiteren strcmp in einer if-Funktion versucht, aber das ändert nichts am Problem.. hier mal die beiden Codes: Header: #ifndef a_h #define a_h #include <stdio.h> #include <stdlib.h> #include <string.h> struct stringList { struct stringList *next; char *zeichen; }; struct stringList *neuesElement(char *zeichenkette) { struct stringList *Neu; Neu = malloc(sizeof(struct stringList)); Neu->zeichen=malloc(strlen(zeichenkette)+1); Neu->next = NULL; strcpy(Neu->zeichen,zeichenkette); return Neu; } void sortiert_einfuegen(struct stringList **liste, struct stringList *Neu) { struct stringList *Tail; if (*liste == NULL) {*liste = Neu; printf("01");} else { Tail = *liste; printf("02"); while (Tail->next != NULL) Tail = Tail->next; Neu->next = Tail->next; Tail->next = Neu; } } void ausgabe(struct stringList **liste) { struct stringList *Tail = *liste; while (Tail != NULL) { printf("%s\n", Tail->zeichen); Tail = Tail->next; } } int suchen(struct stringList **liste, char *zeichenkette ) { int i=1; struct stringList *tmp = *liste; while(strcmp( zeichenkette, tmp->zeichen ) != 0 ) { tmp = tmp->next; i++; if( tmp == NULL ) { printf("nicht vorhanden"); return(-1); } } printf("sucheingabe war%s i=%d", zeichenkette, i); return(i); } void loeschen(struct stringList **liste, char *zeichenkette) { struct stringList *loesch; struct stringList *tmp2= *liste; while(strcmp(zeichenkette, tmp2->zeichen) !=0){ tmp2=tmp2->next; printf("SSSSSSSSSSSSS%s",tmp2->zeichen); if(tmp2==NULL) printf("nicht vorhanden"); if(strcmp(zeichenkette, tmp2->zeichen) ==0){ loesch=tmp2->next; tmp2->next=tmp2->next->next; free(loesch); }; } } #endif und die .c-Datei: #include "a2.h" int main (void) { char str[80]; char such[80]; char loesch[80]; int z; z=5; struct stringList *Neu; struct stringList *liste=NULL; while(1) { fgets(str, 30, stdin); if (z != 0) { Neu = neuesElement(str); sortiert_einfuegen(&liste, Neu); z--; } else break; } printf("03"); ausgabe(&liste); //printf("sucheingabe"); //fgets(such, 30, stdin); //suchen(&liste, such); printf("loescheingabe"); fgets(loesch, 30, stdin); loeschen(&liste, loesch); ausgabe(&liste); return(0); }

superduper...in der ausgabe hakt er noch...und zwar gibt er den letzten Eintrag nicht aus. Das kann natürlich auch an der eingabe liegen. Aber gott sei dank läuft es schonmal so halbwegs. Dann muss ich morgen eine löschen funktion machen und mich um das sortieren kümmern. Bis hierher schonmal vielen vielen dank

WOW Vielen Dank schonmal...er kompiliert es ohne Probleme. Leider stürzt das Programm ab. Sieht so aus: #include <stdio.h> #include <stdlib.h> #include <string.h> struct stringList { struct stringList *next; char *zeichen; }; struct stringList *neuesElement(char *zeichenkette) { struct stringList *Neu; Neu = malloc(sizeof(struct stringList)); Neu->zeichen=malloc(strlen(zeichenkette)+1); Neu->next = NULL; strcpy(Neu->zeichen,zeichenkette); return Neu; } void sortiert_einfuegen(struct stringList **liste, struct stringList *Neu) { struct stringList *Tail; if (liste == NULL) {*liste = Neu; printf("01");} else { Tail = *liste; printf("02"); while (Tail->next != NULL) Tail = Tail->next; Neu->next = Tail->next; Tail->next = Neu; } } void ausgabe(struct stringList **liste) { struct stringList *Tail = *liste; while (Tail != NULL) { printf("%s\n", Tail->zeichen); Tail = Tail->next; } } int suchen(struct stringList **liste, char *zeichenkette ) { int i=1; struct stringList *tmp = *liste; while(strcmp( zeichenkette, tmp->zeichen ) != 0 ) { //hier meint er, dass liste keine structure sei tmp = tmp->next; // und hier i++; if( tmp == NULL ) { return(-1); } else return(i); } } int main (void) { char str[80]; int z; z=5; struct stringList *Neu; struct stringList *liste=NULL; while(1) { fgets(str, 30, stdin); if (z != 0) { Neu = neuesElement(str); sortiert_einfuegen(&liste, Neu); z--; } else break; } printf("03"); ausgabe(&liste); return(0); } er printet das 02, nicht aber das 01 und dann is auch Feierabend. Woran könnte das denn wieder liegen?! :'(

Aaaah, ok...ich verstehe was du meinst und sehe es sogar. Kann aber die ausgabe und sortiert_einfuegen so lassen, oder? Habs jetzt so: Neu = malloc(sizeof(struct stringList))+malloc(sizeof((char *)zeichenkette)); Da hat er aber Probleme, die beiden void Zeiger zu addieren. Aber Neu soll doch ein Zieger sein, der auf einen Speicherbereich zeigt, in den die Struktur mitsamt der eingabe reinpasst, richtig? Wo ist dann mein Fehler da? Ja, das stimmt. Habe mit Kommilitonen gesprochen, wir sollen uns eine Ordnung ausdenken (zB Alphabet). Habe eine suchen-Funktion geschrieben: int suchen(struct stringList **liste, char *zeichenkette ) { int i=1; while(strcmp( zeichenkette, *liste->zeichen ) != 0 ) { *liste = **liste->next; i++; if( *liste == NULL ) { return(-1); } if(strcmp(zeichenkette, *liste->zeichen ) == 0) return(i); } }Beim kompilieren sagt er aber, dass ich den member zeichen (und next und nochmal zeichen) anfordere aus etwas, dass keine structure ist. Aber das gebe ich doch da vor bei int suchen(struct stringList **liste...

statt char zeichen[80] hab ich nun (char *) zeichen Wenn ich die Zeile wegnehme und in die main einfüge sind sie für die anderen Funktionen nicht verfügbar. Wenn ich sie aber in jede Funktion einfüge, kann ich sie auch gleich global lassen?! Ich soll ihn nicht casten, soll ich also das: (struct stringList *) ganz weglassen? Speicherreservierung so? malloc(sizeof(struct stringList)+sizeof(zeichenkette)) Ich glaube aber, dass es darauf hinausläuft. Hab mich in der Aufgabenstellung auch gewundert, wieso die sortiert einfügen heißt. Aber ich denke, da nur das Element und die Liste aus der main an die Funktion übergeben werden, dass das hintendranhängen damit gemeint ist. Sieht gut aus. Auch schon erledigt durch ausgabe(&liste) und sortiert_einfuegen(&liste, Neu). Schreibe grade an der Suchen-Funktion...bin mal gespannt was daraus wird...

Ich habe es nochmal etwas geändert weil ich gesehen habe, dass da zwei & gefehlt haben. #include <stdio.h> #include <stdlib.h> #include <string.h> struct stringList { struct stringList *next; char zeichen[80]; }; struct stringList *liste = NULL; struct stringList *neuesElement(char *zeichenkette) { //richtige Form struct stringList *Neu; Neu = (struct stringList *) malloc(sizeof(struct stringList)); Neu->next = NULL; strcpy(Neu->zeichen,zeichenkette); return Neu; } void sortiert_einfuegen(struct stringList **liste, struct stringList *Neu) { //void sortiert_einfuegen (struct stringList **liste, struct stringList *new) struct stringList *Tail; if (liste == NULL) *liste = Neu; else { Tail = *liste; while (Tail->next != NULL) Tail = Tail->next; Neu->next = Tail->next; Tail->next = Neu; } } void ausgabe(struct stringList **list) { //void ausgabe (struct stringList **list) struct stringList *Tail = liste; while (Tail != NULL) { printf("%s\n", Tail->zeichen); Tail = Tail->next; } } int main (void) { char str[80]; int z; z=5; struct stringList *Neu; while(1) { fgets(str, 30, stdin); if (z != 0) { Neu = neuesElement(str); sortiert_einfuegen(&liste, Neu); z--; } else break; } ausgabe(&liste); return(0); } Das lässt sich kompilieren und macht keine Mucken, stürzt aber nach der Eingabe des ersten Elements ab. Habe ein paar printf's eingebaut und so wie es aussieht hängt er in der while-Schleife der sortiert_einfuegen Funktion. Habt ihr da Ideen?

Es ist sicherlich richtig, dass man so weniger lernt. Allerdings ist unsere Vorlesung nicht wirklich hilfreich und die Bücher und Informationem im Internet helfen zwar weiter, reichen aber auch nicht aus um es zum laufen zukriegen. Damit wir aber überhaupt weiterkommen, haben wir uns etwas ähnliches rausgesucht, um nachzuvollziehen (so gut es halt geht), wie die Aufgabe anzugehen ist. Ich habe es nochmal teilweise neu angefangen und bin soweit #include <stdio.h> #include <stdlib.h> #include <string.h> struct stringList { struct stringList *next; char zeichen[80]; }; struct stringList *liste = NULL; struct stringList *neuesElement(char *zeichenkette) { //richtige Form struct stringList *Neu; Neu = (struct stringList *) malloc(sizeof(struct stringList)); Neu->next = NULL; strcpy(Neu->zeichen,zeichenkette); return Neu; } void sortiert_einfuegen(struct stringList **liste, struct stringList *Neu) { //void sortiert_einfuegen (struct stringList **liste, struct stringList *new) struct stringList *Tail; if (liste == NULL) *liste = Neu; else { Tail = *liste; while (Tail->next != NULL) Tail = Tail->next; Neu->next = Tail->next; Tail->next = Neu; } } void ausgabe(struct stringList **list) { //void ausgabe (struct stringList **list) struct stringList *Tail = liste; while (Tail != NULL) { printf("%s\n", Tail->zeichen); Tail = Tail->next; } } int main (void) { char str[80]; int z; z=5; struct stringList *Neu; while(1) { fgets(str, 30, stdin); if (z != 0) { Neu = neuesElement(str); z--; } else break; } return(0); } Das lässt sich kompilieren und macht keine Mucken. Es gehlt jetzt noch die suchen und löschen funktionen. Dazu gleich mehr. Ich kann nun leider in meiner main die zB die sortiert_einfuegen nciht öffnen. In meinem "alten" Programm sah das ja so aus: liste = sortiert_einfuegen(liste, Neu); Und das stand im if in der main. wenn ich das mache und kompilieren will sagt er Sieht denn das ohne den letzten Aufruf halbwegs passabel aus? denn ich denke ich blicke langsam dahinter wie es funktioniert. Nur diese Doppelpointer find ich noch recht schwierig, aber auch da muss es wahrscheinlich erstmal klick machen...

Hi, ich brauche erneut eure Hilfe. Geht um folgende Aufgabe Ich habe im Netz folgendes gefunden: #include <stdio.h> #include <stdlib.h> #include <string.h> struct stringList { char zeichen[80]; struct stringList *next; }; struct stringList *liste = NULL; struct stringList *neuesElement(char *zeichenkette) { //richtige Form struct stringList *Neu; Neu = (struct stringList *) malloc(sizeof(struct stringList)); if (Neu == NULL) { printf("Speicher voll, Abbruch...\n"); exit (1); } Neu->next = NULL; strcpy(Neu->zeichen,zeichenkette); return Neu; } struct stringList *einfuegen_sort(struct stringList *liste, struct stringList *Neu) { //void sortiert_einfuegen (struct **liste, struct stringList *new) struct stringList *Tail; if (liste == NULL) liste = Neu; else { Tail = liste; while (Tail->next != NULL) Tail = Tail->next; Neu->next = Tail->next; Tail->next = Neu; } return liste; } void ausgabe(struct stringList *list) { //void ausgabe (struct stringList **list) struct stringList *Tail = liste; while (Tail != NULL) { printf("%s\n", Tail->zeichen); Tail = Tail->next; } } int main (void) { char str[80]; int z; z=5; struct stringList *Neu; while(1) { fgets(str, 30, stdin); if (z != 0) { Neu = neuesElement(str); liste = einfuegen_sort(liste, Neu); z--; } else break; } printf("\n"); ausgabe(liste); return 0; } Das ist ja leider noch nciht ganz das, was ich machen soll. Habe das in das geändert und ergänzt: #include <stdio.h> #include <stdlib.h> #include <string.h> struct stringList { char zeichen[80]; struct stringList *next; }; struct stringList *liste = NULL; struct stringList *neuesElement(char *zeichenkette) { //richtige Form struct stringList *Neu; Neu = (struct stringList *) malloc(sizeof(struct stringList)); Neu->next = NULL; strcpy(Neu->zeichen,zeichenkette); return Neu; } struct stringList *einfuegen_sort(struct **liste, struct stringList *Neu) { //void sortiert_einfuegen (struct **liste, struct stringList *new) struct stringList *Tail; if (liste == NULL) liste = Neu; else { Tail = liste; while (Tail->next != NULL) Tail = Tail->next; Neu->next = Tail->next; Tail->next = Neu; } return liste; } void ausgabe(struct **list) { //void ausgabe (struct stringList **list) struct stringList *Tail = liste; while (Tail != NULL) { printf("%s\n", Tail->zeichen); Tail = Tail->next; } } int suchen (struct stringList **liste, char * zeichenkette); int i=1; while(strcmp(Tail->liste,zeichenkette)!=0) { Tail=Tail->next; i++; } if(strcmp(Tail->liste,zeichenkette)==0) return(i); else return(-1); void loeschen(struct stringList **liste, char * zeichenkette); int i; struct stringList tmp; if(suchen(struct stringList **liste, char * zeichenkette)!=-1) { while(suchen(struct stringList **liste, char * zeichenkette)>(i-1)) { Tail=Tail->next; i++; } tmp=Tail->next; Tail=Tail->next->next; free(tmp); } else (printf("Eintrag ist nicht vorhanden"); int main (void) { char str[80]; int z; z=5; struct stringList *Neu; while(1) { fgets(str, 30, stdin); if (z != 0) { Neu = neuesElement(str); liste = einfuegen_sort(liste, Neu); z--; } else break; } printf("\n"); ausgabe(liste); return 0; } Leider geht nun garnichts mehr. Es ist ja auch noch keine Header-Datei. Aber ich dachte, ich muss es erstmal als Programm zum laufen kriegen, bevor ich daraus ne header-Datei mache. Mich wundert unter anderem, dass er in meiner Version meckert, dass Tail undeclared ist und in der Ursprungsversion nicht. Vielen Dank schonmal

Hallo, ersteinmal schöne Restweihnachten. wir haben folgende Aufgabe gekriegt: Bisher sieht unser Programm so aus: #include <stdio.h> #include <stdlib.h> #include <string.h> void allocMem (int length, void **ptrptr, int f) { double *feld[length]; feld=(double *) malloc(length); memset(*feld, 0 ,length); feld[f]=**ptrptr; } void eingabe (int i, int *wert) { int a; printf("%d. Zahl eingeben", i); scanf("%d", &a); *wert=a; } int main() { int i=1,groesse,*zahl; printf("Geben Sie die gewuenschte Groeße ein"); scanf("%d", &groesse); while(i<groesse) { allocMem(groesse , eingabe(i, &*zahl),i); i++; } return(0); } Zum einen spuckt er einige Fehler beim kompilieren aus. In der main funktioniert die Übergabe an die allocMem nicht so, wie sie sollte. Er klagt über Probleme, dass er double * übergibt usw...Außerdem steht ja in der Aufgabe dieser Prototyp und da wird ja der Zähler nicht übergeben. meint ihr es ist schlimm, wenn man deren Prototyp ändert? Vielen Dank schonmal

Ich überlege grade, ob man das überhaupt muss. Würdest du die Aufgabe so verstehen? Kann man so verstehen, muss man aber nciht, oder?

Hi royale, ich sitz an der selben Aufgabe. Ich mache sie aber ganz anders. In den HÜ Folien steht als Tipp eine Adjazenzmatrix. Die sagt dir praktisch, welche Knoten miteinander verbunden sind. Vom Ablauf her mache ich es so: perm gibt eine Möglichkeit aus, die Zaheln 1 bis 8 anzuordnen. eine funktion (bei mir heißt sie pruefung) prüft mithilfe der adjazenzmatrix, ob die verbundenen Zahlen um mehr als 1 verschieden sind. Dann printet die funktion ausgabe das. Und perm geht von vorne los mit der nächsten Anordnungsmöglichkeit. Es läuft bei mir auch noch nciht richtig, aber ich denke, das ist ne Ecke überishctlicher als deins. Zumindest ist es das bei mir.