Swift Academy · Lekcja

Wyliczenia indirect i struktury rekurencyjne

Budowanie list wiązanych i drzew za pomocą przypadków wyliczeń indirect.

Wyliczenia indirect i struktury rekurencyjne to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 3 z 4. 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 Swift Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Swift Academy zawiera 4 lekcji w sumie.

Wprowadzenie

Przypadek typu wyliczeniowego `indirect` przechowuje swoją wartość powiązaną za wskaźnikiem, co umożliwia tworzenie rekurencyjnych struktur danych, takich jak listy jednokierunkowe, drzewa i drzewa wyrażeń.

Dlaczego potrzebne jest indirect

Bez `indirect` typ wyliczeniowy odwołujący się do samego siebie miałby nieskończony rozmiar: ```swift enum List { case empty case node(T, List) // ❌ recursive without size bound } ``` `indirect` dodaje alokację na stercie, dzięki czemu rozmiar ogranicza się do rozmiaru wskaźnika.

Definiowanie typu wyliczeniowego indirect

```swift indirect enum List { case empty case node(T, List) } let list = List.node(1, .node(2, .node(3, .empty))) // [1, 2, 3] ```

Przykład drzewa binarnego

```swift indirect enum Tree { case leaf case branch(left: Tree, value: T, right: Tree) } let t = Tree.branch(left: .leaf, value: 5, right: .branch(left:.leaf, value:10, right:.leaf)) ```

Funkcja rekurencyjna dla typu wyliczeniowego indirect

```swift func sum(_ list: List) -> Int { switch list { case .empty: return 0 case .node(let value, let rest): return value + sum(rest) } } print(sum(list)) // 6 ```

Wysokość drzewa

```swift func height(_ tree: Tree) -> Int { switch tree { case .leaf: return 0 case .branch(let l, _, let r): return 1 + max(height(l), height(r)) } } ```

Drzewa wyrażeń

```swift indirect enum Expr { case num(Double) case add(Expr, Expr) case mul(Expr, Expr) } func eval(_ e: Expr) -> Double { switch e { case .num(let n): return n case .add(let a, let b): return eval(a) + eval(b) case .mul(let a, let b): return eval(a) * eval(b) } } print(eval(.mul(.num(2), .add(.num(3), .num(4))))) // 14 ```

indirect dla poszczególnych przypadków

Można oznaczyć jako `indirect` tylko rekurencyjne przypadki, zamiast oznaczać cały typ wyliczeniowy: ```swift enum Tree { case leaf indirect case branch(left: Tree, value: T, right: Tree) } ``` Jest to dokładniejsze rozwiązanie — tylko rekurencyjny przypadek wymaga alokacji na stercie.

Kwestie wydajności

Przypadki `indirect` są alokowane na stercie. W przypadku rekurencyjnych struktur o krytycznym znaczeniu dla wydajności warto rozważyć użycie klasy albo reprezentacji opartej na tablicy i odwołaniach.

Kiedy używać typów wyliczeniowych indirect

Dobre zastosowania: • Listy jednokierunkowe i funkcyjne struktury danych • Drzewa składni abstrakcyjnej (parsery, kalkulatory) • Hierarchie systemu plików • Reprezentacje drzew JSON/XML Należy unikać tego rozwiązania, gdy reprezentacje oparte na płaskich tablicach zapewniają lepsze wykorzystanie pamięci podręcznej.

Szybkie sprawdzenie

Co `indirect` dodaje do przypadku typu wyliczeniowego?

Podsumowanie

Najważniejsze informacje: • `indirect enum` lub `indirect case` umożliwia tworzenie typów rekurencyjnych • Jest potrzebne, ponieważ rekurencyjne typy wartości miałyby nieskończony rozmiar • Stosuje się je w listach jednokierunkowych, drzewach i drzewach składni abstrakcyjnej • Przechodzenie po strukturze odbywa się za pomocą funkcji rekurencyjnych i `switch` • `indirect` dla pojedynczego przypadku jest dokładniejsze niż `indirect` dla całego typu wyliczeniowego Dalej: modelowanie maszyn stanów za pomocą typów wyliczeniowych.

Często zadawane pytania

Czy lekcja „Wyliczenia indirect i struktury rekurencyjne” jest bezpłatna?

Tak — pełny tekst „Wyliczenia indirect i struktury rekurencyjne” 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 Swift Academy, przejdź na CoddyKit PRO. Kurs Swift Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Wyliczenia indirect i struktury rekurencyjne”?

Budowanie list wiązanych i drzew za pomocą przypadków wyliczeń indirect. Ćwiczysz Swift 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ąć Swift Academy?

Nie wymagamy żadnego doświadczenia. Swift 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 3 z 4.

Ile czasu zajmuje lekcja „Wyliczenia indirect i struktury rekurencyjne”?

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 Swift Academy?

Tak. Każda lekcja Swift 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

Wartości surowe i CaseIterable
Wartości powiązane dla bogatych danych
Wyliczenia indirect i struktury rekurencyjne
Modelowanie automatów stanów za pomocą wyliczeń

← Powrót do Swift Academy