La recursividad es una técnica de programación importante. Se utiliza para realizar una llamada a una función desde la misma función de forma indirecta ó llamarse a si misma de forma directa.

Una de las características de la recursividad es que Para que una definición recursiva esté completamente identificada es necesario tener un caso base que no se calcule utilizando casos anteriores y que la división del problema converja a ese caso base.

Un requisito importante para que sea correcto un algoritmo recursivo es que no genere una secuencia infinita de llamadas así mismo.

Para resolver un problema, el primer paso será la identificación de un algoritmo recursivo. Tendremos que diseñar: casos base, casos generales y la solución en términos de ellos.

Casos base: Son los casos del problema que se resuelve con un segmento de código sin recursividad.

Casos generales: Si el problema es suficientemente complejo, la solución se expresa, de forma recursiva, como la unión de:

La solución de uno o más subproblemas (de igual naturaleza pero menor tamaño).

Un conjunto de pasos adicionales. Estos pasos junto con las soluciones a los subproblemas componen la solución al problema general que queremos resolver.

int factorial (int n){

  if (n==0)   //Caso base

                          return 1;

              else   //Caso general

                           return n*factorial(n-1);

}

// Solución estructurada

int factorial (int n){

  int resultado;

              if (n==0)   //Caso base

               resultado = 1;

               else   //Caso general

                           resultado = n*factorial(n-1);

               return resultado;

}

#include <iostream>

 //====================

int fib(int val){

   if ((val==1)||(val==2))

   return 1;

   else

  return (fib(val-1)+fib(val-2));

}

 //====================

int main (int argc, char * const argv[]) {

  int n;

  std::cout<<"Numero entero:";  

           std::cin>>n;

           std::cout<<"\nEl "<< n <<"-esimo numero fibonacci es: "<< fib(n);

           return 0;

 }

No es necesario definir la secuencia de pasos exacta para resolver el problema.

Los algoritmos recursivos dan elegancia a las soluciones de los problemas.

Es fácil crear una función recursiva que no llegue a devolver nunca un resultado definitivo y no pueda llegar a un punto de finalización del bucle "infinito".

Menor eficiencia.