C# Academy · Lektion

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

Verstehen Sie den Unterschied zwischen Mengen mit eindeutigen und sortierten Elementen sowie zwischen FIFO- und LIFO-Sammlungen. Üben Sie Add/Contains, Enqueue/Dequeue und Push/Pop.

HashSet<T>, SortedSet<T>, Queue<T>, Stack<T> ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C# Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C# Academy-Kurs umfasst insgesamt 3 Lektionen.

Strukturen von Collections

Ziel: Wählen Sie die passende Collection.

HashSet<T>: eindeutig, schnelle Suche
SortedSet<T>: eindeutig und sortiert
Queue<T>: FIFO
Stack<T>: LIFO

Grundlagen von HashSet

HashSet<T> speichert eindeutige Werte; Add gibt bei Duplikaten false zurück; Contains ist schnell.

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
  }
}

Grundlagen von SortedSet

SortedSet<T> hält Elemente beim Hinzufügen eindeutig und sortiert.

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> arbeitet nach dem FIFO-Prinzip: Enqueue → Dequeue. Verwenden Sie Peek, um ein Element anzusehen, ohne es zu entfernen.

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> arbeitet nach dem LIFO-Prinzip: Push → Pop. Peek betrachtet das oberste Element.

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
  }
}

Tipps zur Auswahl

Spickzettel:

Sie benötigen Eindeutigkeit und schnelle Suche → HashSet<T>
Sie benötigen Eindeutigkeit und sortierte Reihenfolge → SortedSet<T>
Verarbeitung in der Reihenfolge des Eintreffens → Queue<T> (FIFO)
Das zuletzt hinzugefügte Element zuerst verarbeiten → Stack<T> (LIFO)

Auswahl eines Sets

Kurzer Check: Welche Collection stellt eindeutige Elemente sicher und bietet im Durchschnitt eine schnelle Suche nach Werten?

Zusammenfassung

Zusammenfassung: Verwenden Sie Sets für Eindeutigkeit (HashSet, SortedSet) und wählen Sie für die geordnete Verarbeitung FIFO (Queue) oder LIFO (Stack).

Häufig gestellte Fragen

Ist die Lektion „HashSet<T>, SortedSet<T>, Queue<T>, Stack<T>“ kostenlos?

Ja — der vollständige Text von „HashSet<T>, SortedSet<T>, Queue<T>, Stack<T>“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C# Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C# Academy-Kurs umfasst insgesamt 3 Lektionen.

Was lerne ich in „HashSet<T>, SortedSet<T>, Queue<T>, Stack<T>“?

Verstehen Sie den Unterschied zwischen Mengen mit eindeutigen und sortierten Elementen sowie zwischen FIFO- und LIFO-Sammlungen. Üben Sie Add/Contains, Enqueue/Dequeue und Push/Pop. Du übst C# Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C# Academy zu starten?

Keine Vorkenntnisse erforderlich. C# Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 3.

Wie lange dauert die Lektion „HashSet<T>, SortedSet<T>, Queue<T>, Stack<T>“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C# Academy-Lektion Code schreiben und ausführen?

Ja. Jede C# Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

HashSet , SortedSet , Queue , Stack
ConcurrentDictionary und unveränderliche Sammlungen
Gleichheit und Hashing (Wert und Referenz)

← Zurück zu C# Academy