0Pricing
C# Academy · Leçon

HashSet<T>, SortedSet<T>, Queue<T> et Stack<T>

Comprenez la différence entre les ensembles de valeurs uniques et les ensembles ordonnés, ainsi que les collections FIFO/LIFO ; pratiquez Add/Contains, Enqueue/Dequeue et Push/Pop.

HashSet<T>, SortedSet<T>, Queue<T> et Stack<T> est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 3 leçons au total.

Formes des collections

Objectif : choisir la collection appropriée.

  • HashSet<T> : valeurs uniques, recherche rapide
  • SortedSet<T> : valeurs uniques et triées
  • Queue<T> : FIFO
  • Stack<T> : LIFO

Bases de HashSet

HashSet<T> conserve des valeurs uniques ; Add renvoie false en cas de doublon ; Contains est rapide.

using System;
using System.Collections.Generic;

public class Program
{
  public static void Main(string[] args)
  {
    HashSet<string> tags = new HashSet<string>();
    bool a1 = tags.Add("red");   // true
    bool a2 = tags.Add("blue");  // true
    bool a3 = tags.Add("red");   // false (duplicate ignored)

    Console.WriteLine("Has red? " + tags.Contains("red"));
    Console.WriteLine("Count = " + tags.Count); // 2
  }
}

Bases de SortedSet

SortedSet<T> conserve les éléments uniques et triés au fur et à mesure de leur ajout.

using System;
using System.Collections.Generic;

public class Program
{
  public static void Main(string[] args)
  {
    SortedSet<int> scores = new SortedSet<int>();
    scores.Add(30);
    scores.Add(10);
    scores.Add(20);
    scores.Add(20); // duplicate ignored

    foreach (int s in scores)
    {
      Console.WriteLine(s); // 10, 20, 30 (sorted ascending)
    }

    Console.WriteLine("Min = " + (scores.Count > 0 ? scores.Min : 0));
    Console.WriteLine("Max = " + (scores.Count > 0 ? scores.Max : 0));
  }
}

Queue (FIFO)

Queue<T> suit le principe FIFO : Enqueue → Dequeue. Utilisez Peek pour consulter un élément sans le supprimer.

using System;
using System.Collections.Generic;

public class Program
{
  public static void Main(string[] args)
  {
    Queue<string> q = new Queue<string>();
    q.Enqueue("A");
    q.Enqueue("B");
    q.Enqueue("C");

    Console.WriteLine("Peek = " + q.Peek()); // A
    Console.WriteLine(q.Dequeue());          // A
    Console.WriteLine(q.Dequeue());          // B
    Console.WriteLine("Count = " + q.Count); // 1
  }
}

Stack (LIFO)

Stack<T> suit le principe LIFO : Push → Pop. Peek consulte l’élément situé au sommet.

using System;
using System.Collections.Generic;

public class Program
{
  public static void Main(string[] args)
  {
    Stack<int> st = new Stack<int>();
    st.Push(1);
    st.Push(2);
    st.Push(3);

    Console.WriteLine("Peek = " + st.Peek()); // 3
    Console.WriteLine(st.Pop());              // 3
    Console.WriteLine(st.Pop());              // 2
    Console.WriteLine("Count = " + st.Count); // 1
  }
}

Conseils de sélection

Aide-mémoire :

  • Unicité et recherche rapide → HashSet<T>
  • Unicité et ordre trié → SortedSet<T>
  • Traitement dans l’ordre d’arrivée → Queue<T> (FIFO)
  • Traitement du dernier arrivé au premier → Stack<T> (LIFO)

Choix de l’ensemble

Vérification rapide : quelle collection garantit des éléments uniques et fournit en moyenne une recherche rapide par valeur ?

Récapitulatif

Récapitulatif : utilisez les ensembles pour garantir l’unicité (HashSet, SortedSet) et choisissez FIFO (Queue) ou LIFO (Stack) pour le traitement ordonné.

Questions Fréquemment Posées

La leçon « HashSet<T>, SortedSet<T>, Queue<T> et Stack<T> » est-elle gratuite ?

Oui — le texte complet de « HashSet<T>, SortedSet<T>, Queue<T> et Stack<T> » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 3 leçons au total.

Qu'est-ce que j'apprendrai dans « HashSet<T>, SortedSet<T>, Queue<T> et Stack<T> » ?

Comprenez la différence entre les ensembles de valeurs uniques et les ensembles ordonnés, ainsi que les collections FIFO/LIFO ; pratiquez Add/Contains, Enqueue/Dequeue et Push/Pop. Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C# Academy ?

Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 3.

Combien de temps prend la leçon « HashSet<T>, SortedSet<T>, Queue<T> et Stack<T> » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?

Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. HashSet , SortedSet , Queue et Stack
  2. ConcurrentDictionary et collections immuables
  3. Égalité et hachage (valeur et référence)
← Retour à C# Academy