Swift Academy · Lección

Enumeraciones indirectas y estructuras recursivas

Construya listas enlazadas y árboles mediante casos de enumeraciones indirectas.

Enumeraciones indirectas y estructuras recursivas es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Swift Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Swift Academy incluye 4 lecciones en total.

Introducción

Un caso de enumeración `indirect` almacena su valor asociado detrás de un puntero, lo que permite crear estructuras de datos recursivas, como listas enlazadas, árboles y árboles de expresiones.

Por qué se necesita indirect

Sin `indirect`, una enumeración que se referencia a sí misma tendría un tamaño infinito: ```swift enum List { case empty case node(T, List) // ❌ recursive without size bound } ``` `indirect` añade una asignación en el montón, por lo que el tamaño se reduce al de un puntero.

Definición de una enumeración indirecta

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

Ejemplo de árbol binario

```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)) ```

Función recursiva sobre una enumeración indirecta

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

Altura de un árbol

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

Árboles de expresiones

```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 por caso

Puede marcar solo los casos recursivos con `indirect` en lugar de marcar toda la enumeración: ```swift enum Tree { case leaf indirect case branch(left: Tree, value: T, right: Tree) } ``` Esto es más preciso: solo el caso recursivo requiere una asignación en el montón.

Consideración sobre el rendimiento

Los casos `indirect` se asignan en el montón. Para estructuras recursivas en las que el rendimiento sea crítico, considere usar una clase o hacer referencia a una representación basada en un array.

Cuándo usar enumeraciones indirectas

Casos de uso adecuados: • Listas enlazadas y estructuras de datos funcionales • Árboles de sintaxis abstracta (analizadores y calculadoras) • Jerarquías de sistemas de archivos • Representaciones de árboles JSON/XML Evítelas cuando las representaciones planas basadas en arrays sean más eficientes para la caché.

Comprobación rápida

¿Qué añade `indirect` a un caso de enumeración?

Resumen

Conceptos clave: • `indirect enum` o `indirect case` permite crear tipos recursivos • Es necesario porque los tipos de valor recursivos tendrían un tamaño infinito • Se usa para listas enlazadas, árboles y AST • Se recorren mediante funciones recursivas y switch • `indirect` por caso es más preciso que `indirect` para toda la enumeración Siguiente: modelado de máquinas de estados con enumeraciones.

Preguntas frecuentes

¿La lección «Enumeraciones indirectas y estructuras recursivas» es gratis?

Sí — el texto completo de «Enumeraciones indirectas y estructuras recursivas» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Swift Academy, actualiza a CoddyKit PRO. El curso de Swift Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Enumeraciones indirectas y estructuras recursivas»?

Construya listas enlazadas y árboles mediante casos de enumeraciones indirectas. Practicas Swift Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Swift Academy?

No se requiere experiencia previa. Swift Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Enumeraciones indirectas y estructuras recursivas»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Swift Academy?

Sí. Cada lección de Swift Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Valores raw y CaseIterable
Valores asociados para datos enriquecidos
Enumeraciones indirectas y estructuras recursivas
Modelado de máquinas de estados con enumeraciones

← Volver a Swift Academy