Einführung in die imperative Programmierung

WS 2014/15

Zeiger

program zeiger;

 uses crt;

 type 
   tRefPerson = ^tPerson;
   tPerson = record
   Name: string;
   Alter: integer;
   next: tRefPerson;
   end;

 var 
   ErstePerson,
   Person1 : tRefPerson;
   
   procedure drucken(inPerson: tRefPerson);
   begin
   writeln(inPerson^.Name);
   writeln(inPerson^.Alter);
   end;
   
   procedure alleDrucken(inAnfang: tRefPerson);
   var zeig: tRefPerson;
   begin
   zeig:= inAnfang;
   while (zeig <> nil) do 
   begin
   drucken(zeig);
   zeig:= zeig^.next;
   end;
   end;

BEGIN
   new(ErstePerson);
   readln(ErstePerson^.Name);
   readln(ErstePerson^.Alter);
   ErstePerson^.next := nil;
   
   drucken(ErstePerson);
   
   new(Person1);
   readln(Person1^.Name);
   readln(Person1^.Alter);
   Person1^.next := nil;
   
   ErstePerson^.next := Person1;
   
   alleDrucken(ErstePerson);
   
   END.

Kehrwert

program kehrwert (input,output);

 uses crt;
   
   type tBruch = record
   zaehler,
   nenner : integer;
   end;
   
   var bruch : tBruch;
   
   procedure kw(var ioBruch: tBruch);
   var tausch: integer;
   begin
   tausch:= ioBruch.zaehler;
   ioBruch.zaehler:= ioBruch.nenner;
   ioBruch.nenner := tausch;
   end;
   
   procedure drucken( inBruch: tBruch);
   begin
   writeln(inBruch.zaehler,'/',inBruch.nenner);
   end;

BEGIN
   readln(bruch.zaehler);
   readln(bruch.nenner);
   drucken(bruch);
   
   kw(bruch);
   
   drucken(bruch);
   
   END.

Aufgabe 4 aus der Sitzung (noch fehlerhaft) Wer findet die Fehler

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,
   einSortieren,
   unsortiert,
   hilfszeiger,
   hilfszeiger2: tRefListe;
   begin
   if (ioRefListe <> nil) then
   begin
   EndeSortiert:= ioRefListe;
   unsortiert := ioRefListe^.next;
   while (unsortiert <> nil) do
   begin
   einSortieren := unsortiert;
   writeln(einSortieren^.info);
   unsortiert:= unsortiert^.next;
   EndeSortiert^.next := nil;
   if (einSortieren^.info < ioRefListe^.info) then
   begin
   einSortieren^.next := ioRefListe;
   ioRefListe:= einSortieren;
   end
   else 
   if (einSortieren^.info >= EndeSortiert^.info) then
   begin
   EndeSortiert^.next := einSortieren;
   EndeSortiert:= einSortieren;
   EndeSortiert^.next:= nil;
   end
   else 
   begin
   hilfszeiger:= ioRefListe;
   hilfszeiger2 := hilfszeiger^.next;
   while (einSortieren^.info < hilfszeiger2^.info) do
   begin
   hilfszeiger:= hilfszeiger2;
   hilfszeiger2:=hilfszeiger2^.next;
   end; 
   hilfszeiger^.next := einSortieren;
   einSortieren^.next:= hilfszeiger2;
   end;
   end;
   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.

Hier steckt der Fehler:

Die While-Bedingung ist falsch.

while (einSortieren^.info < hilfszeiger2^.info) do
begin
   hilfszeiger:= hilfszeiger2;
   hilfszeiger2:=hilfszeiger2^.next;
end; 

Wenn z.B. in die Liste (1,5) die 3 einsortiert werden soll, zeigt hilfszeiger zu Anfang auf die 1 und hilfszeiger2 auf die 5.
Da die 3 kleiner ist als die 5, zeigt hilfszeiger im nächsten Schritt auf die 5 und hilfszeiger2 ins Leere.
Es soll aber die 3 zwischen 1 und 5 eingefügt werden. Deshalb muss die Bedingung anders formuliert werden:

while (einSortieren^.info < hilfszeiger^.info) do    
begin    
   hilfszeiger:= hilfszeiger2;    
   hilfszeiger2:=hilfszeiger2^.next; 
end; 

Jetzt wird die Schleife sofort beendet, weil die 3 größer als die 1 ist.
Die Schleife muss beendet werden, sobald das einzusortierende Element größer wird als das, auf welches hilfszeiger zeigt.

Aufgabe 4 (funktioniert wohl hoffentlich)

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 15642}
   var 
   sortiertEnde,
   unsortiertStart,
   unsortiert,
   zeiger2,
   zeiger3: tRefListe;
   begin
   if ioRefListe<>nil then
   begin
   if ioRefListe^.next<>nil then
   begin
   sortiertEnde:=ioRefListe; 
   unsortiertStart:= ioRefListe^.next;
   sortiertEnde^.next:=nil;
   while unsortiertStart<>nil do
   begin 
   unsortiert:=unsortiertStart;
   writeln(unsortiert^.info);
   unsortiertStart:=  unsortiertStart^.next;
   if unsortiert^.info<ioRefListe^.info then 
   {ganz vorne einsortieren}
   begin
   writeln('vorne');
   unsortiert^.next:=ioRefListe; iorefliste:= unsortiert;
   end
   else 
   if unsortiert^.info>=sortiertEnde^.info then
   {hinten einsortieren}
   begin
   writeln('hinten');
   sortiertEnde^.next:= unsortiert; sortiertEnde:=unsortiert;
   sortiertEnde^.next:=nil;
   end
   else
   {einsortieren}
   begin
   writeln('mitte');
   zeiger2:=ioRefListe; zeiger3:=ioRefListe^.next;
   while (unsortiert^.info>zeiger3^.info) do
   begin
   zeiger2:=zeiger3; zeiger3:=zeiger3^.next;
   end;
   unsortiert^.next:=zeiger3; zeiger2^.next:=unsortiert;
   end;
   end; 
   
   end; {Durchlaufe Liste}
   writeln;
   end; 
   
   end;  {Sortiere Liste}

 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.