Einführung in die imperative Programmierung

WS 2015/16

Maximum (mit zweiter Prozedur)

{$B+} {$R+}

program maximum (input, output);

  uses crt;
      
  var
  zahl1, zahl2, zahl3: integer;
      
  procedure inc(var ioZahl1: integer; var ioZahl2: integer);    
  begin
    ioZahl1 := ioZahl1+1;
    ioZahl2 := ioZahl2+1;
  end;
      
  procedure max(inZahl1 : integer; inZahl2 : integer; var outMax: integer);
    var zahl1: integer;
  begin
    inc(inZahl1, inZahl2);
    if inZahl1 >= inZahl2 then
      outMax := inZahl1
    else 
      outMax := inZahl2;
  end;

BEGIN
  readln(zahl1);
  readln(zahl2); 
      
  zahl3:= 5;
      
  max(zahl1, zahl2, zahl3);
      
  writeln('Maximum: ', zahl3);
  writeln('Zahl1: ', zahl1);
  writeln('Zahl2: ', zahl2);
      
END.

Liste mit Zeigern

program liste2 (input,output);

  type
  tRefListe = ^tListe;
  tListe = record
             zahl : integer;
             next : tRefListe;
  end;
   
  var 
  listenanfang : tRefListe; 
  zeiger : tRefListe; 
  endeListe : tRefListe;
  eingabe : integer;
   
  procedure alleDrucken(zuDrucken:  tRefListe);
    var
    zeiger: tRefListe;
  begin
    zeiger := zuDrucken;
    while zeiger <> nil do 
    begin
      writeln(zeiger^.zahl);
      zeiger:= zeiger^.next;
    end;
  end;

BEGIN
  listenanfang := nil;
   
  readln(eingabe);
  while eingabe <> 0 do
  begin
    new(zeiger);
    zeiger^.zahl := eingabe;
    zeiger^.next:=nil;
    if listenanfang = nil then
      listenanfang := zeiger
    else
      endeListe^.next:=zeiger;
    endeListe := zeiger; 
    readln(eingabe);
  end;
   
  alleDrucken(listenanfang);
   
END.

Aufgabe 1

program testeFeldZweitMax (input, output);
{ testet die Funktion FeldZweitMax }

  const
  FELDGROESSE = 10;

  type
  tIndex = 1..FELDGROESSE;
  tFeld = array [tIndex] of integer;

  var 
  Feld : tFeld;
  i : integer;

  function FeldZweitMax (var inFeld : tFeld) : integer;
  {}
    var
    max, zweitmax, i: integer;
   
  begin
    max:= inFeld[1];
    zweitmax := inFeld[2];
    if zweitmax > max then
    begin
     max:= inFeld[2];
     zweitmax := inFeld[1];
    end;
   
    for i:=3 to FELDGROESSE do
      if inFeld[i] > max then
      begin
       zweitmax := max;
       max := inFeld[i];
      end
      else
        if inFeld[i] > zweitmax then
          zweitmax := inFeld[i];
    FeldZweitMax := zweitmax;
  end;

begin { Testprogramm }
  writeln('Bitte geben Sie ', FELDGROESSE, ' Zahlen ein:');
  for i := 1 to FELDGROESSE do
    read (Feld [i]);
  writeln('Die zweitgroesste Zahl ist ', FeldZweitMax (Feld), '.');
end. { testeFeldZweitMax }

Aufgabe 4

program TesteSortiereListe(input, output);

  type
  tNatZahl = 0..maxint;
  tRefListe = ^tListe;
  tListe = record
             info : tNatZahl;
             next : tRefListe;
           end;

  var
  RefListe : tRefListe;

  procedure SortiereListe (var ioRefListe : tRefListe);
  { sortiert eine lineare Liste aufsteigend }
      
    var 
    endeSortiert, kandidat, zeiger: tRefListe;    
  
  begin 
    if ioRefListe <> nil then
    begin
    {falls Liste nicht leer}
      if ioRefListe^.next <> nil then
      {Liste hat zweites Element}
      begin 
        endeSortiert := ioRefListe;
        while endeSortiert^.next <> nil do
        begin 
          kandidat :=  endeSortiert^.next;
          if kandidat^.info >= endeSortiert^.info then
            endeSortiert:= kandidat
          else
          begin
            endeSortiert^.next := kandidat^.next;
            if kandidat^.info <= ioRefListe^.info then
            begin
              kandidat^.next := ioRefListe;
              ioRefListe := kandidat;
            end
            else
            begin
              zeiger := ioRefListe;
              while zeiger^.next^.info < kandidat^.info do
                zeiger := zeiger^.next;
              kandidat^.next := zeiger^.next;
              zeiger^.next := kandidat;
            end;
          end; {while}
        end; {if ioRefListe^.next <> nil}
      end;
    end
    else 
      writeln('Liste leer!');
  end;

  procedure Anhaengen(var ioListe : tRefListe; inZahl : tNatZahl);
  { Haengt inZahl an ioListe an }
    var Zeiger : tRefListe;
  begin
    Zeiger := ioListe;
    if Zeiger = nil then
    begin
      new(ioListe);
      ioListe^.info := inZahl;
      ioListe^.next := nil;
    end
    else
    begin
      while Zeiger^.next <> nil do
      Zeiger := Zeiger^.next;
      { Jetzt zeigt Zeiger auf das letzte Element }
      new(Zeiger^.next);
      Zeiger := Zeiger^.next;
      Zeiger^.info := inZahl;
      Zeiger^.next := nil;
    end;
  end;

  procedure ListeEinlesen(var outListe:tRefListe);
  { liest eine durch Leerzeile abgeschlossene Folge von Integer-
  Zahlen ein und speichert diese in der linearen Liste RefListe. }
    var
    Liste : tRefListe;
    Zeile : string;
    Zahl, Code : integer;
  begin
    writeln('Bitte geben Sie die zu sortierenden Zahlen ein.');
    writeln('Beenden Sie Ihre Eingabe mit einer Leerzeile.');
    Liste := nil;
    readln(Zeile);
    val(Zeile, Zahl, Code); { val konvertiert String nach Integer }
    while Code=0 do
    begin
      Anhaengen(Liste, Zahl);
      readln(Zeile);
      val(Zeile, Zahl, Code);
    end; { while }
    outListe := Liste;
  end; { ListeEinlesen }

  procedure GibListeAus(inListe : tRefListe);
  { Gibt die Elemente von inListe aus }
    var Zeiger : tRefListe;
  begin
    Zeiger := inListe;
    while Zeiger <> nil do
    begin
      writeln(Zeiger^.info);
      Zeiger := Zeiger^.next;
    end; { while }
  end; { GibListeAus }

begin
  ListeEinlesen(RefListe);
  SortiereListe(RefListe);
  GibListeAus(RefListe)
end.