Einführung in die imperative Programmierung

Array aufbauen

program Felder (input,output);
   
 const FELDMAX = 10;
 
 type
 tIndex = 1..FELDMAX;
 tFeld = array[tIndex] of integer;
 
 var 
 a : tFeld; 
 eingabe : integer;
 zeiger : integer;
 
 procedure alleDrucken(zuDrucken:  tFeld);
 var
 zeiger: integer;
 begin
 zeiger := 1;
 writeln();
 while zeiger <> FELDMAX do 
 begin
 writeln(a[zeiger]);
 zeiger:= zeiger+1;
 end;
 end;
 

BEGIN
   writeln('Eingabe der Zahlen, Beenden mit 0'); 
   readln(eingabe);
   zeiger:=0;
   while eingabe <> 0 do
   begin
   zeiger:=zeiger+1;
   a[zeiger] := eingabe; 
   readln(eingabe);
   end;
   
   alleDrucken(a);
END.

Binären Suchbaum aufbauen

program Binaerbaum (input, output);              
   {Verwaltet einen Binärbaum}                      
   const
   NULL=0;                                         
   EINS=1;
   F=false;
   T=true;
   
   type
   tRefBinBaum= ^tBinBaum;                        
   tBinbaum= record                               
   info: integer;
   links:tRefBinBaum;
   rechts:tRefBinBaum;
   end;
   var 
   wurzel : tRefBinBaum;
   Zahl: integer;
   
   procedure einf(inWert:integer; 
   var ioBaum:tRefBinBaum);                     
   {fügt inWert als neuen Knoten in den Baum ein}            
   var
   Zeiger: tRefBinBaum; 
   begin                                                
   if ioBaum=nil then
   {Baum ist noch leer}
   begin
   new(Zeiger);
   Zeiger^.info:=inWert;
   Zeiger^.links:=nil;
   Zeiger^.rechts:=nil;
   ioBaum:=Zeiger;                                         
   end
   else
   begin
   if inWert <= ioBaum^.info then
   {Wert links einfügen}
   begin
   if ioBaum^.links=nil then
   {einfügen}
   begin
   new(Zeiger);
   Zeiger^.info:=inWert;
   Zeiger^.links:=nil;
   Zeiger^.rechts:=nil;
   ioBaum^.links:=Zeiger;
   end
   else
   {links weitersuchen}
   einf(inWert, ioBaum^.links);
   end;
   if inWert > ioBaum^.info then
   {Wert rechts einfügen}
   begin
   if ioBaum^.rechts=nil then
   {einfügen}
   begin
   new(Zeiger);
   Zeiger^.info:=inWert;
   Zeiger^.links:=nil;
   Zeiger^.rechts:=nil;
   ioBaum^.rechts:=Zeiger;
   end
   else
   {rechts weitersuchen}
   einf(inWert, ioBaum^.rechts);
   end;
   end;
   end; 

 function finden(inBaum:tRefBinBaum; 
   inWert:integer): boolean;                           
   {sucht inWert im Baum und gibt true oder false zurück}              
   begin
   if inBaum=nil then
   {Knoten leer}
   finden:=F
   else
   if inBaum^.info=inWert then
   {Wert gefunden}
   finden:=T
   else
   {links und rechts suchen}
   finden:=finden(inBaum^.links,inWert) or finden(inBaum^.rechts,inWert);
   end;
   
   procedure drucken(inBaum:tRefBinBaum);
   begin
   if inBaum <> nil then
   begin
   drucken(inBaum^.links);
   writeln(inBaum^.info);
   drucken(inBaum^.rechts);
   end;
   end;
   
   BEGIN                                                                 
   {Baum aufbauen}                                                     
   wurzel:=nil;                                                        
   einf(NULL, wurzel);
   einf(EINS , wurzel);
   einf(9, wurzel); 
   einf(5, wurzel);
   einf(3, wurzel);
   einf(10, wurzel);
   einf(EINS, wurzel);
   
   for Zahl:= 20 to 30 do
   begin
   einf(Zahl, wurzel);
   {Zahl := Zahl+1; ist auskommentiert}				              
   end; 

 {Baum drucken}
   drucken(wurzel);
   
   {im Baum suchen}
   Zahl:=0;
   while Zahl >= 0 do
   begin
   writeln('Nach Zahl suchen, Abbrechen mit negativer Zahl');        
   readln(Zahl);
   if Zahl>=0 then
   writeln(finden(wurzel, Zahl)); 
   end;
   
 END.
 

Verkettete Liste aufbauen

program liste (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;
   writeln('Eingabe der Zahlen, Beenden mit 0'); 
   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.