LIfT - Lehrwerk Informatik für Thüringen

Innerhalb eines Algorithmus ist der Zyklus zum einen das Wiederholen von Anweisungen durch Iteration – mittels Schleifen – und zum anderen durch Rekursion, indem sich Funktionen wiederholt selbst aufrufen.^[1]

In den Abbildungen 1 und 2 sind allgemein die Schleifentypen in Struktogrammen dargestellt.

In der Abbildung 3 ist der Algorithmus »Zahlen« dargestellt.

• Die Variablen »n« und »zahl« des Algorithmus sind vom Typ Ganzzahl (int).
• Der Algorithmus enthält als eine Anweisung die for-Schleife (im Struktogramm farblich rot hervorgehoben).
• Die for-Schleife wird verwendet, weil nach der Eingabe des Wertes für »n« – also von vornherein – die Anzahl der zu wiederholenden Ausführungen des Schleifenrumpfs feststeht.
• Die for-Schleife besteht aus:
  • dem Schleifenkopf »für zahl = 1 bis n«, wobei »zahl« eine sogenannte Laufvariable ist
  • dem Schleifenrumpf mit der Anweisung »Ausgabe zahl«
• Der Algorithmus gibt die Ganzzahlen 1 bis n≥1 untereinander aus.
• Implementiert ist der Algorithmus in den Programmen »zahlen.java« und »zahlen.py«.

import java.util.Scanner;

public class Zahlen {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        
        System.out.print("n: ");
        int n=input.nextInt();
        
        for (int zahl=1;zahl<=n;zahl++) {
            System.out.println(String.format("%d",zahl));
        }
    
        input.close();
    }  
}

n=int(input("n: "))

for zahl in range(1,n+1):
    print(zahl)

• Die Variable »zahl« im Schleifenkopf der for-Schleife des Programms »zahlen.java« ist die Laufvariable, weil die Variable im Schleifenkopf nacheinander die Werte 1 bis n zugewiesen bekommt.
• Ebenso im Programm »zahlen.py«.

Der Algorithmus berechnet den (prozentualen) Anteil der gefärbten Fläche eines schrittweise gefärbten Quadrats:

Schritt 1

1/2 der Fläche des Quadrats wird gefärbt

Schritt 2

zudem wird 1/4 der Fläche des Quadrats gefärbt

Schritt 3

zudem wird 1/8 der Fläche des Quadrats gefärbt

…

Schritt n

zudem wird 1/2ⁿ der Fläche des Quadrats gefärbt

Der Anteil der gefärbten Fläche – an der des Quadrats – berechnet sich wie folgt:

• 1/2 + 1/4 + 1/8 + 1/16 + 1/32 + 1/64 + 1/128 + 1/256 + … + 1/2ⁿ

In der Abbildung 5 ist die gefärbte Fläche nach acht Schritten dargestellt – einem Anteil von ∼99,6% der Gesamtfläche.

• Die Variablen »anzahl« und »schritt« des Algorithmus sind vom Datentyp Ganzzahl (int)
  Die Variable »gefaerbt« des Algorithmus ist vom Datentyp Gleitkommazahl (float/double).
• Innerhalb der for-Schleife (im Struktogramm farblich rot hervorgehoben) ist »schritt« die Laufvariable.
• Die Funktion »pow(2, schritt)« berechnet die Potenz 2^schritt.

In der Abbildung 6 ist ein Beispiel verschachtelter for-Schleifen im Algorithmus »Schleifen1« gegeben.

• Die Variablen »n«, »m«, »i« und »j« sind vom Datentyp Ganzzahl (int).
• Die Anweisung »Ausgabe« bewirkt einzig einen Zeilenumbruch.
• Innerhalb der beiden for-Schleifen sind die Variablen »i« und »j« Laufvariablen.
• Der Algorithmus ist in den Programmen »schleifen1.java« und »schleifen1.py« implementiert.

import java.util.Scanner;

public class Schleifen1 {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        
        System.out.print("n: ");
        int n=input.nextInt();
        int m=n;
       
        for (int i=1;i<=n;i++) {
            for (int j=1;j<=m;j++) {
                System.out.println(String.format("(%d,%d)",i,j));               
            }
            
            System.out.println();
        }
    
        input.close();
    }  
}

n=int(input("n: "))
m=n

for i in range(1,n+1):
    for j in range(1,m+1):
        print(f"({i},{j})")
    print()

Die for-Schleife wird im Allgemeinen immer dann verwendet, wenn von vornherein die Anzahl der zu wiederholenden Ausführungen des Schleifenrumpfs feststeht.

Neben der for-Schleife gibt es die while-Schleife.

• Das Besondere an der while-Schleife ist, dass diese Schleife alles das leisten kann, was die for-Schleife leistet (Abbildungen 9 und 10). Das heißt, eigentlich wird die for-Schleife nicht benötigt.^[2]

• Eine weitere Besonderheit der while-Schleife ist, dass der Schleifenkörper gegebenenfalls überhaupt nicht ausgeführt wird.

Beispielsweise wird im Algorithmus »Beispiel« (Abbildung 11) nach der Eingabe von zwei gleichen Ganzzahlen der Schleifenrumpf nicht ausgeführt.

• Die Variablen »zahl1« und »zahl2« des Algorithmus sind vom Datentyp Ganzzahl (int).
• Im Stuktogramm ist die while-Schleife farblich rot hervorgehoben.

Des Weiteren gibt es neben der for-Schleife und while-Schleife noch die do-while-Schleife.

• Das Besondere an der do-while-Schleife ist, dass die Schleife statt des Schleifenkopfs einen Schleifenfuß besitzt. ^[3] Das hat zur Folge, dass der Schleifenrumpf mindestens einmal ausgeführt wird.
• Aus diesem Grund eignet sich die do-while-Schleife beispielsweise für Programme, in denen geraten werden muss.

Im Algorithmus »Raten« besteht das Problem darin, die Anzahl der Etagen des Jenaer Jentowers zu erraten. Der Rater muss dazu wenigstens einmal raten, das heißt mindestens einmal eine Eingabe ausführen.

Um den in der Abbildung 12 dargestellten Algorithmus in eiinem Programm zu implementieren, steht unter anderem in Java die do-while-Schleife zur Verfügung (im Struktogramm fablich blau hervorgehoben), für die gilt, »wiederhole, solange die Wiederholbedingung wahr ist«, das heißt solange »antwort != etagen« gilt.

• Die Variablen »etagen« und »antwort« im Algorithmus sind vom Datentyp Ganzzahl (int).
• Das in der Abbildung 12 gegebene Struktogramm mit der do-while-Schleife lässt sich zwar mit dem Structorizer darstellen, führt allerdings beim Testen zu Fehlern, weil es im Structorizer die do-while-Schleife nicht gibt, sondern nur die repeat-until-Schleife.
• Im Java-Programm »raten.java« ist die do-while-Schleife implementiert.

import java.util.Scanner;

public class Ordnen {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        
        int etagen=31;
        int antwort;
        
        do {
            System.out.print("Etagen des Jenaer Jentowers? ");
            antwort=input.nextInt();    
        }
        while (antwort!=etagen);
        
        System.out.println(String.format(
            "%d ist richtig!",antwort));
    
        input.close();
    }  
}

Anders verhält es sich beim Structorizer, denn der verfügt nicht über die do-while.Schleife, sondern über die repeat-until-Schleife, die es unter anderem auch in Pascal, Delphi und Visual Basic gibt.

Für die repeat-until-Schleife gilt, »wiederhole, bis die Abbruchbedingung wahr ist«, das heißt bis »antwort == etage« gilt.

• Im abgebildeten Algorithmus handelt es sich um die repeat-until-Schleife (im Struktogramm farblich rot hervorgehoben) des Structorizers. Für die repeat-until-Schleife kann der Structorizer den Test ausführen.
• Die Variablen »etagen« und »antwort« im Algorithmus sind vom Datentyp Ganzzahl (int).

In Python gibt es weder die do-while-Schleife noch die repeat-until-Schleife. Im Programm »raten.py« wird daher die repeat-until-Schleife durch die while-Schleife, die if-Auswahl und die Anweisung break simuliert.

etagen=31

while True:
    antwort=int(input("Etagen des Jenaer Jentowers? "))
    if(antwort==etagen):
        print(f"{antwort} ist richtig!")
        break

• Die Variablen »etagen« und »antwort« im Programm sind vom Datentyp Ganzzahl (int).
• True (wahr) ist – neben False (falsch)) – in Python ein Wert des Datentyps Wahrheitswert (bool).
• Die Anweisung break bewirkt einen sofortigen Programmabbruch.

Die do-while-Schleife wird zudem in Algorithmen zur Ausführung von Näherungsverfahren genutzt.

• Das heißt, eine Näherung wird mindestens einmal ausgeführt, bevor geprüft wird, ob sie genau genug ist.

In der Abbildung 14 ist der Algorithmus »Wurzel« mit dem Structorizer dargestellt.

• Der Algorithmus berechnet nach dem Verfahren von Heron von Alexandria – der im 1. Jahrhundert n. Chr. lebte – die Quadratwurzel einer Gleitkommazahl > 0 näherungsweise bis auf eine bestimmte Genauigkeit.
• Die Variablen »radikand«, »epsilon«, »a« und »b« des Algorithmus sind vom Datentyp Gleitkommazahl (float/double).)
• Die Funktion »abs(b - a)« ermittelt den Betrag |b - a|.
• Der Algorithmus kann im Structorizer getestet werden, da es sich hierbei um eine repeat-until-Schleife handelt, für die gilt »wiederhole, bis die Abbruchbedingung wahr ist« (im Struktogramm farblich rot hervorgehoben).

Der in der Abbildung 14 dargestelle Algorithmus ist im Programm »wurzel.java« implementiert.

• Der im Struktogramm dargestellte Algorithmus würde beim Testen im Structorizer zu fehlerhaften Ergebnissen führen, weil es sich hierbei um eine do-while-Schleife handelt, für die gilt »wiederhole, solange die Wiederholbedingung wahr ist« (im Struktogramm farblich blau hervorgehoben).

import java.util.Scanner;

public class Wurzel {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        
        System.out.print("Wurzelradikand: ");
        double radikand=input.nextDouble();
        System.out.print("Genauigkeit: ");
        double epsilon=input.nextDouble();
        
        double a=radikand/2;
        double b;
        
        do {
            b=a;
            a=0.5*(a+radikand/a);
            System.out.println(String.format("%f  %f",b,a));
        }
        while (Math.abs(b-a)>epsilon);
        
        System.out.println(String.format(
            "Wurzel: %.2f",a));
    
        input.close();
    }  
}

Wie bereits erwähnt, wird die do-while-Schleife in Python durch die while-Schleife, die if-Anweisung und die Anweisung break simuliert.

radikand=float(input("Wurzelradikant >=0: "))
epsilon=float(input("Genauigkeit: "))

a=radikand/2

while True:
    b=a
    a=0.5*(a+radikand/a)
    if abs(b-a)<=epsilon:
        print(f"Wurzel: {a:.2f}")
        break

1. Aufgrund dessen, dass den Computerprogrammen Algorithmen zugrunde liegen, ist es wichtig, die Aufmerksamkeit gezielt auf das Entwickeln der Algorithmen zu richten. Und das zuallererst unabhängig davon, in welcher Programmiersprache die Algorithmen beschrieben werden.
2. Im Informatikunterricht kann der Structorizer als Bindeglied zwischen dem Entwickeln, Darstellen und Programmieren von Algorithmen fungieren. Und das vor allem deshalb, weil der Structorizer die Algorithmen automatisch in Programme überführt, die sich dann in Tests ausführen lassen.

---

1. [1] Wiederholen durch Rekursion wird in den Programmier-Themenbereichen des Gebiets »Praktische Informatik« behandelt.
2. [2] Oftmals ist die Notation der for-Schleife kürzer und eleganter als die der while-Schleife.
3. [3] Während die while-Schleife eine kopfgesteuerte Schleife ist, handelt es sich bei der do-while-Schleife um eine fußgesteuerte Schleife.