Finde das Maximum einer verketteten Liste (mit rekursiver Funktion)

[DesWeeedert]

Hallo zusammen,

meine Aufgabe ist es eine rekursive Funktion zu schreiben, die in einer linear verketteten Liste die größte Zahl findet.

In meinem Programm heißt diese Funktion ZeigListMax.

Hier ist mein bisheriger Ansatz:

Code:

program FindeListMax (input, output);
{ testet die Funktion ZeigListMax }

  type
  tRefListe = ^tListe;
  tListe = record
             info : integer;
             next : tRefListe
           end;
  var
  Liste,
  MaxZeig : tRefListe;

  function ZeigListMax (inRefAnfang : tRefListe) : tRefListe;
  { bestimmt rekursiv einen Zeiger auf das Listenelement mit
    der groessten Zahl }
   
    var
    HilfszeigerEins :tRefListe;
   
    begin
    if inRefAnfang = nil then
      ZeigListMax := nil
    else
      if inRefAnfang^.next = nil then
      begin
        ZeigListMax := inRefAnfang;
      end
      else
        begin
        HilfszeigerEins := inRefAnfang;
        repeat 
          HilfszeigerEins := HilfszeigerEins^.next;
          if HilfszeigerEins^.info > inRefAnfang^.info then
          inRefAnfang := HilfszeigerEins;
          ZeigListMax := ZeigListMax(inRefAnfang);
        until HilfszeigerEins^.next =nil;
        ZeigListMax := inRefAnfang;
        end;      
  end;

  procedure LiesListe(var outListe : tRefListe);
  { Liest eine (evtl. leere) Liste ein und gibt deren
    Anfangszeiger outListe zurueck. }

    var
    Anzahl : integer;
    i : integer;
    neueZahl : integer;
    Listenanfang,
    Listenende : tRefListe;
    
    begin
    Listenanfang := nil;
    repeat
      write ('Wie viele Zahlen wollen Sie eingeben? ');
      readln (Anzahl);
    until Anzahl >= 0;
 
    write ('Bitte geben Sie ', Anzahl, ' Zahlen ein: ');

    { Liste aufbauen }
    for i := 1 to Anzahl do
    begin
      read (neueZahl);
      if Listenanfang = nil then
      begin
        new (Listenanfang);
        Listenanfang^.next := nil;
        Listenanfang^.info := neueZahl;
        Listenende := Listenanfang;
      end
      else
      begin
        new (Listenende^.next);
        Listenende := Listenende^.next;
        Listenende^.next := nil;
        Listenende^.info := neueZahl
      end  { if Liste = nil }
    end; { for }
    outListe := Listenanfang;
    writeln
  end; { LiesListe }

  begin 
  LiesListe (Liste);
  { Die zu testende Funktion wird zweimal aufgerufen, damit tatsaechlich
    ein Fehler auftritt, wenn die Liste durch den Aufruf zerstoert wird. }
  MaxZeig := ZeigListMax (Liste);
  MaxZeig := ZeigListMax (Liste);
  if MaxZeig = nil then
    writeln('Leere Eingabefolge!')
  else
    writeln ('Das Maximum ist ', MaxZeig^.info, '.')
end. { testeZeigListMax }

Das Programm funktioniert leider nur bei Listen, die bereits aufsteigend sortiert sind. In diesem Fall spuckt es bei meinen Tests immer die richtige Zahl aus.

Ich weiß leider nicht genau, woran es liegt. Ein bisschen komisch kommt mir die repeat-schleife vor, weil ja sozusagen diese repeat-schleife immer wieder die Funktion aufruft.
Ich weiß nicht genau, was das da genau passiert. Also wird die repeat-Schleife sozusagen abgebrochen, wenn innerhalb der repeat-Schleife die Funktion erneut aufgerufen wird?
Oder wie verhält sich das?

Hat vielleicht jemand einen kleinen Tipp, was verkehrt ist?


Vielen Dank, falls sich denn jemand die Mühe macht, wäre super!

LG