C# Pile
En C#, Stack est une structure de données de type dernier entré, premier sorti (LIFO).
Stack convient pour stocker et traiter des données en séquence, où l'élément le plus récemment ajouté est retiré en premier.
Stack représente unecollection d'objets de type dernier entré, premier sorti. Lorsque vous avez besoin d'un accès dernier entré, premier sorti aux éléments, utilisez une pile. Lorsque vous ajoutez un élément à la pile, on l'appellePushélément, et lorsque vous retirez un élément de la pile, on l'appellePopÉlément.
Stack fournit deux implémentations :
- non générique
Stack(System.Collections.Stack): Prend en charge le stockage d'objets de tout type (nécessite des opérations de boxing et d'unboxing). - Génériques
Stack<T>(System.Collections.Generic.Stack<T>): Prend en charge les objets fortement typés, évite le boxing et l'unboxing, et améliore les performances.
Fonctionnalités de Stack :
- Dernier entré, premier sorti: Le dernier élément empilé est le premier dépilé.
- Taille dynamique: La capacité de la pile s'ajuste dynamiquement selon les besoins.
- Prise en charge des génériques: grâce à
Stack<T>Assure la sûreté de type, en évitant les erreurs de conversion de type. - Non thread-safe: par défaut
StacketStack<T>Aucune d'entre elles n'est thread-safe.
Méthodes et propriétés de la classe Stack
Le tableau ci-dessous répertorieStackQuelques membres de classe courantsPropriété:
| Nom de l'attribut | Type | Description |
|---|---|---|
Count | int | Obtient le nombre d'éléments dans la pile. |
SyncRoot | object | Obtient un objet utilisé pour synchroniser l'accès à la pile (non générique). |
IsSynchronized | bool | Indique si l'accès à la pile est synchronisé (thread-safe, toujoursfalse)。 |
Le tableau ci-dessous répertorieStackQuelques membres de classe courantsMéthodes:
| Nom de la méthode | Type de retour | Description |
|---|---|---|
| Opérations sur les éléments | ||
Push(object item) | void | Empile un élément au sommet de la pile. |
Pop() | object | Supprime et renvoie l'élément au sommet de la pile. |
Peek() | object | Renvoie l'élément au sommet de la pile sans le supprimer. |
Clear() | void | Supprime tous les éléments de la pile. |
| Vérification et copie | ||
Contains(object item) | bool | Détermine si un élément existe dans la pile. |
ToArray() | object[] | Copie les éléments de la pile dans un nouveau tableau (avec l'ordre inversé). |
Clone() | object | Crée une copie superficielle de la pile actuelle. |
CopyTo(Array array, int index) | void | Copie les éléments de la pile dans un tableau existant, à partir de l'index spécifié. |
| Prise en charge des énumérateurs | ||
GetEnumerator() | IEnumerator | Retourne un énumérateur utilisé pour parcourir les éléments de la pile. |
| Sécurité des threads | ||
Synchronized(Stack stack) | Stack | Retourne un wrapper de pile thread-safe. |
Exemple
L'exemple suivant illustre l'utilisation d'une pile (Stack).
Pile non générique :
Exemple
using System.Collections;
namespace CollectionsApplication
{
class Program
{
static void Main(string[] args)
{
Stack st = new Stack();
st.Push('A');
st.Push('M');
st.Push('G');
st.Push('W');
Console.WriteLine("Pile actuelle : ");
foreach (char c in st)
{
Console.Write(c + " ");
}
Console.WriteLine();
st.Push('V');
st.Push('H');
Console.WriteLine("La prochaine valeur pouvant être dépilée de la pile : {0}",
st.Peek());
Console.WriteLine("Pile actuelle : ");
foreach (char c in st)
{
Console.Write(c + " ");
}
Console.WriteLine();
Console.WriteLine("Suppression des valeurs ");
st.Pop();
st.Pop();
st.Pop();
Console.WriteLine("Pile actuelle : ");
foreach (char c in st)
{
Console.Write(c + " ");
}
}
}
}
Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :
Current stack: W G M A The next poppable value in stack: H Current stack: H V W G M A Removing values Current stack: G M A
Pile générique :
Exemple
using System.Collections.Generic;
class Program
{
static void Main()
{
Stack<int> stack = new Stack<int>();
// push
stack.Push(10);
stack.Push(20);
stack.Push(30);
// Voir le sommet de la pile
Console.WriteLine($"Sommet : {stack.Peek()}"); // Sortie : 30
// pop
Console.WriteLine($"Dépiler : {stack.Pop()}"); // Sortie : 30
// Pile restante
Console.WriteLine("Éléments restants :");
foreach (var item in stack)
{
Console.WriteLine(item); // Sortie : 20, 10
}
}
}
Différence entre Stack et Stack<T>
Stack (non générique)
- Stocke les objets en tant que
objecttype. - Nécessite une conversion de type explicite lorsqu'il est utilisé, ce qui peut provoquer des exceptions d'exécution.
Stack<T> (générique)
- Assure la sécurité de type et évite les problèmes de conversion de type.
- Meilleures performances car il évite la surcharge liée au boxing et à l'unboxing.