Hi,
muss leider mal etwas verkürzt antworten.
Trotzdem möchte ich erstmal darauf hinweisen, dass hier natürlich nur Hilfen gegeben werden, du musst natürlich auch einen guten Teil leisten. Da du sagtest, du hast das Grundprinzip schon verstanden, wäre es hier sehr schön, wenn du einfach mal sagen könntest, was du meinst in welchem Teil gemacht werden muss. Wie legt man denn eine doppelt verkettete Liste an, wie fügt man ein Element ein...?
Hier in diesem Fall werden die Elemente immer nur hinten rangehangen. Deswegen ist die Bezeichnung pVorherigerWert eigentlich falsch. Es ist zwar (wie Preddy schon sagte) immer der aktuelle Wert, vorallem aber ist es der Letzte Werte deiner Liste. Eine (nicht zyklische) Liste hat immer ein erstes und ein letztes Element. Ist sie leer, entfällt das natürlich, ist nur ein Element drin, dann ist dieses Element beides, erstes und letztes Element, sind mind. zwei Elemente drin, gibt es verschiedene Elemente, von denen eines das erste ist und eines das Letzte.
Die Idee der Verkettung in der Liste war dir ja klar? Dann überleg einfach mal, wenn du eine Liste hast, die nicht leer ist, wie du hier ein Element anhängen würdest. Überleg es dir einfach mal in Worten, dann versuche das ganze im Code wiederzufinden und/oder zu verstehen.
Da ich leider gleich weiter muss werde ich hier mal kurz ein wenig dazu sagen, dass findest du dann vielleicht auch gleich im Code wieder (der trotzdem schlecht ist, sorry). Jedenfalls besteht die Idee beim Anhängen einfach darin, dass du das letzte Element nimmst. Das es das letzte ist erkennst du daran, dass es keinen Nachfolger hat (der Zeiger next zeigt auf nil). Jetzt erzeugst du das neue letzte Element. Nennen wir der Einfachheithalber das alte Letzte Element A und das neue B. Du möchtest nun B hinter A in die Liste einfügen. Das heißt, dass der Vorgänger von B A ist und der Nachfolger von A muss B sein. Soweit klar?
Das ganze musst du jetzt noch in Code umsetzen. Das ist an sich sehr einfach, du musst hier ja nur übernehmen, was da steht. Nun hast du aber ein neues letztes Element, also musst du den globalen Zeiger, der immer nur auf das letzte Element zeigt auf B zeigen lassen. Das ist dann schon alles.
Delphi-Quellcode:
A, B : PListElement;
begin
// hier ist A einfach nur ein Puffer für einen Zeiger
// Es wird hier einfach der Zeiger auf das im Moment noch letzte Element zwischengespeichert
A := letztes_Element; // letztes_Element ist ein globaler zeiger auf das letzte Element
new(B); // hier wird ein neues Element erzeugt
// da es hinten ran gehangen wird, kann es keinen Nachfolger geben
B.next := nil;
// da es rangehangen wird, muss es aber einen Vorgänger geben
B.prev := A;
// nun weiß b zwar, wer sein Vorgänger ist und dass es keinen Nachfolger hat,
// aber der Rest der Liste hat das noch nicht mitbekommen.
// A hat immer noch keinen Nachfolger und der Zeiger letztes_Element zeigt immer
// noch auf A
// also zeigen wir A nun seinen Nachfolger
A.next := B;
// und setzen den globalen Zeiger auf das Ende
letztes_Element := B;
end;
Das ist jetzt nur das Prinzip für das hinten ran hängen. Das erzeugen einer Liste und das auslesen der Liste sind dann zwar noch offen, aber vielleicht komsmt du damit dann auch weiter.
Die erste Frage, die du beim Auslesen hast,
if pVorheriger_Wert = nil then Exit; //??
Ersetz hier einfach wieder pVorheriger_Wert durch pLetzter_Wert, dann ist vielleicht klar, was da gemacht wird. Sauberer ist es hier aber, wenn du das durch eine Bedingung ersetzt, alles was danach kommt sollte nur ausgeführt werden, wenn es eine letztes Element gibt (ansonsten ist die Liste einfach leer).
Gruß Der Unwissende
[EDIT]
Nix roter Kasten, deswegen alles so redundant
[/EDIT]