C# Academy · Lekcja

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

Proszę zrozumieć różnicę między zbiorami unikatowymi a uporządkowanymi oraz kolekcjami FIFO/LIFO, a także przećwiczyć Add/Contains, Enqueue/Dequeue i Push/Pop.

HashSet<T>, SortedSet<T>, Queue<T>, Stack<T> to bezpłatna lekcja C# Academy na CoddyKit. To lekcja 1 z 3. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C# Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C# Academy zawiera 3 lekcji w sumie.

Rodzaje kolekcji

Cel: Wybierać odpowiednią kolekcję.

HashSet<T>: unikatowość i szybkie wyszukiwanie
SortedSet<T>: unikatowość i sortowanie
Queue<T>: FIFO
Stack<T>: LIFO

Podstawy HashSet

HashSet<T> przechowuje unikatowe wartości; Add zwraca false w przypadku duplikatów; Contains działa szybko.

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

Podstawy SortedSet

SortedSet<T> przechowuje elementy jako unikatowe i posortowane podczas ich dodawania.

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

Kolejka (FIFO)

Queue<T> działa zgodnie z zasadą FIFO: Enqueue → Dequeue. Użyj Peek, aby sprawdzić element bez jego usuwania.

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

Stos (LIFO)

Stack<T> działa zgodnie z zasadą LIFO: Push → Pop. Peek sprawdza element na szczycie.

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

Wskazówki dotyczące wyboru

Podręczna ściąga:

Potrzebna jest unikatowość i szybkie wyszukiwanie → HashSet<T>
Potrzebna jest unikatowość i uporządkowanie → SortedSet<T>
Przetwarzanie w kolejności nadejścia → Queue<T> (FIFO)
Przetwarzanie od ostatnio dodanego elementu → Stack<T> (LIFO)

Wybór zbioru

Szybkie sprawdzenie: Która kolekcja gwarantuje unikatowość elementów i zapewnia średnio stałoczasowe wyszukiwanie według wartości?

Podsumowanie

Podsumowanie: Używaj zbiorów do zapewnienia unikatowości (HashSet, SortedSet), a do uporządkowanego przetwarzania wybierz FIFO (Queue) lub LIFO (Stack).

Często zadawane pytania

Czy lekcja „HashSet<T>, SortedSet<T>, Queue<T>, Stack<T>” jest bezpłatna?

Tak — pełny tekst „HashSet<T>, SortedSet<T>, Queue<T>, Stack<T>” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C# Academy, przejdź na CoddyKit PRO. Kurs C# Academy zawiera 3 lekcji w sumie.

Co nauczysz się w „HashSet<T>, SortedSet<T>, Queue<T>, Stack<T>”?

Proszę zrozumieć różnicę między zbiorami unikatowymi a uporządkowanymi oraz kolekcjami FIFO/LIFO, a także przećwiczyć Add/Contains, Enqueue/Dequeue i Push/Pop. Ćwiczysz C# Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć C# Academy?

Nie wymagamy żadnego doświadczenia. C# Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 3.

Ile czasu zajmuje lekcja „HashSet<T>, SortedSet<T>, Queue<T>, Stack<T>”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji C# Academy?

Tak. Każda lekcja C# Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

HashSet , SortedSet , Queue , Stack
ConcurrentDictionary i kolekcje niezmienne
Równość i haszowanie (wartość a referencja)

← Powrót do C# Academy