Conceptos básicos de recursión
Funciones recursivas
Conceptos básicos de recursión es una lección gratuita de Scala for Backend Engineering & Functional Programming en CoddyKit. Esta es la lección 1 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 Scala for Backend Engineering & Functional Programming, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.
¿Qué es la recursión?
La recursión ocurre cuando una función se llama a sí misma para resolver una versión más pequeña del mismo problema. Encaja de forma natural con la programación funcional y sustituye muchos bucles por definiciones autorreferentes.
Dos partes esenciales
Toda función recursiva correcta necesita:
- Un caso base que detenga la recursión.
- Un caso recursivo que avance hacia el caso base.
Sin un caso base alcanzable, la recursión se ejecuta indefinidamente.
Factorial
El ejemplo clásico: n! = n * (n-1)!, con 0! = 1 como caso base.
object Main {
def factorial(n: Int): Int =
if (n <= 1) 1
else n * factorial(n - 1)
def main(args: Array[String]): Unit = {
println(factorial(5))
}
}Seguir las llamadas
Cada llamada recursiva se pausa y espera el resultado interno. factorial(3) se expande a 3 * (2 * (1)). Las multiplicaciones se realizan cuando las llamadas van terminando.
object Main {
def factorial(n: Int): Int = {
println(s"entering factorial($n)")
if (n <= 1) 1 else n * factorial(n - 1)
}
def main(args: Array[String]): Unit = {
println("result = " + factorial(3))
}
}Suma de una lista
Recursión sobre una lista: la suma es la cabeza más la suma de la cola, y la suma de la lista vacía es cero.
object Main {
def sum(xs: List[Int]): Int = xs match {
case Nil => 0
case h :: t => h + sum(t)
}
def main(args: Array[String]): Unit = {
println(sum(List(1, 2, 3, 4)))
}
}Longitud de una lista
El mismo patrón calcula la longitud: la lista vacía tiene longitud 0; en caso contrario, es 1 más la longitud de la cola.
object Main {
def length[A](xs: List[A]): Int = xs match {
case Nil => 0
case _ :: t => 1 + length(t)
}
def main(args: Array[String]): Unit = {
println(length(List("a", "b", "c")))
}
}La pila de llamadas
Cada llamada recursiva pendiente utiliza un marco de pila. Una recursión profunda acumula muchos marcos. Con entradas muy grandes, la pila puede agotarse y producir un StackOverflowError.
Fibonacci
Algunos problemas se ramifican en varias llamadas recursivas. Fibonacci se llama a sí misma dos veces, lo que resulta elegante, pero tiene un coste exponencial.
object Main {
def fib(n: Int): Int =
if (n < 2) n
else fib(n - 1) + fib(n - 2)
def main(args: Array[String]): Unit = {
println(fib(10))
}
}Invertir una lista
La recursión puede construir estructuras nuevas: reverse añade la cabeza después de invertir la cola.
object Main {
def reverse[A](xs: List[A]): List[A] = xs match {
case Nil => Nil
case h :: t => reverse(t) :+ h
}
def main(args: Array[String]): Unit = {
println(reverse(List(1, 2, 3)))
}
}Recursión frente a iteración
Los bucles modifican un contador; la recursión expresa el problema de forma declarativa. Ambas opciones son válidas. La recursión resulta especialmente útil con datos estructurados como árboles y con algoritmos de divide y vencerás, pero la recursión ingenua puede provocar un desbordamiento de pila con entradas lineales grandes.
Máximo común divisor
El algoritmo de Euclides es naturalmente recursivo y converge rápidamente.
object Main {
def gcd(a: Int, b: Int): Int =
if (b == 0) a else gcd(b, a % b)
def main(args: Array[String]): Unit = {
println(gcd(48, 18))
}
}Comprobación rápida
Compruebe sus conocimientos básicos sobre recursión.
Resumen
Ha aprendido los fundamentos de la recursión:
- Toda función recursiva necesita un caso base y un caso recursivo.
- Cada llamada pendiente utiliza un marco de pila; una recursión profunda puede provocar un desbordamiento.
- La recursión expresa de forma natural los algoritmos para listas y árboles.
A continuación, hará que la recursión sea segura frente al desbordamiento de pila mediante la anotación @tailrec.
Preguntas frecuentes
¿La lección «Conceptos básicos de recursión» es gratis?
Sí — el texto completo de «Conceptos básicos de recursión» 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 Scala for Backend Engineering & Functional Programming, actualiza a CoddyKit PRO. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.
¿Qué aprenderé en «Conceptos básicos de recursión»?
Funciones recursivas Practicas Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming?
No se requiere experiencia previa. Scala for Backend Engineering & Functional Programming 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 1 de 4.
¿Cuánto tiempo toma la lección «Conceptos básicos de recursión»?
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 Scala for Backend Engineering & Functional Programming?
Sí. Cada lección de Scala for Backend Engineering & Functional Programming 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
- Conceptos básicos de recursión
- La anotación tailrec
- Patrón acumulador
- Trampolining