Einführung in die imperative Programmierung

WS 2018/19

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
   max1,max2, i, Tausch: integer;
   begin
   max1:= inFeld[1];
   max2:= inFeld[2];
   if max2>max1 then
   begin
   Tausch:= max2;
   max2:=max1;
   max1:=Tausch;
   end;
   for i:=3 to FELDGROESSE do
   begin
   if inFeld[i]> max1 then
   begin
   max2:= max1;
   max1:= inFeld[i];
   end 
   else
   if inFeld[i]> max2 then
   max2:= inFeld[i];
   end;
   FeldZweitMax:= max2;
   
   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 2

program testeListenMaxBestimmen (input, output);
   { Testet die Prozedur ListenMaxBestimmen }

 type
   tRefListe = ^tListe;
   tListe = record
   info : integer;
   next : tRefListe
   end;

 var
   Liste : tRefListe;
   Max : integer;
   OK : boolean;
 

 procedure ListenMaxBestimmen ( inRefAnfang: tRefListe; 
   var outMax : integer; 
   var outOK : boolean); 
   var 
   zeiger: tRefListe; 
   
   begin
   if inRefAnfang=nil then
   outOK := false
   else
   outOK := true;
   
   if outOK  then
   begin
   outMax:= inRefAnfang^.info;
   zeiger := inRefAnfang;
   while zeiger^.next<>nil do
   begin
   zeiger:= zeiger^.next;
   if zeiger^.info > outMax then
   outMax := zeiger^.info;
   end;
   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);
   ListenMaxBestimmen(Liste, Max, OK);
   if OK then 
   writeln ('Das Maximum ist ', Max, '.')
   else
   writeln ('Leere Eingabefolge!');
   end. { testeListenMaxBestimmen } 
 

Aufgabe 3

program TesteAnhaengen (input, output);
   { testet die Prozedur anhaengen }

 type
   tRefListe = ^tListe;
   tListe = record
   info : integer;
   next : tRefListe
   end;

 var 
   Liste1, 
   Liste2,
   Gesamtliste : tRefListe;
 

 procedure anhaengen (    inRefAnfang1,
   inRefAnfang2 : tRefListe;
   var outRefAnfang : tRefListe);
   { Haengt die lineare Liste mit Anfangszeiger inRefAnfang2 an
   die Liste mit Anfangszeiger inRefAnfang1 an.
   Zurueckgegeben wird outRefAnfang, der Anfangszeiger der Ergebnisliste. }
   
   var
   zeiger: tRefListe;
   
   begin
   if inRefAnfang1=nil then
   outRefAnfang := inRefAnfang2
   else 
   if inRefAnfang2=nil then
   outRefAnfang := inRefAnfang1
   else
   begin
   {bewege zeiger zum letzten Element der 1. Liste}
   zeiger := inRefAnfang1;
   while zeiger^.next<> nil do
   zeiger:= zeiger^.next;
   
   {Hänge 2. List an}
   zeiger^.next := inRefAnfang2; 
   outRefAnfang := inRefAnfang1;
   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 }
 

 procedure gibListeAus (inListe : tRefListe);
   { gibt die Liste mit Anfangszeiger inListe aus }
   var
   ListenElement : tRefListe;
   begin
   ListenElement := inListe;
   while ListenElement <> nil do
   begin
   write(ListenElement^.info, ' ');
   ListenElement := ListenElement^.next;
   end;
   writeln;
   end; { gibListeAus }
 

begin { testeAnhaengen }
   writeln('Bitte geben Sie die erste Liste ein! ');
   LiesListe (Liste1);
   writeln;

 writeln('Bitte geben Sie die zweite Liste ein! ');
   LiesListe (Liste2);
   writeln;

 writeln('Die konkatenierte Liste lautet: ');
   Anhaengen (Liste1, Liste2, Gesamtliste);
   GibListeAus (Gesamtliste);
   end. { TesteAnhaengen }
 

Liste Invertieren

program ListeInvertieren (input, output);
   { Testet die Prozedur ListenMaxBestimmen }

 type
   tRefListe = ^tListe;
   tListe = record
   info : integer;
   next : tRefListe
   end;

 var
   Liste : tRefListe;
   Max : integer;
   OK : boolean;
   
   procedure Invertieren( var ioRefAnfang: tRefListe);

 var 
   aktuell, vorheriges, naechstes:  tRefListe;
   
   begin
   if ioRefAnfang<>nil then
   begin
   aktuell:= ioRefAnfang;
   vorheriges:= nil;
   naechstes:= aktuell^.next;
   aktuell^.next:= vorheriges;
   while naechstes<>nil do
   begin
   vorheriges := aktuell;
   aktuell:= naechstes;
   naechstes:= naechstes^.next;
   aktuell^.next:= vorheriges;
   
   end;
   
   ioRefAnfang := aktuell;
   
   end; 
   
   end; 
   
   procedure gibListeAus (inListe : tRefListe);
   { gibt die Liste mit Anfangszeiger inListe aus }
   var
   ListenElement : tRefListe;
   begin
   ListenElement := inListe;
   while ListenElement <> nil do
   begin
   write(ListenElement^.info, ' ');
   ListenElement := ListenElement^.next;
   end;
   writeln;
   end; { gibListeAus }
 

 procedure ListenMaxBestimmen ( inRefAnfang: tRefListe; 
   var outMax : integer; 
   var outOK : boolean); 
   var 
   zeiger: tRefListe; 
   
   begin
   if inRefAnfang=nil then
   outOK := false
   else
   outOK := true;
   
   if outOK  then
   begin
   outMax:= inRefAnfang^.info;
   zeiger := inRefAnfang;
   while zeiger^.next<>nil do
   begin
   zeiger:= zeiger^.next;
   if zeiger^.info > outMax then
   outMax := zeiger^.info;
   end;
   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);
   
   Invertieren(Liste);
   
   gibListeAus(Liste);
   
   end. { testeListenMaxBestimmen }