Einführung
in die imperative Programmierung
WS 2016/17
Zeiger
{$B+}
program zeiger;
type
tRefInt = ^integer;
var
i : tRefInt;
j: tRefInt;
BEGIN
new(i);
i^ := 17;
writeln(i^);
j:= nil;
if j=nil then
writeln('nil')
else
writeln('not nil');
j:= i;
if j=nil then
writeln('nil')
else
writeln('not nil');
writeln(j^);
j^ :=20;
writeln(i^);
dispose(i);
if j=nil then
writeln('nil')
else
writeln('not nil');
if i=nil then
writeln('nil')
else
writeln('not nil');
writeln(i^);
END.
Person
program person;
type
tRefPerson = ^tPerson;
tPerson = record
name: string;
next: tRefPerson;
end;
var
person1 : tRefPerson;
neu : tRefPerson;
procedure durchlauf( inListeStart: tRefPerson);
var
adresse: tRefPerson;
begin
adresse:= inListeStart;
while adresse<>nil do
begin
writeln(adresse^.name);
adresse := adresse^.next;
end;
end;
BEGIN
new(person1);
person1^.name := 'Obama';
new(neu);
person1^.next := neu;
neu^.name := 'Sanders';
neu^.next:= nil;
durchlauf(person1);
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
firstmax,
secondmax: integer;
i:integer;
begin
{ Initialisierung}
firstmax:= inFeld[1];
if inFeld[2]<firstmax then
secondmax:= inFeld[2]
else
begin
secondmax:= firstmax;
firstmax:= inFeld[2]
end;
{Schleife}
for i:= 3 to FELDGROESSE do
begin
if inFeld[i]>firstmax then
begin
secondmax:= firstmax;
firstmax:=inFeld[i];
end;
if (inFeld[i]<firstmax) and (inFeld[i]>secondmax) then
secondmax:=inFeld[i];
end;
{Rückgabewert}
FeldZweitMax:= secondmax;
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
zeiger:= inRefAnfang;
if zeiger=nil then
outOK:= false
else
begin
outOK:=true;
outMax:= zeiger^.info;
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 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,
anfang,
anfangunsortiert,
letztersortiert:tRefListe;
begin
anfang:= ioRefListe;
letztersortiert := anfang;
if anfang<>nil then
begin
anfangunsortiert:= anfang^.next;
{unsortierte durchlaufen}
while anfangunsortiert<>nil do
begin
{einsortieren}
if anfangunsortiert^.info < anfang^.info then
begin
letztersortiert^.next := anfangunsortiert^.next;
anfangunsortiert^.next:= anfang;
anfang := anfangunsortiert;
anfangunsortiert:= letztersortiert^.next;
end
else
if letztersortiert^.info <= anfangunsortiert^.info then
begin
letztersortiert:= letztersortiert^.next;
anfangunsortiert:= anfangunsortiert^.next;
end
else
begin
zeiger:= anfang;
while zeiger^.next^.info<=anfangunsortiert^.info do
zeiger:= zeiger^.next;
letztersortiert^.next:= anfangunsortiert^.next;
anfangunsortiert^.next := zeiger^.next;
zeiger^.next:= anfangunsortiert;
anfangunsortiert:= letztersortiert^.next;
end
end
end;
ioRefListe:= anfang;
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.