LineareListe - Sortiert ausgeben

program eigeneListe (input, output);

type
tRefListe = ^tListe;
tListe = record
			Info : Integer;
			next : tRefListe;
        end;
var
RefListe,
first : tRefListe;

  procedure ListeEinlesen (var iOutRefliste : tRefliste);
  var
  eingabe : char;
  wert : integer;

  begin
    repeat
      Write ('Ist es eine Leere Liste? Tippen Sie "y" = yes und "n" = no: ');
      readln (Eingabe);
    until (eingabe = 'y') or (eingabe = 'n');
    if eingabe = 'y' then
    begin
      repeat
        Write ('Geben Sie einen Wert des Listenelementes ein >= 0, Eingabe Beenden mit -1: ');
        readln (wert);
        if wert >= 0 then
        begin
          new (iOutRefliste);
          iOutRefliste^.Info := Wert;
          iOutRefliste^.Next := first;
          writeln (iOutRefliste^.Info);
        end;
      first := iOutRefliste; {First zeigt auf das Zuletzt eingegebene}
      until wert <= 0;
    Writeln ('Einlesen wurde Beendet')
    end {If (Y) --> Liste hat Werte!}
    else
      iOUtRefliste := NIL;
  end;

  procedure ListeAusgeben (inRefliste : tRefListe);
  begin
     {inRefListe zeigt auf das Erste ListenElement}
    Writeln ('>> Ausgabe der Liste <<');
      while (inRefliste <> NIL) do
      begin
        writeln (inRefliste^.Info);
        inRefliste := inRefliste^.Next;
      end;{WHILE ---> Ende der Liste}
  end;{Ende Procedure Ausgabe}


  procedure ListeSortieren (var iOutRefliste : tRefListe);
  var
  Zeiger : tRefListe;


    procedure amAnfangEinfug (var ListeAnfang, VorEinfuegElement : tRefListe);
    var
    Hilfszeig : tRefListe; {Zeigt auf das Einzufügende Element}
    begin
    Hilfszeig := VorEinfuegElement^.Next;
    VorEinfuegElement^.Next := VorEinfuegElement^.Next^.Next;
    Hilfszeig^.Next := ListeAnfang;
    ListeAnfang := Hilfszeig;
    end; {Ende Procedure amAnfangEinfügen}


    procedure SuchenEinfueg (var ListeAnfang, vorEinfuegElement : tRefListe);
    var
    SuchZeig : tRefListe;
    hilfszeig : tRefliste;
    begin
      SuchZeig := ListeAnfang;
      {Liste durchsuchen}
      while vorEinfuegElement^.next^.info > Suchzeig^.next^.info do
        SuchZeig := SuchZeig^.next;

      hilfszeig := vorEinfuegElement^.next; {Kopiert die Zukopierende Zahl}
      vorEinfuegElement^.Next := hilfszeig^.Next; {Voreinfugelement Zeigt auf NIL --> 10 Abgehandelt}

      hilfszeig^.Next := SuchZeig^.Next; {7 Soll auf 9 Zeigen}
      Suchzeig^.Next := hilfszeig; {2 Zeigt auf 7}

  end; {Einfuegen}





  begin
    Zeiger := IOutRefliste;
    if (IOutRefliste = NIL) then
      writeln ('Die Liste ist leer')
    else
    begin
      while (zeiger^.Next <> NIL) do
      begin
        writeln ('IN WHILE');
        {Fall 1: IOutRefliste > Kleiner als nächstes Element, dann mache nichts }
        if Zeiger^.Next^.Info >= Zeiger^.Info then
        begin
          writeln ('Es wird nichts verändert');
          zeiger := zeiger^.Next;
        end {If es muss nichts geändert werden}
        else
        begin
		  if Zeiger^.Next^.Info < iOutRefliste^.info then
		  begin
		    writeln ('ICH BIN IM IF');
		    AmAnfangEinfug(IOutRefliste, Zeiger);
		  end
		  else
		  begin
		  writeln ('ICH GEHE IN SUCHEN EINFÜGE');
		  SuchenEinfueg (IOutRefliste, Zeiger);
		  end;
        end; {Else -> Die liste musste geändert werden}

      end; {While Schleife}
    end; {Ende Else (Liste nicht leer)}
    first := iOUtRefliste;
  end; {ListeSortieren}



begin
  first := nil;
  ListeEinlesen (Refliste);
  ListeSortieren (Refliste);
  writeln ('Noch nicht gecrasht');

  ListeAusgeben (Refliste);


end.