Einfach Verkettete Liste von hinten durchlaufen!
-
Hi!
Ich habe eine Frage wie der Titel vielleicht schon zeigt!
Wie kann ich eine einfach verkettete Liste von hinten durchlaufen...??Die Liste hat diese Struktur:
int Wert;
Liste next;?????
-
gar nicht, deswegen ist sie nur einfach verkettet, weil man sie nur in einer Richtung durchlaufen kann.
-
supertux schrieb:
gar nicht
sag niemals nie...
void show_reverse (struct list *l) { if (l->next) show_reverse (l->next); printf ("%d\n", l->wert); }...geht davon aus, dass der letzte pointer 0 ist.
-
Auf so eine Rekursion habe ich tatsächlich nicht dran gedacht. Aber so toll finde ich diesen Ansatz auch nicht, denn man geht irgendwie die Liste trotzdem von vorne durch.
-
Ja so in der art hab ich das auch schon probiert!
Das Problem ist nur das ich zwei listen verarbeiten muss!
Das heißt das beide listen von hinten durchlaufen werden müssen und zuerst die obersten Elemente vergleichen bis nach unten!Das bekomm ich mit deinem Ansatz auch nicht gebacken....
-
Thes-One schrieb:
Ja so in der art hab ich das auch schon probiert!
Das Problem ist nur das ich zwei listen verarbeiten muss!
Das heißt das beide listen von hinten durchlaufen werden müssen und zuerst die obersten Elemente vergleichen bis nach unten!
Das bekomm ich mit deinem Ansatz auch nicht gebacken....hinten, oben, unten ???
vielleicht so?void compare_reverse (struct list *l, struct list *m) { if (l->next && m->next) compare_reverse (l->next, m->next); if (l->wert < m->wert) printf ("l kleiner m\n"); else if (l->wert > m->wert) printf ("l groesser m\n"); else printf ("l gleich m\n"); }
-
Das funktioniert doch auch nur mit 2 gleichlangen Listen!
Wenn ich jetzt angenommen 2 Listen haben mit diesen Element -->A : (1,2,3)
B : (2,3,4,5,6,7,8,9)Dann kann ich so an das Ende der Liste kommen!
if (a->next)
blah(a->next,b);
if (b->next)
blah(a,b->next);1.Jetzt sind beide Listen am Ende!
A bei 3 und B bei 9!Nur jetzt tritt mein Problem auf das erst B "zurück" traversiert wird und dann A!
Also geht B erst wieder zur 2 und dann A zur 1!Ich muss das aber irgendwie Parallel hinbekommen, nur wie???
-
Thes-One schrieb:
A : (1,2,3)
B : (2,3,4,5,6,7,8,9)mal angenommen du hast 9/3 8/2 und 7/1 verglichen, wie soll's dann weitergehen?
übrigens, nimm doch eine doppelte verkettung. wenn du in der forensuche mal nach CONTAINING_RECORD suchst, findest du eine coole listenstruktur basierend auf makros, mit der du jede beliebige struct listenfähig machen kannst.
-
Dann bleibt A bei der 1 und B geht weiter runter!
Ja werde mir das gleich mal anschauen nur leider ist eine einfach verkettete Liste vorgegeben!
-
Thes-One schrieb:
Dann bleit A bei der 1 und geht weiter runter!
wohin? 1 ist doch das erste element.
-
wie wärs, wenn du einfach first und last umdefinierst und damit first last ist und last first
*duck*
ok, blöde Antwort, aber ohne die Rekursion hast eigentlich keine Chance
-
Ich will es ja mit der Rekursion machen doch das Problem ist doch kalr oder???
Ich muss in zwei listen bis an das letzte Element absteigen und dann Element für Element in beiden Listen bis zum Anfang hochsteigen!
Das ist das Problem!
Ich bekomme das einfach nicht hin!
-
Das Problem ist weder klar noch kalr
Guck dir die Rekursion genauer an, da steht es ja. Aber wir können nicht hellsehen und deinen Code bzw. was du versucht hast, kennen wir nicht, also können wir nur raten, was du falsch machst. Hilf uns dir zu helfen
-
Ja würd ich an deiner Stelle mal die vorherigen Posts lesen!
Das Problem ist das ich zwei Listen in einer Funktion bearbeiten muss und zwar von hinten!
Und nochmal:
Wenn ich eine Menge A und B haben mit den folgenden Elementen!
A->(1,2,3)
B->(1,2,3,4)Muss ich in der Funktion zu erst die beiden Listen bis zum Ende durchlaufen, dann will ich die beiden Elemente vergleichen und dann eine Operation durchführen!
Wenn ich es aber so mache wie schon gesagt wurde , läuft als erstes die Liste B zurück zum ersten Element und dann A und genau das will ich nicht!
Ich will das beide Parallel laufen!
Soll heißen ich will 4 mit 3 , 3 mit 2 und 2 mit 1 und 1 mit 1 vergleichen,(bis halt beide Listen wieder am Anfang sind)
Jetzt verstanden?????
-
Thes-One schrieb:
Soll heißen ich will 4 mit 3 , 3 mit 2 und 2 mit 1 und 1 mit 1 vergleichen,(bis halt beide Listen wieder am Anfang sind)
dann dupliziere in der kürzeren liste das erste element so lange, bis sie so viele elemente hat wie die lange liste (immer vorn anhängen) und dann nimm z.b. diese rekursive funktion da ^^
-
Thes-One schrieb:
Ja würd ich an deiner Stelle mal die vorherigen Posts lesen!
*ich* hab alle Post gelesen, sogar welche geschrieben, nur du kannst dich nicht so gut ausdrucken, das ist aber ein anderes Problem.Dass du die Liste paralell durchlaufen willst, ist uns schon klar, es gab sogar eine Antwort darauf, die Antwort von "kobold der 5. dimension" (Antwort Nummer 6).
Thes-One schrieb:
Soll heißen ich will 4 mit 3 , 3 mit 2 und 2 mit 1 und 1 mit 1 vergleichen,(bis halt beide Listen wieder am Anfang sind)
1 mit 1? Wieso soll 1 mit 1 verglichen werden? Wenn die eine Liste weniger Elemente enthält als die andere, dann wird immer passieren, dass eine Liste fertig ist, während die andere noch Elemente hat.
Du sagst "Ich bekomme das einfach nicht hin!" und ich sagte, dass wir auch keine Ahnung haben, warum du es nicht schaffst, und zwar weil wir keine Ahnung haben, was *du* bereits versucht hast. Wie sieht deinen Code aus? Vielleicht liegt der Fehler an einer anderen Baustelle und du hast es nicht bemerkt. Also poste deinen Code bzw. was du bereits versucht hast. Fertige Lösungen kannst du von uns weder erwarten noch verlangen, außer du bist bereit Geld dafür zu zahlen.
Thes-One schrieb:
Jetzt verstanden?????
ja, dass deine ?-Taste klemmt.
-
dann machs do so dass wenn du in der kuerzeren liste beim ersten element angelangt bis,
du einfach mit diesem die rekursion wieder aufrufst bis auch die 2. liste beim
ersten element angekommen bist.also hier jetzt fuer eine liste:
void show_reverse (struct list *l) { if (l->next) show_reverse (l->next); else show_reverse (l); printf ("%d\n", l->wert); }
-
Ok dann werde ich euch jetzt mal schreiben was genau mein Problem ist mit Beispiel!
Also ich habe zwei Funktionen bei denen ich Probleme habe, vielleicht löst sich das zweite Problem aber von selbst wenn ich weiß woran das erste liegt!!!
Also, wir machen Mengenoperationen die wir intern in Listen darstellen!
Eine Menge ist eine Liste!Nun muss ich eine Funktion schreiben die eine Invertierte Menge erstellt, also alle Elemente enthält die nicht in der Menge enthalten sind!
Dazu wurde vorher ein Wert festgelegt, was das Maximale Element in der Menge sein darf.
Das ist die 150!Nun will ich das ganze Rekursiv und von hinten durchlaufen lassen, da man dann das Element einfach am Anfang anfügen kann und nicht erst die Liste durchlaufen und dann einfuegen.
So hat man dann gleich eine sortiere Invertierte Liste!Das ist mein bissheriger code.....
->head(Alt) == Alt->Wert;
->cons(Element,Neu) == Wird ein Element vorne angefügt
->Maximum == 150, muss aber runter gezählt werden!Liste InvertierteMenge(Liste Neu,Liste Alt, int Maximum){ if (Alt->next) InvertierteMenge(Neu,Alt->next,Maximum); if (Maximum > head(Alt))) Neu = cons(Maximum,Neu); InvertierteMenge(Neu,Alt,--Maximum); }Das Problem ist das das soo garnicht klappt und es kommt ein Stack Overflow error!
Ich hoffe ihr habt verstanden was da jetzt das Problem ist(???)
-
du hast die seltene begabung, einen sachverhalt total wirr rüberzubringen
zeig doch mal den *kompletten* code, einschliesslich der listenverwaltung...
-
Das gibt es nicht!
So jetzt kurz und knapp!
"Ich will eine Liste(A) mit den Werten zwischen 150 und 0 die nicht in einer Liste(B) enthalten sind füllen"!
Das ganze möchte ich Rekursiv und von hinten durchlaufend haben!
Da ja das hinterste Element in einer meiner Listen das größte Element ist!PS: Ich kann hier nicht meinen kompletten Code reinstellen da es ein Schulprojekt ist(evntl. EMAIL)!