Verschachtelte For Schleifen

Hallo, also ich weiß schon mal, dass bei einer verschachtelung von For-Schleifen, die äußere Schleife erst einmal einen Durchgang macht bis die innere Schleife false liefert. Nur wie sieht es mit mehreren For Schleifen aus. Ich verstehe nicht genau wie die Schleifen abgerarbeitet werden.

Bsp:

for (stern = 0; stern < 10; stern++) {
for (dreieck = 0; dreieck < 10; dreieck++) {
for (raute = 0; raute < 10; raute++) {
int zahl1 = stern * 100 + dreieck * 10 + raute;

for (unendlich = 0; unendlich < 10; unendlich++) {
for (dreieckAndersherum = 0; dreieckAndersherum < 10; dreieckAndersherum++) {
int zahl2 = unendlich * 100 + dreieck * 10 + dreieckAndersherum;

for (quadrat = 0; quadrat < 10; quadrat++) {
int zahl3 = dreieckAndersherum * 100 + quadrat * 10 + quadrat;

if (zahl1 + zahl2 == zahl3)
 
Versuche einmal, das ganze zu abstrahieren, also nicht zu versuchen, zwei Schleifen zu verstehen und dann drei Schleifen und dann vier usw., sondern es reicht lediglich, wenn du eine Schleife verstehst:
Java:
for (...) {
  statement
}
In dem obigen Code wird `statement` für jede Iteration der for-Schleife ausgeführt. Wenn jetzt `statement` wieder eine for-Schleife ist bzw. beinhaltet, dann wird halt diese Schleife als ein Statement ausgeführt. Und du weißt ja, wann die Ausführung einer for-Schleife beendet ist, nämlich genau dann, wenn die Bedingung der Schleife `false` liefert.
Diese Regel kannst du dann für beliebig verschachtelte Schleifen anwenden.
Also: eine Schleife kann erst eine weitere Iteration durchführen, wenn ihr Schleifenrumpf vollständig ausgeführt wurde (und nicht mit anderen Statements "abgebrochen" wurde).
 
Also ich verstehe das jetzt so, dass wenn die erste Schleife +1 hoch zählt, dann erstemal die if-Abfrage (zahl1+zahl2==zahl3) kommt ?
Oder muss ich dann eher von innen nach außen gehen?
 
Zuletzt bearbeitet:
Lese den Code einfach von oben nach unten.
Java:
1. for (...) {
2.   for (...) {
3.     for (...) {
4.       ...
5.     }
6.   }
7. }
Zuerst wird bei 1. die äußerste for-Schleife ausgeführt. Das führt dazu, dass sie erstmal ihre Bedingung auswertet, die - hier mal angenommen - true liefert. Das bedeutet, die äußere Schleife möchte in dieser ersten Iteration ihren Rumpf ausführen. Was in dem Rumpf genau drinsteht, ist völlig egal. Das kann eine weitere for-Schleife sein oder irgendwas anderes. Im obigen Beispiel ist es einfach eine weitere for-Schleife. Das heißt, der Rumpf der äußersten Schleife wird nun bei 2. ausgeführt. Wir befinden uns ja immernoch in der Ausführung der ersten Iteration der äußersten (1.) Schleife. Nun möchte die Schleife bei 2. ausführt werden. Was macht sie also? Sie wertet ihre Bedingung aus, die (hier mal) wieder true ist und nun möchte sie ihrerseits ihren Rumpf ausführen. Es ist wiederum völlig egal, was der Rumpf ist. In diesem Beispiel ist es wieder eine for-Schleife, die nach denselben Regeln wie vorher ausgewertet und ausgeführt wird. Wir sind also bei 3., aber eben immer noch in der ersten Iteration der äußersten 1. Schleife und in der ersten Iteration der 2. Schleife. Nun wird halt noch die Schleife bei 3. ausgeführt. Und so weiter und so fort.
 
Versuche mal, die innere(n) Schleife(n) in eine Methode auszulagern. Das:

Java:
//Start here:
public void static main(String args[]){
    for(int i = 0; i < 10; i++){
        //...
        performAnotherFor();
        //...
    }
}

void performAnotherFor(){
    for(int i = 0; i < 10; i++){
        //...
        performAThirdFor();
        //...
    }
}

void performAThirdFor(){
    for(int i = 0; i < 10; i++){
        //...
    }
}
ist exakt das Gleiche wie:
Java:
//Start here:

public void static main(String args[]){
    for(int i = 0; i < 10; i++){
        //...
        for(int j = 0; j < 10; j++){    //performAnotherFor
            //...
            for(int k = 0; k < 10; k++){    //performAThirdFor
                //...
            }
            //...
        }
        //...
    }
}
 
for (stern = 0; stern < 10; stern++) { <- Dann wird hier +1 gezählt
for (dreieck = 0; dreieck < 10; dreieck++) { <- Hier auch
for (raute = 0; raute < 10; raute++) { <- Hier auch ... usw
int zahl1 = stern * 100 + dreieck * 10 + raute;

for (unendlich = 0; unendlich < 10; unendlich++) {
for (dreieckAndersherum = 0; dreieckAndersherum < 10; dreieckAndersherum++) {
int zahl2 = unendlich * 100 + dreieck * 10 + dreieckAndersherum;

for (quadrat = 0; quadrat < 10; quadrat++) { <- aber hier wird dann so lange
int zahl3 = dreieckAndersherum * 100 + quadrat * 10 + quadrat; gezählt bis die Schleife False anzeigt. Dann zählt die schleife darüber so lange bis die Schleife False anzeigt usw.

if (zahl1 + zahl2 == zahl3)




Oder ?
 
Die zweite Hälfte der Schleifen fehlt jeweils, aber du hast da sechs verschachtelte Schleifen, von denen die Innerste (quadrad..) zuerst komplett abgearbeitet wird. Danach folgt die nächst höhere (dreieckAndersrum..), wobei bei jedem Durchlauf auch immer die Innerste erneut abgearbeitet wird, usw.

Die innere Schleife wird also ziemlich oft bearbeitet, weil ja noch die anderen fünf Schleifen dazukommen.

Die Schleife "stern" ruft 10 mal die Schleife "dreieck" auf.
Die Schleife "dreieck" ruft 10 mal die Schleife "raute" auf: "raute" wird 10 x 10 mal abgearbeitet.
Die Schleife "raute" ruft 10 mal die Schleife "unendlich" auf: "unendlich" wird 10 x 10 x 10 mal abgearbeitet.
usw.
 
Passende Stellenanzeigen aus deiner Region:

Oben