1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:

function Tliste.loesche(x:string):boolean;
var erg:boolean;
begin
erg:=false;
if pfirst^.data=x then 
begin
if pfirst^.pnext<>nil then
begin
pfirst^.pnext^.pprev:=nil; //Wenn du eine doppelt verkettete Liste hast
pfirst:=pfirst^.pnext;
end ;
dispose(pfirst);
erg:=true;
end
else 
....
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:

type

  Zeiger=^element;
  element=record
    z:integer;
    next:zeiger;
  end;

  Tliste=class(Tobject)
    Head,Tail,Fund,tmp:zeiger;
    check:boolean;
    suchzahl,anzahl:integer;
    Constructor init;
    procedure Keller(zahl:integer);
    procedure Schlange(zahl:integer);
    procedure Pop(var zahl:integer);
    procedure anzeigen(lb:tlistbox);
    procedure suchen(k:zeiger);
    procedure loeschen;
   end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:

procedure tliste.loeschen;

begin

 tmp:=Head ;

 suchen(Head);

// <If anzahl = 1 then pop>
// <IF Fund  = 1. Zahl then pop>
// <If Fund.next = nil then dispose Fund und tail eine höher setzen>
 While tmp^.next <> Fund do tmp:=tmp^.next;

 tmp^.next:=Fund^.next;

 dispose(Fund);

end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:

PElement = ^TElement;
TElement = record
  DataBlub: String;
  Previous, Next: PElement;
end;

//in der Klasse
  Liste, tmp: PElement;  // der erste Listeneintrag hat als Previous = NIL und der Letzte als Next = NIL

// Bsp: Deine Liste zeigt heirhin
//             |
// Element - Element - Element - Element - Element
// Wenn du es löschen willst musst du zuerst dem vorigen sagen, dass sein Nächster der Nächste vom aktuellen Datensatz ist und dem Nächsten(vom akutellen Datensatz) sagen, dass sein Voriger der Vorige vom akt. D. ist ...

Liste^.Previous^.Next := Liste^.Next;
Liste^.Next^.Previous := Liste^.Previous;

// Somit hättest du die Pointer verbogen
// Nun kannst du den Datensatz, den du mit New angelegt hast, Disposen:
tmp := Liste;
Liste := Liste^.Next // je nach dem (next, prev)...
Dispose( tmp );                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

procedure tliste.loeschen(var list:zeiger);
var tmp:zeiger;
begin

if(list<>nil) then begin
  if(list^.z=suchzahl) then begin
  tmp:=list;
  list:=list^.next;
  dispose(tmp);
  end else loeschen(list^.next);
end;

end;                    

1:
2:
3:
4:
5:

  pZeiger=^Telement;
  Telement=record
    z:integer;
    next:pZeiger;
  end