Tutorial recursividad, ejemplo, ventajas y desventajas en lenguaje C

En este artículo, vamos a aprender todo sobre recursividad, su uso, ventajas y desventajas en el lenguaje de programación C .

Requisito: recursividad en lenguaje C

función recursiva

Una función que llama a sí mismo es una función recursiva . Hay básicamente una declaración en algún lugar dentro de la función que se llama. A veces también se denomina “definición circular” .

Veamos, cómo funciona la recursividad a través de ejemplos ?

Ejemplo 1: Imprimir la suma de 10 números naturales utilizando la recursividad

#include <stdio.h>
//function declaration
int sum(int);
//main code
int main()
{
int n, add;
printf("Enter the number of natural numbers to be added: ");
scanf("%d",&n);
add = sum(n);
printf("The sum of the first %d natural numbers is %d",n,add);
return 0;
}
//recursion function definition
int sum(int n)
{
if (n == 0)
return 0;
else
return(n + sum(n-1)); //calling function itself
}

salida

    Enter the number of natural numbers to be added: 10
The sum of the first 10 natural numbers is 55

marcha en seco del programa:

Cuando entramos en el valor de n = 10 , la función de suma se llama con n como 10 . Ahora, puesto que n no es igual a 0, lo que se devuelve es (n + suma (n-1)) , es decir, (10 + sum (9)) . Como se puede ver, la función se llama de nuevo dentro de la propia función.

Ahora, al lado de salida es (10 + 9 + sum (8)) .

Entonces, (10 + 9 + 8 + sum (7)) y así sucesivamente hasta (10 + 9 + 8 + 7 + 6 + 5 + 4 + 3 + 2 + 1 + suma (0)) .

Aquí, cuando la función es llamada con n = 0 , el valor return es 0. En realidad, esto se parece a (10 + 9 + 8 + 7 + 6 + 5 + 4 + 3 + 2 + 1 + 0 ) lo que equivale a 55 .

Ejemplo 2: Calcular factorial de un número utilizando la recursividad

#include <stdio.h>
//function declaration
int fact (int);
//main code
int main ()
{
int n, result;
printf ("Enter a number whose factorial is to be calculated: ");
scanf ("%d", &n);
if (n < 0)
{
printf ("Fatorial does not exist.");
}
else
{
result = fact(n);
printf("Factorial of %d is %d.", n,result);
}
return 0;
}
//recursion function definition
int fact (int n)
{
if (n == 0 || n == 1)
return 1;
else
return (n * fact (n - 1)); //calling function definition
}

salida

    Enter a number whose factorial is to be calculated: 5
Factorial of 5 is 120.

marcha en seco del programa

Como se desprende de la programa, si entramos en un valor inferior a 0 , el factorial no existe y el final del programa después de eso. Si entramos 0 o 1 , factorial habrá 1 . Else, lo que se devuelve es (n * hecho de (n-1)) , es decir, (5 hecho * (4)) . Como se puede ver, la función se llama de nuevo dentro de la función en sí al igual que el programa anterior.

salida siguiente es (5 * 4 hecho * (3)) y así sucesivamente hasta (5 * 4 * 3 * 2 * hecho (1)) . Aquí, lo que se devuelve es 1 . Así, parece que (5 * 4 * 3 * 2 * 1) que es igual a 120 .

Ejemplo 3: Imprimir la serie de Fibonacci utilizando recursividad

serie de Fibonacci es una serie de números enteros en la que cada número es la suma de dos números anteriores. Los dos primeros números son 0 y 1 y luego el tercer número es la suma de 0 y 1 es decir 1 , el cuarto número es la suma de segundo y tercero, es decir, 1 y 1 e igual 2 . Se puede escribir en la forma más simple como fn = 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, …

#include <stdio.h>
//function declaration
int fib(int);
//Main code
int main()
{
int n, i;
printf("Enter the number of values to be printed from the fibonacci series: ");
scanf("%d",&n);
for(i=0;i<n;i++)
printf("%d ",fib(i));
return 0;
}
//recursion function definition
int fib(int a)
{
if (a==0)
return 0;
if (a==1)
return 1;
else
return(fib(a-1) + fib(a-2)); //calling function itself
}

salida

    Enter the number of values to be printed from the fibonacci series: 10
0 1 1 2 3 5 8 13 21 34

funcionamiento en seco del programa

    i	Output
0 0
1 1
2 return ( fib(2-1) + fib(2-2))
return ( fib(1) + fib(0))
return ( 1 + 0) = 1 therefore, fib(2) = 1
3 return ( fib(3-1) + fib(3-2))
return ( fib(2) + fib(1))
return(1 + 1) = 2 therefore, fib(3) = 2
4 return ( fib(4-1) + fib(4-2))
return( fib(3) + fib(2))
return(2 + 1) = 3 and so on... till i = 9.

Ventajas del uso de la recursividad

  1. recursividad es más elegante y requiere un menor número de variables que hace que el programa short y limpio.
  2. recursividad se pueden hacer para reemplazar los códigos de anidación complejas ya que no tenemos que llamar al programa, una y otra vez, a do la misma tarea que se llama a sí misma.

Desventajas de usar recursividad

  1. Es relativamente difícil pensar en la lógica de una función recursiva.
  2. También a veces se vuelve difícil de depurar un código recursivo.


Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *