Meistern Sie verschachtelte Schleifen in C#:For, While und Do-While erklärt

Eine Schleife innerhalb einer anderen Schleife wird als verschachtelte Schleife bezeichnet. So sieht eine verschachtelte Schleife aus:

Outer-Loop 
{
 // body of outer-loop
 Inner-Loop
 {
 // body of inner-loop
 }
... ... ...
}

Wie Sie sehen können, die äußere Schleife umschließt die innere Schleife . Die innere Schleife ist Teil der äußeren Schleife und muss innerhalb des Körpers der äußeren Schleife beginnen 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 wird als verschachtelte for-Schleife bezeichnet.

Zum Beispiel:

for (int i=0; i<5; i++)
{
 // body of outer for loop
 for (int j=0; j<5; j++)
 {
 // body of inner for loop
 }
 // body of outer for loop
}

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("Outer Loop runs {0} times", outerLoop);
 Console.WriteLine("Inner Loop runs {0} times", innerLoop);
 }
 }
}

Wenn wir das Programm ausführen, lautet die Ausgabe:

Outer Loop runs 5 times
Inner Loop runs 25 times

In diesem Programm wird die äußere Schleife fünfmal ausgeführt. Jedes Mal, wenn die äußere Schleife ausgeführt wird, wird die innere Schleife fünf Mal ausgeführt, sodass sie insgesamt 25 Mal ausgeführt wird.

Beispiel 2:Verschachtelte for-Schleife zum Drucken von Mustern

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();
 }
 }
 }
}

Wenn wir das Programm ausführen, lautet die 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 wird als verschachtelte While-Schleife bezeichnet.

Zum Beispiel:

while (condition-1)
{
 // body of outer while loop
 while (condition-2)
 {
 // body of inner while loop
 }
 // body of outer while loop
}

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();
 }
 }
 }
}

Wenn wir das Programm ausführen, lautet die Ausgabe:

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

Verschachtelte Do-While-Schleife

Eine Do-While-Schleife innerhalb einer anderen Do-While-Schleife wird als verschachtelte Do-While-Schleife bezeichnet.

Zum Beispiel:

do
{
 // body of outer while loop
 do
 {
 // body of inner while loop
 } while (condition-2);
 // body of outer while loop
} while (condition-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);
 }
 }
}

Wenn wir das Programm ausführen, lautet die Ausgabe:

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

Unterschiedliche innere und äußere verschachtelte Schleifen

Es ist nicht zwingend erforderlich, denselben Schleifentyp zu verschachteln. Wir können eine for-Schleife in eine while-Schleife oder eine do-while-Schleife in eine for-Schleife einfügen.

Beispiel 5:Verschachtelte C#-Schleife:Verschiedene 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++;
 }
 }
 }
}

Wenn wir das Programm ausführen, lautet die Ausgabe:

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

Im obigen Programm wird eine for-Schleife innerhalb einer while-Schleife platziert. Wir können innerhalb einer Schleife verschiedene Arten von Schleifen verwenden.