Verschachtelte Schleifen in C# meistern: For, While und Do-While erklärt

Was sind verschachtelte Schleifen?

Eine Schleife innerhalb einer anderen Schleife wird als verschachtelte Schleife bezeichnet. Die äußere Schleife umschließt die innere Schleife. Die innere Schleife ist Teil der äußeren und muss innerhalb deren Body starten und enden.

Bei jeder Iteration der äußeren Schleife wird die innere Schleife vollständig ausgeführt.

Verschachtelte for-Schleife

Eine for-Schleife innerhalb einer anderen for-Schleife.

Beispiel:

for (int i = 0; i < 5; i++) {
    // Body äußere for-Schleife
    for (int j = 0; j < 5; j++) {
        // Body innere for-Schleife
    }
    // Body äußere for-Schleife
}

Beispiel 1: Verschachtelte for-Schleife

using System;
namespace Loop {
    class NestedForLoop {
        public static void Main(string[] args) {
            int outerLoop = 0, innerLoop = 0;
            for (int i = 1; i <= 5; i++) {
                outerLoop++;
                for (int j = 1; j <= 5; j++) {
                    innerLoop++;
                }
            }
            Console.WriteLine("Äußere Schleife läuft {0} Mal", outerLoop);
            Console.WriteLine("Innere Schleife läuft {0} Mal", innerLoop);
        }
    }
}

Ausgabe:

Äußere Schleife läuft 5 Mal
Innere Schleife läuft 25 Mal

Die äußere Schleife läuft 5 Mal. Jedes Mal läuft die innere 5 Mal → insgesamt 25 Mal.

Beispiel 2: Verschachtelte for-Schleife zum Muster-Drucken

using System;
namespace Loop {
    class NestedForLoop {
        public static void Main(string[] args) {
            for (int i = 1; i <= 5; i++) {
                for (int j = 1; j <= i; j++) {
                    Console.Write(j + " ");
                }
                Console.WriteLine();
            }
        }
    }
}

Ausgabe:

1
1 2
1 2 3
1 2 3 4
1 2 3 4 5

Verschachtelte while-Schleife

Eine while-Schleife innerhalb einer anderen while-Schleife.

while (Bedingung-1) {
    // Body äußere while-Schleife
    while (Bedingung-2) {
        // Body innere while-Schleife
    }
    // Body äußere while-Schleife
}

Beispiel 3: Verschachtelte while-Schleife

using System;
namespace Loop {
    class NestedWhileLoop {
        public static void Main(string[] args) {
            int i = 0;
            while (i < 2) {
                int j = 0;
                while (j < 2) {
                    Console.Write("({0},{1}) ", i, j);
                    j++;
                }
                i++;
                Console.WriteLine();
            }
        }
    }
}

Ausgabe:

(0,0) (0,1)
(1,0) (1,1)

Verschachtelte do-while-Schleife

Eine do-while-Schleife innerhalb einer anderen do-while-Schleife.

do {
    // Body äußere Schleife
    do {
        // Body innere Schleife
    } while (Bedingung-2);
    // Body äußere Schleife
} while (Bedingung-1);

Beispiel 4: Verschachtelte do-while-Schleife

using System;
namespace Loop {
    class NestedWhileLoop {
        public static void Main(string[] args) {
            int i = 0;
            do {
                int j = 0;
                do {
                    Console.Write("({0},{1}) ", i, j);
                    j++;
                } while (j < 2);
                i++;
                Console.WriteLine();
            } while (i < 2);
        }
    }
}

Ausgabe:

(0,0) (0,1)
(1,0) (1,1)

Unterschiedliche innere und äußere verschachtelte Schleifen

Es ist nicht vorgeschrieben, gleiche Schleifentypen zu verschachteln. Eine for-Schleife kann in eine while-Schleife, eine do-while in eine for-Schleife gelegt werden.

Beispiel 5: C# Verschachtelte Schleife: Unterschiedliche innere und äußere Schleifen

using System;
namespace Loop {
    class NestedLoop {
        public static void Main(string[] args) {
            int i = 1;
            while (i <= 5) {
                for (int j = 1; j <= i; j++) {
                    Console.Write(i + " ");
                }
                Console.WriteLine();
                i++;
            }
        }
    }
}

Ausgabe:

1
2 2
3 3 3
4 4 4 4
5 5 5 5 5

Im obigen Programm ist eine for-Schleife innerhalb einer while-Schleife platziert. Verschiedene Schleifentypen können ineinander verschachtelt werden.