Doppelt Verkettete Liste Sortieren

program ListeSortieren (input,output);
  type
  tRefliste = ^tliste;
  tListe = record
			Info : Integer;
			Next : tRefliste;
			Prev : tRefliste;
		end;
  var
  i,
  eWert,
  Feldgrosse : integer;
  AnfangsZeiger,
  pZeiger : tRefliste;


  procedure Sortieren (var ioRefAnfang : tRefliste);
    var
    Backup,
    Zeiger,
    Durchlaufen : tRefliste;

  begin
    Zeiger := ioRefAnfang;
    while (Zeiger^.Next <> NIL) do
    begin
      if Zeiger^.Info <= Zeiger^.Next^.info then
      begin
        Zeiger := Zeiger^.Next;
      end {Das nächste Element ist kleiner, somit muss nicht umgehangen werden}
      else
      begin
        if Zeiger^.Info > Zeiger^.Next^.Info then
        begin
          Backup := Zeiger^.Next;
          if Backup^.info < ioRefAnfang^.Info then
          begin
            Zeiger^.Next := Backup^.Next;
            Backup^.Next := ioRefAnfang;
            ioRefAnfang := Backup;
            ioRefAnfang^.Prev := NIL;
            if Zeiger^.Next <> NIL then
              Zeiger^.Next^.Prev := Zeiger;
              ioRefAnfang^.Next^.Prev := ioRefAnfang;
          end {AM Anfang Einfüg}
          else
          begin
            Durchlaufen := ioRefAnfang;
            while (Durchlaufen^.Next <> Backup) and (Durchlaufen^.Next^.Info < Backup^.Info) do
            begin
              Durchlaufen := Durchlaufen^.Next;
            end;
            Backup^.Prev := Durchlaufen;
            Durchlaufen^.Next^.Prev := Backup;
            Durchlaufen^.Next^.Next := Backup^.Next;
            Backup^.Next := Durchlaufen^.Next;
            Durchlaufen^.Next := Backup;
          end; {Durchlaufen}
        end;
      end; {Element muss umgehangen werden }
    end; {While\}
  end;
begin
  Anfangszeiger := NIL;
  Write ('Wie Lang soll die Liste sei: ');
    readln (Feldgrosse);
  for i := 1 to Feldgrosse do
  begin
    Write ('Info Wert: ');
      readln (eWert);
    new (pZeiger);
    pZeiger^.Info := eWert;
    pZeiger^.Next := Anfangszeiger;
    pZeiger^.Prev := NIL;
    if Anfangszeiger <> NIL then
      Anfangszeiger^.prev := pZeiger;
    Anfangszeiger := pZeiger;
  end;

  Sortieren (AnfangsZeiger);

  pZeiger := Anfangszeiger;
  while (pZeiger^.Next <> NIl) do
  begin
    writeln (pZeiger^.Next^.info, ' Hat den Vorgänger -> ', pZeiger^.next^.Prev^.info);
    pZeiger := pZeiger^.Next;
  end;

  pZeiger := Anfangszeiger;
  while (pZeiger <> NIl) do
  begin
    writeln (pZeiger^.Info);
    pZeiger := pZeiger^.Next;
  end;
end.