Wie lösche ich eine komplette Liste? (Pointer)

[Wusel]

Hi Leute,
ich hab mal eine Frage:
Ich erstelle mit Hilfe von Pointern eine Liste. Jetzt hab ich aber das Problem dass ich nicht weiß, wie ich die komplette Liste (bzw den Speicher) zum Schluss wieder freigeben kann.
Ich habe mir bereits mit der Suchfunktion viele Beispiele angesehen, aber dort wird immer der kompliziertere Fall, wie man einzelne Elemente löscht, gezeigt. Kann mir bitte jemand ein Beispiel für das Löschen der kompletten Liste zeigen?
Wäre euch sehr sehr sehr ... dankbar :wink:


in diesem Sinne
Wusel

[Luckie]

In einer Schleife von hinten nach vorne durchgehen und die Elemete löschen.

[Chewie]

Meinst du eine verkettete Liste? Wenn ja, musst du jedes Element einzeln löschen (via Dispose()).

[Wusel]

Ja ich meine eine verkettete Liste. Wie geh ich eine Liste von hinten nach vorn durch? Daran scheiterte es ja die ganze Zeit bei mir :?

[SirThornberry]

arbeitest du mit TList???
wenn ja

Delphi-Quellcode:

for i := 0 to Liste.count - 1 do
begin
  dispose(PIrgendwas(Liste.Items[i]));
end;
Liste.clear;

[edit=Christian Seehase]Delphi-Tag geschlossen Mfg, Christian Seehase[/edit]

[Wusel]

nein leider nicht, aber der Code dort hilft mir trotzdem wieder ein Stückchen weiter. Ich bräuchte nur noch irgendwie den Befehl (?) damit ich ein Element zurück kann.
p^.Next springt ja zum nächsten also bräucht ich sowas wie p^.zurück :|

[Chewie]

Du kannst das auch vorwärts machen. Einfach das aktuelle Element sichern, dann zum nächsten weitergehen und nun das gesicherte (also den Vorgänger) löschen.

[SirThornberry]

steig am besten auf TList um, das hat jeder und ist total einfach zu handhaben.

[Chewie]

...ist aber leider eine sequenzielle Liste und keine verkettete. Soll heißen: die Vorteile einer verketteten Liste gehen verloren.

[Wusel]

Naja das mit dem TList muss ich auch mal versuchen.
Wegen dem löschen von vorn nach hinten hab ich mir ne Procedur geschrieben. Wird bei der die ganze Liste gelöscht oder bleibt da zum Schluss was übrig?

Delphi-Quellcode:

  procedure DelWholeList
  begin
    while (pFirst <> nil) do
    begin
      p := pFirst;
      pFirst := pFirst^.Next;
      Dispose(p);
    end;
  end;

[Chewie]

Die Liste wird komplett gelöscht: du prüfst, ob pFirst <> nil ist. pFirst ist genau dann nil, wenn an der Stelle kein Element sitzt.

[Wusel]

prima :bouncing4: :hello:

nochmal danke an euch :corky:

[Wusel]

hm ... jetzt bekomm ich den Fehler EInvalidPointer und er markiert mir die Zeile wo ich die Procedur DelWholeList aufrufe. Kann es damit zusammenhängen, dass ich nen record benutze?

[Wusel]

Also hier mal der Code eventuell seht ihr den Fehler

Delphi-Quellcode:

type
  PZahl = ^TZahl;
  TZahl = record
    Next : PZahl;
    iZahl : Integer;
    dwWann : Cardinal;
  end;

Var
  p,       // Hilfvariable, genauso wie p2
  pFirst,  // gibt immer die 1. Zeile an
  p2 : PZahl;

procedure AddItem(iNumber : Integer; dwZeit : Cardinal);
begin
  New(p);                      // holt Speicher
  p^.iZahl := iNumber;         // setzt die Zahl in den Speicher
  p^.dwWann := dwZeit;
  p^.Next := nil;              // setzt letztes Element auf nil
  if pFirst = nil then         // setzt die erste Zeile, wenn noch nicht vorher gemacht
    pFirst := p
  else
  begin
    p2 := pFirst;
    while (p2^.Next <> nil) do // wandert an die letzte Zeile
      p2 := p2^.Next;
    p2^.Next := p;
  end;
end;

procedure DelWholeList;
begin
  while (pFirst <> nil) do   // es wird solange gelöscht, bis pFirst nil ist
  begin                      // und das ist wenn die Liste zu ende ist
    p := pFirst;
    pFirst := pFirst^.Next;
    Dispose(p);
  end;
end;

Wo liegt da der EInvalidPointer Fehler :?:

[neolithos]

:shock:

Man da muss ich mir ja noch eine Aufgabe ausdenken :wink: , wenn das so schnell geht...

Delphi-Quellcode:

Var
  p,       // Hilfvariable, genauso wie p2
  pFirst,  // gibt immer die 1. Zeile an
  p2 : PZahl;

Hilfsvariablen (p, p2) sind bei mir niemals Global.

Delphi-Quellcode:

function GetLast : PZahl;
// wandert an die letzte Zeile
begin
  Result := pFirst;
  while (Result^.Next <> nil) do 
    Result := Result^.Next;
end;

procedure AddItem(iNumber : Integer; dwZeit : Cardinal);
var pTmp : PZahl;
begin
  New(pTmp);                      // holt Speicher
  with pTmp^ do 
    begin
      iZahl := iNumber;         // setzt die Zahl in den Speicher
      dwWann := dwZeit;
      pNext := nil; // setzt letztes Element auf nil
    end;             
  if pFirst = nil then         // setzt die erste Zeile, wenn noch nicht vorher gemacht
     pFirst := pTmp
  else
     GetLast^.pNext := pTmp;       
end;

procedure DelWholeList;
var pDel,
    pTmp : PZahl;
begin
  pTmp := pFirst;
  while (pTmp <> nil) do   // es wird solange gelöscht, bis pTmp nil ist
    begin                  // und das ist wenn die Liste zu ende ist
      pDel := pTmp;
      pTmp := pTmp^.pNext;
      Dispose(pDel);
    end;
end;

Übrigens Doku reicht aus.

Schick mir mal eine PM, damit ich genau weis wer Wusel ist :shock: .

[negaH]

Chewie hat den iterativen Algorithmus aufgezeigt, vielleicht hilft dir vom Verständnis her noch der rekursive Algo weiter.

Delphi-Quellcode:

procedure Free(P: PNode);
begin
  if P <> nil then
  begin
    Free(P.Next);
    Dispose(P);
  end;
end;

Gruß Hagen