Einführung
in die imperative Programmierung
WS 2017/18
Prozedur Quadrat
program quadratprogramm;
var i, qu : integer;
procedure quadrat (inZahl: integer; var outErgebnis: integer);
begin
outErgebnis := inZahl*inZahl;
end;
BEGIN
qu := 0;
readln(i);
quadrat(i, qu);
writeln('Quadrat: ', qu);
END.
Prozedur Quadrat mit Globaler Variable (Seiteneffekt)
program quadratprogramm;
var i, qu : integer;
procedure quadrat (inZahl: integer);
begin
qu := inZahl*inZahl;
end;
BEGIN
qu := 0;
readln(i);
quadrat(i);
writeln('Quadrat: ', qu);
END.
Personen Liste
program personen;
type
tRefPerson = ^tPerson;
tDatum = record
tag: integer;
monat: integer;
jahr: integer;
end;
tPerson = record
name: String;
geb: tDatum;
next: tRefPerson;
end;
var {person : tPerson;}
ListenAnfang: tRefPerson;
neu : tRefPerson;
procedure druckePerson(inPers: tRefPerson);
begin
writeln(inPers^.name);
writeln(inPers^.geb.tag);
writeln(inPers^.geb.monat);
writeln(inPers^.geb.jahr);
writeln();
end;
procedure druckeAllePersonen(inListenAnfang:tRefPerson );
var zeiger: tRefPerson;
begin
zeiger:= inListenAnfang;
while zeiger <> nil do
begin
druckePerson(zeiger);
zeiger:= zeiger^.next;
end;
end;
BEGIN
new(ListenAnfang);
ListenAnfang^.name := 'Einstein';
ListenAnfang^.geb.tag := 14;
ListenAnfang^.geb.monat := 3;
ListenAnfang^.geb.jahr := 1879;
new(neu);
neu^.name := 'Turing';
neu^.geb.tag := 23;
neu^.geb.monat := 6;
neu^.geb.jahr := 1912;
ListenAnfang^.next := neu;
druckeAllePersonen(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
max1, max2, k: integer;
begin
max1:= -maxint;
max2:= max1;
for k:=1 to FELDGROESSE do
begin
if inFeld[k]>max1 then
begin
max2:=max1;
max1:=inFeld[k];
end
else if inFeld[k]>max2 then
max2:=inFeld[k];
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 max:integer;
zeiger: tRefListe;
begin
if inRefAnfang= nil then
outOK:= false
else
begin
zeiger:=inRefAnfang;
max:= zeiger^.info;
while zeiger^.next<>nil do
begin
zeiger:= zeiger^.next;
if zeiger^.info>max
then max := zeiger^.info;
end;
outMax := max;
outOK:= true;
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
begin
zeiger := inRefAnfang1;
while zeiger^.next <> nil do
zeiger:=zeiger^.next;
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 }
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 zeiger, zuSortieren, sortierZeiger, einfuegenNach: tRefListe;
stelleGefunden: boolean;
begin
if ioRefListe=nil then
{leere Liste ist schon sortiert}
else
begin
{Liste nicht leer}
zeiger := ioRefListe;
while zeiger<>nil do
if zeiger^.next=nil then
{ende der Liste erreicht}
zeiger:=zeiger^.next
else
{Suche nach zu sortierendem Element}
if zeiger^.info >zeiger^.next^.info then
begin
zuSortieren:= zeiger^.next;
zeiger^.next:= zuSortieren^.next;
stelleGefunden := false;
sortierZeiger:= ioRefListe;
einfuegenNach:= nil;
repeat
if zuSortieren^.info < sortierZeiger^.info then
begin
stelleGefunden:= true;
end
else
begin
einfuegenNach:= sortierZeiger;
sortierZeiger:= sortierZeiger^.next;
end
until stelleGefunden;
{Element einsortieren}
if einfuegenNach=nil then
ioRefListe:= zuSortieren
else
einfuegenNach^.next:= zuSortieren;
zuSortieren^.next:= sortierZeiger;
end
else
zeiger:= zeiger^.next;
end;
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.
Aufgabe 4 mit Hilfsprozedur
program TesteSortiereListe(input, output);
type
tNatZahl = 0..maxint;
tRefListe = ^tListe;
tListe = record
info : tNatZahl;
next : tRefListe;
end;
var
RefListe : tRefListe;
procedure EinsortierenListe (var ioRefListe , ioZuSortieren : tRefListe);
{ sortiert ein Element in eine Teilliste }
var zuSortieren, sortierZeiger, einfuegenNach: tRefListe;
stelleGefunden: boolean;
begin
zuSortieren := ioZuSortieren;
stelleGefunden := false;
sortierZeiger:= ioRefListe;
einfuegenNach:= nil;
repeat
if zuSortieren^.info < sortierZeiger^.info then
begin
stelleGefunden:= true;
end
else
begin
einfuegenNach:= sortierZeiger;
sortierZeiger:= sortierZeiger^.next;
end
until stelleGefunden;
{Element einsortieren}
if einfuegenNach=nil then
ioRefListe:= zuSortieren
else
einfuegenNach^.next:= zuSortieren;
zuSortieren^.next:= sortierZeiger;
end;
procedure SortiereListe (var ioRefListe : tRefListe);
{ sortiert eine lineare Liste aufsteigend }
var zeiger, zuSortieren: tRefListe;
begin
if ioRefListe=nil then
{leere Liste ist schon sortiert}
else
begin
{Liste nicht leer}
zeiger := ioRefListe;
while zeiger<>nil do
if zeiger^.next=nil then
{ende der Liste erreicht}
zeiger:=zeiger^.next
else
{Suche nach zu sortierendem Element}
if zeiger^.info >zeiger^.next^.info then
begin
zuSortieren:= zeiger^.next;
zeiger^.next:= zuSortieren^.next;
EinsortierenListe ( ioRefListe , zuSortieren );
end
else
zeiger:= zeiger^.next;
end;
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.