Doppelt Verkettete Liste Sortieren + Sortiert einfugen

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


  procedure Einfugen (VAR ioRefAnfang : tRefListe; inEingabeWert : integer);
    var
    Zeiger,
    EinfugElement : tRefListe;
  begin
    Zeiger := ioRefAnfang;
    new (EinfugElement);
    EinfugElement^.Info := inEingabeWert;

    if ioRefAnfang^.info > EinfugElement^.Info then
    begin
      EinfugElement^.Next := ioRefAnfang;
      ioRefAnfang^.Prev := EinfugElement;
      ioRefAnfang := EinfugElement;
      ioRefAnfang^.Prev := NIL;
    end
    else
    begin
      While (Zeiger^.Next <> NIL) and (Zeiger^.Next^.Info < EinfugElement^.info) do
      begin
        Zeiger := Zeiger^.Next;
      end; {WHILE}
      if Zeiger^.Next = NIL then
      begin
        Zeiger^.Next := EinfugElement;
        EinfugElement^.Prev := Zeiger;
        EinfugElement^.Next := NIL;
      end
      else
      begin
      EinfugElement^.Next := Zeiger^.Next;
      Zeiger^.Next := EinfugElement;
      EinfugElement^.Prev := Zeiger;
      EinfugElement^.Next^.Prev := EinfugElement;
      end;
    end;
  end;

  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);
  EinfugWert := 14;
  Einfugen (Anfangszeiger, EinfugWert);

  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.