Pile C# avec exemples Push & Pop

Qu’est-ce que Stack en C# ?

La pile est une collection de cas particuliers qui représente un concept du dernier entré, premier sorti (LIFO). Pour d’abord comprendre LIFO, prenons un exemple. Imaginez une pile de livres, chaque livre étant superposé.

Le concept du dernier entré, premier sorti dans le cas des livres signifie que seul le livre le plus haut peut être retiré de la pile de livres. Il n'est pas possible de retirer un livre entre les deux, car cela perturberait le positionnement de la pile.

Donc dans C#, la pile fonctionne également de la même manière. Les éléments sont ajoutés à la pile, les uns sur les autres. Le processus d’ajout d’un élément à la pile est appelé opération push. Pour supprimer un élément d'une pile, vous pouvez également supprimer l'élément le plus haut de la pile. Cette opération est connue sous le nom de pop.

Examinons plus en détail les opérations disponibles pour la collection Stack.

Déclaration de la pile

Une pile est créée à l'aide du type Stack Data. Le mot clé « new » est utilisé pour créer un objet d’une Stack. L'objet est ensuite affecté à la variable st.

Stack st = new Stack()

Ajout d'éléments à la pile

La méthode push est utilisée pour ajouter un élément sur la pile. La syntaxe générale de l'instruction est donnée ci-dessous.

Stack.push(element)

Supprimer des éléments de la pile

La méthode pop est utilisée pour supprimer un élément de la pile. L'opération pop renverra l'élément le plus haut de la pile. La syntaxe générale de l'instruction est donnée ci-dessous

 Stack.pop()

que vous avez

Cette propriété est utilisée pour obtenir le nombre d'éléments dans la pile. Vous trouverez ci-dessous la syntaxe générale de cette instruction.

Stack.Count

Inclus

Cette méthode est utilisée pour voir si un élément est présent dans la Stack. Vous trouverez ci-dessous la syntaxe générale de cette instruction. L'instruction renverra vrai si l'élément existe, sinon elle renverra la valeur faux.

Stack.Contains(element)

Voyons maintenant que cela fonctionne au niveau du code. Tout le code mentionné ci-dessous sera écrit dans notre Application console. Le code sera écrit dans notre fichier Program.cs.

Dans le programme ci-dessous, nous écrirons le code pour voir comment nous pouvons utiliser les méthodes mentionnées ci-dessus.

Exemple 1 : méthode Stack.Push()

Dans cet exemple, nous verrons

• Comment une pile est créée.
• Comment afficher les éléments de la pile, et utiliser les méthodes Count et Contain.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DemoApplication
{
 class Program
 {
  static void Main(string[] args)
  {
   Stack st = new Stack();
   st.Push(1);
   st.Push(2);
   st.Push(3);

   foreach (Object obj in st)
   {
    Console.WriteLine(obj);
   }
    Console.WriteLine(); Console.WriteLine();
    Console.WriteLine("The number of elements in the stack " +st.Count);
    Console.WriteLine("Does the stack contain the elements 3 "+st.Contains(3));
    Console.ReadKey();
  }
 }
}

Code Explication:-

1. La première étape permet de déclarer la Stack. Ici, nous déclarons « st » comme variable pour contenir les éléments de notre pile.
2. Ensuite, nous ajoutons 3 éléments à notre pile. Chaque élément est ajouté via la méthode Push.
3. Maintenant, puisque les éléments de la pile ne sont pas accessibles via la position d'index comme le liste des tableaux, nous devons utiliser une approche différente pour afficher les éléments de la pile. L'objet (obj) est une variable temporaire, déclarée pour contenir chaque élément de la pile. Nous utilisons ensuite l'instruction foreach pour parcourir chaque élément de la pile. Pour chaque élément de pile, la valeur est attribuée à la variable obj. Nous utilisons ensuite la commande Console.Writeline pour afficher la valeur sur la console.
4. Nous utilisons la propriété Count (st.count) pour obtenir le nombre d'éléments dans la pile. Cette propriété renverra un numéro. Nous affichons ensuite cette valeur à la console.
5. Nous utilisons ensuite la méthode Contains pour voir si la valeur 3 est présente dans notre pile. Cela renverra une valeur vraie ou fausse. Nous affichons ensuite cette valeur de retour à la console.

Si le code ci-dessus est entré correctement et que le programme est exécuté, la sortie suivante sera affichée.

Sortie :

À partir du résultat, nous pouvons voir que les éléments de la pile sont affichés. De plus, la valeur True est affichée pour indiquer que la valeur 3 est définie sur la pile.

Note: Vous avez remarqué que le dernier élément poussé sur la pile est affiché en premier. Il s'agit de l'élément le plus haut de la pile. Le nombre d'éléments de pile est également affiché dans la sortie.

Exemple 2 : méthode Stack.Pop()

Examinons maintenant la fonctionnalité « supprimer ». Nous verrons le code requis pour supprimer l'élément le plus haut de la pile.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DemoApplication
{
 class Program
 {
  static void Main(string[] args)
  {
   Stack st = new Stack();
   st.Push(1);
   st.Push(2);
   st.Push(3);
   
   st.Pop();

   foreach (Object obj in st)
   {
    Console.WriteLine(obj);
   }
    Console.ReadKey();
  }
 }
}

Code Explication:-

1. Ici, nous émettons simplement la méthode pop qui est utilisée pour supprimer un élément de la pile.

Si le code ci-dessus est saisi correctement et que le programme est exécuté, la sortie suivante sera affichée.

Sortie :

On voit que l'élément 3 a été supprimé de la pile.

C# Stack Peek() Method

The Push and Pop methods work with the top of the stack, but sometimes you only need to look at the top element without removing it. The Peek method does exactly that. It returns the topmost value of the stack while leaving the collection unchanged, which is useful when you want to test the next item before deciding to pop it.

Étape 1) Create a stack and push three elements onto it, so the value 3 sits on top.

Étape 2) Call the Peek method to read the top element, then check the Count property to confirm nothing was removed.

using System;
using System.Collections;

namespace DemoApplication
{
 class Program
 {
  static void Main(string[] args)
  {
   Stack st = new Stack();
   st.Push(1);
   st.Push(2);
   st.Push(3);
   Console.WriteLine(st.Peek());
   Console.WriteLine(st.Count);
   Console.ReadKey();
  }
 }
}

Code Explication:-

1. A stack named st is declared, and the values 1, 2, and 3 are added with the Push method, so 3 becomes the topmost element.
2. The Peek method returns the top element without removing it, and the Count property still reports the full number of items in the stack.

When the program runs, it prints the value 3 from Peek and then the count 3, which proves the element stays on the stack. If the stack is empty, Peek throws an InvalidOperationException, so it is safe to check Count before calling it.

Generic Stack<T> in C#

The examples above use the non-generic Stack class from System.Collections, which stores every element as an object. Modern C# code usually prefers the generic Stack<T> class from the System.Collections.Generic namespace. It binds the stack to a single declared type, so the compiler checks every Push and Pop and no casting or boxing is needed.

The key benefits of the generic Stack<T> are listed below.

• Sécurité du type : The type is fixed at declaration, so only values of that type can be pushed, and errors are caught at compile time.
• No boxing: Value types such as int are stored directly, which avoids the boxing cost that the non-generic Stack pays.
• Cleaner reads: Pop and Peek return the declared type directly, so you do not cast the result back from object.

using System;
using System.Collections.Generic;

namespace DemoApplication
{
 class Program
 {
  static void Main(string[] args)
  {
   Stack<string> st = new Stack<string>();
   st.Push("Java");
   st.Push("Python");
   Console.WriteLine(st.Pop());
   Console.ReadKey();
  }
 }
}

In this example the stack is declared as Stack<string>, so it accepts only string values. The Pop method returns a string directly and prints Python, the last value pushed. For any new project, the generic Stack<T> is the recommended choice.

Difference Between Stack and Queue in C#

A stack and a file are both collections that control the order in which elements are removed, but they use opposite rules. A stack is last in, first out, while a queue is first in, first out. Choosing the right one makes the intent of your code clear to other developers.

Les principales différences sont énumérées ci-dessous :

• Commande: A stack removes the most recently added element first (LIFO), while a queue removes the oldest element first (FIFO).
• Méthodologie: A stack uses Push and Pop, whereas a queue uses Enqueue to add and Dequeue to remove.
• Top-element access: A stack reads its next item with Peek, and a queue reads its next item with Peek from the front.
• Utilisations typiques: Stacks fit undo features, expression evaluation, and recursion tracking, while queues fit scheduling, buffering, and breadth-first traversal.

Both types are available in generic form as Stack<T> and Queue<T> in System.Collections.Generic, so you gain type safety with either choice.

FAQ