Maîtriser les boucles imbriquées en C# :For, While et Do-While expliqués
Une boucle dans une autre boucle est appelée boucle imbriquée. Voici à quoi ressemble une boucle imbriquée :
Outer-Loop
{
// body of outer-loop
Inner-Loop
{
// body of inner-loop
}
... ... ...
}
Comme vous pouvez le constater, la boucle externe renferme la boucle interne . La boucle interne fait partie de la boucle externe et doit commencer et se terminer dans le corps de la boucle externe.
A chaque itération de la boucle externe, la boucle interne est exécutée complètement.
Boucle for imbriquée
Une boucle for à l'intérieur d'une autre boucle for est appelée boucle for imbriquée.
Par exemple :
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
}
Exemple 1 : boucle for imbriquée
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);
}
}
}
Lorsque nous exécutons le programme, le résultat sera :
Outer Loop runs 5 times Inner Loop runs 25 times
Dans ce programme, la boucle externe s'exécute 5 fois. Chaque fois que la boucle externe s'exécute, la boucle interne s'exécute 5 fois, ce qui la fait fonctionner 25 fois au total.
Exemple 2 :Boucle for imbriquée pour imprimer le motif
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();
}
}
}
}
Lorsque nous exécutons le programme, le résultat sera :
1 1 2 1 2 3 1 2 3 4 1 2 3 4 5
Boucle while imbriquée
Une boucle while à l'intérieur d'une autre boucle while est appelée boucle while imbriquée.
Par exemple :
while (condition-1)
{
// body of outer while loop
while (condition-2)
{
// body of inner while loop
}
// body of outer while loop
}
Exemple 3 :Boucle while imbriquée
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();
}
}
}
}
Lorsque nous exécutons le programme, le résultat sera :
(0,0) (0,1) (1,0) (1,1)
Boucle do-while imbriquée
Une boucle do-while à l'intérieur d'une autre boucle do-while est appelée boucle do-while imbriquée.
Par exemple :
do
{
// body of outer while loop
do
{
// body of inner while loop
} while (condition-2);
// body of outer while loop
} while (condition-1);
Exemple 4 :boucle do-while imbriquée
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);
}
}
}
Lorsque nous exécutons le programme, le résultat sera :
(0,0) (0,1) (1,0) (1,1)
Différentes boucles imbriquées intérieures et extérieures
Il n'est pas obligatoire d'imbriquer le même type de boucle. Nous pouvons mettre une boucle for dans une boucle while ou une boucle do-while dans une boucle for.
Exemple 5 : boucle imbriquée C# :différentes boucles internes et externes
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++;
}
}
}
}
Lorsque nous exécutons le programme, le résultat sera :
1 2 2 3 3 3 4 4 4 4 5 5 5 5 5
Dans le programme ci-dessus, une boucle for est placée dans une boucle while. Nous pouvons utiliser différents types de boucles à l'intérieur d'une boucle.
Langue C