Independientemente del lenguaje de programación que utilice, a medida que comienza a codificar más y más, aprende conceptos que hacen que su código sea nítido y fácil de leer/comprender. También hay varios conceptos de este tipo en la C. Una de ellas son las 'funciones recursivas', de las que hablaremos aquí en este artículo.
Una función recursiva es una función que se llama a sí misma. La llamada se puede hacer directamente desde el cuerpo de la función, o indirectamente desde alguna otra función que sea llamada por la función en cuestión.
El siguiente es un ejemplo de recursividad directa:
int func (int a)
{
//statements
func(a-1);
// statements
return 0;
}
Y aquí hay un ejemplo de recursividad indirecta:
int func (int a)
{
//statements
func_new(a);
// statements
return 0;
}
int func_new(int b)
{
//statements
func(b-1);
//statementsur
return 0;
}
Como ya se mencionó al principio, la recursividad lo ayuda a lograr un código compacto, uno que no solo es fácil de escribir sino también fácil de entender y revisar. Tomemos un ejemplo para que esta ventaja sea más clara.
Estoy seguro de que todos ustedes deben haber oído hablar del concepto de factorial. Para aquellos que no lo saben, el factorial es el resultado que obtienes cuando multiplicas un número entero con todos los números enteros positivos menores que él. Por ejemplo, el factorial de 5 es 5x4x3x2x1, que es igual a 120.
Aquí hay un código simple para encontrar el factorial de un número:
#include <stdio.h>
int main()
{
int a = 0, i = 0, fact = 1;
printf("Enter a number: ");
scanf("%d", &a);
for(i=1; i<=a; i++)
{
fact = fact * i;
}
printf("Factorial of the number is: %d ", fact);
return 0;
}
Tenga en cuenta que este código es solo para informarle cómo se puede calcular el factorial de un número a través de un programa C. El programa no se ocupa de los casos extremos que pueden afectar la precisión del resultado que produce.
Entonces, esta es una de las muchas formas en que puede calcular el factorial de un número sin usar una función recursiva. Ahora veamos un fragmento de código que usa la recursividad para calcular un factorial.
#include <stdio.h>
int factorial (int b)
{
if(!b)
return 1;
return (b * factorial(b-1));
}
int main()
{
int a = 0, fact = 1;
printf("Enter a number: ");
scanf("%d", &a);
fact = factorial(a);
printf("Factorial of the number is: %d ", fact);
return 0;
}
Como puede ver, la función 'factorial' que en realidad calcula el factorial es muy compacta. Y si presta mucha atención, también es muy fácil de entender.
Para aquellos que no saben lo que está sucediendo, el valor que el usuario ha ingresado, digamos 5, se pasa a la función 'factorial' cuando se llama por primera vez desde dentro de la función 'principal'. Dentro de la función 'factorial', hay una verificación para ver si el valor de entrada es cero, lo cual no es cierto cuando la función se llama por primera vez con el valor de entrada '5'.
Luego, la declaración de retorno contiene una expresión que multiplica 5 con el valor de retorno de 'factorial(4)'. Entonces ahora, la función 'factorial' se ejecuta una vez más, y llegamos a la siguiente expresión:return (4 * factorial(3)). Y luego nuevamente estos pasos se repiten.
Entonces, si miras en términos generales, así es como se apilan estas llamadas a funciones:
- 5 * factoriales(4)
- 4 * factoriales(3)
- 3 * factorial(2)
- 2 * factoriales (1)
- 1 * factoriales (0)
Ahora, cuando se ejecuta factorial(0), la condición 'si' en la función 'factorial' se vuelve verdadera y se devuelve el valor '1'. Ahora, así es como se completan las llamadas enumeradas anteriormente (compare la última entrada en la lista anterior con la primera entrada en esta lista, y así sucesivamente):
- 1 * 1
- 2 * (1*1)
- 3 * (2*(1*1))
- 4 * (3*(2*(1*1)))
- 5 * (4 * (3*(2*(1*1))))
Que es efectivamente 5 * 4 * 3 * 2 * 1, que a su vez es 120, el factorial de 5.
Así es como funcionan las funciones recursivas. Si bien no hay duda acerca de las ventajas de la función recursiva que enumeramos hasta ahora, también existen algunas desventajas.
Por ejemplo, en nuestro ejemplo anterior, hasta que se completó la llamada 'factorial (0)', todas las llamadas 'factoriales' anteriores estaban esperando que se completara el procesamiento de la función. Por no hablar del hecho de que las variables automáticas o locales ocupan memoria por cada llamada recursiva realizada.
Entonces, efectivamente, no hay ahorros en el espacio de almacenamiento cuando usa la recursividad. Además, tampoco hay garantía de que su código sea más rápido en ejecución. La verdadera ventaja de una función recursiva es cuando se trata de estructuras de datos, que se analizarán más adelante como parte de esta serie de tutoriales de C en curso.
Conclusión
Para concluir, si bien es posible que no use la función recursiva con frecuencia en sus tareas de codificación diarias, es un concepto importante que debe tener en cuenta. Pruebe el ejemplo que hemos mencionado aquí y modifíquelo para comprender aún mejor el concepto de funciones recursivas.