ESTRUCTURA DE DATOS

Unidad 2. Recursividad
2.1. Definicin

La recursividad o recursin es una tcnica de programacin, que consiste en el llamado directo o

indirecto a s mismo de un mtodo o funcin en un programa, generando con esto un ciclo.

Esta tcnica es muy utilizada para resolver problemas complejos que no pueden ser resueltos tan
fcilmente con estructuras de repeticin.

2.2. Procedimientos recursivos

La recursividad a simple vista parece un ciclo interminable, sin embargo, la clave para evitar esto, es
que en la definicin del problema exista un caso base, esto es, una solucin directa.

En una funcin pueden existir varias llamadas de tipo recursivo, pero de cualquier manera lo que
hace efectiva la recursin, son estas dos caractersticas: cambio en los valores de los parmetros
de la llamada recursiva y una solucin directa al problema.

A diferencia de una estructura iterativa, la cual establece una condicin para efectuarse el ciclo, en
la funcin recursiva, se establece una condicin para la llamada recursiva y no existe como tal una
estructura de repeticin, pero si se lleva a cabo un ciclo para solucionar el problema.

2.3. Ejemplos de casos recursivos

Para entender cmo funciona la recursin, veamos a continuacin un caso clsico que ilustra tanto
una solucin recursiva como una solucin iterativa

Ejemplo: la funcin Factorial

El factorial de un nmero n!, se puede definir como:

Por definicin si n=0

n! = 1;
Para n>0

n! =n * (n-1) * (n-2) *.* 1;

Ejemplos:

5! = 5 * 4 * 3 * 2 * 1 = 120
0! = 1
7! = 7 * 6 * 5 * 4 * 3 * 2 * 1 = 5040

esta definicin es lineal y explcita, y nos lleva a pensar en un ciclo para solucionar el factorial de un
nmero n. Solucin iterativa.

M.C. Miriam Snchez Santamaria

M.C. Luis Adrin Garca Garca
 ESTRUCTURA DE DATOS

Sin embargo, tambin se puede definir el factorial n! como:

Para n=0
n! = 1;

Para n>0
n! =n * (n-1)!

Ejemplos:

5! = 5 * 4!
0! = 1
7! = 7 * 6!

esta definicin es recursiva, y para solucionar el factorial de n, debe resolverse primero el factorial
de n-1, esto es;

5! = 5 * 4!
4! = 4 * 3!
3! = 3 * 2!
2! = 2 * 1!
1! = 1 * 0!
0! = 1

Esto nos conduce a un ciclo, hasta llegar a una solucin directa cuando por definicin el factorial 0!
es igual a 1 y una vez resuelto este caso base es posible solucionar en regresin los valores
factoriales pendientes, como se muestra a continuacin:

5! = 5 * 4!
4! = 4 * 3!
3! = 3 * 2!
2! = 2 * 1!
1! = 1 * 0!
0! = 1

5! = 5 * 4!

4! = 4 * 3!
3! = 3 * 2!
2! = 2 * 1!
1! = 1 * 0! = 1*1= 1

5! = 5 * 4!
4! = 4 * 3!
3! = 3 * 2!
2! = 2 * 1! = 2 * 1= 2

5! = 5 * 4!
4! = 4 * 3!
3! = 3 * 2! = 3 * 2 = 6

5! = 5 * 4!

4! = 4 * 3! = 4 * 6 = 24

5! = 5 * 4! = 5 *24 = 120

M.C. Miriam Snchez Santamaria

M.C. Luis Adrin Garca Garca
 ESTRUCTURA DE DATOS

Los algoritmos iterativo y recursivo se muestran a continuacin:

int factorial_iterativo(int n)
{
int res=1;
if (n==0)
return 1;
else
{
for ( int x=n, x>1;x--)
res*=x;
return res;
}
}

int factorial_recursivo (int n)

{
if (n==0)
return 1;
else
return(n*factorial_recursivo(n-1));
}

Veamos el siguiente ejemplo:

// llamada inicial al mtodo o funcin

f = factorial_recursivo(5);

para la llamada factorial_recursivo(5)

n=5

if (n==0) // FALSO
return 1;
else
return (5*factorial_recursivo (4)); //LLAMADA RECURSIVA

------------------------------------------------------------------------------------------
para la llamada factorial_recursivo(4)
n=4

if (n==0) // FALSO
return 1;
else
return (4*factorial_recursivo (3)); //LLAMADA RECURSIVA

-----------------------------------------------------------------------------------------------

M.C. Miriam Snchez Santamaria

M.C. Luis Adrin Garca Garca
 ESTRUCTURA DE DATOS

para la llamada factorial_recursivo(3)

n=3

if (n==0) // FALSO
return 1;
else
return (3*factorial_recursivo (2)); //LLAMADA RECURSIVA

------------------------------------------------------------------------------------------------
para la llamada factorial_recursivo(2)
n=2

if (n==0) // FALSO
return 1;
else
return (2*factorial_recursivo (1)); // LLAMADA RECURSIVA

-------------------------------------------------------------------------------------------------
para la llamada factorial_recursivo(1)
n=1

if (n==0) // FALSO
return 1;
else
return (1*factorial_recursivo (0)); //LLAMADA RECURSIVA

--------------------------------------------------------------------------------------------------
para la llamada factorial_recursivo(0)
n=0

if (n==0) // VERDADERO
return 1; // SE RETORNA EL VALOR 1, DONDE FUE INVOCADO

Veamos como se resuelve la funcin

para la llamada factorial_recursivo(0)

n=0
if (n==0) // VERDADERO
return 1; // SE RETORNA EL VALOR 1
----------------------------------------------------------------------------
para la llamada factorial_recursivo(1)
n=1
return (1*1); // Se realiza la operacin con el valor
// recibido 1
// y RETORNA EL RESULTADO VALOR 1

M.C. Miriam Snchez Santamaria

M.C. Luis Adrin Garca Garca
 ESTRUCTURA DE DATOS

-----------------------------------------------------------------------------------
para la llamada factorial_recursivo(2)
n=2
return (2*1);
// Se realiza la operacin con el valor
// recibido 1
// y RETORNA EL RESULTADO VALOR 2
_______________________________________________________

para la llamada factorial_recursivo(3)

n=3
return (3*2); // Se realiza la operacin con el valor
// recibido 2
// y RETORNA EL RESULTADO VALOR 6
-------------------------------------------------------------------------------------------

para la llamada factorial_recursivo(4)

n=4
return (4*6); // Se realiza la operacin con el valor
// recibido 6
// y RETORNA EL RESULTADO VALOR 24

------------------------------------------------------------------------------------------

para la llamada factorial_recursivo(5)

n=5
return (5*24); // Se realiza la operacin con el valor
// recibido 24
// y RETORNA EL RESULTADO VALOR 120
------------------------------------------------------------------------------------------
Llamada inicial a la funcin
f = factorial_recursivo(5); // recibe el valor de retorno

f = 120

Serie Fibonacci

La serie fibonacci de nmeros, consiste en calcular el siguiente nmero de la serie con la

suma de los dos anteriores, la serie se inicia con los valores 0 y 1.

0 1 1 2 3 5 8 13 21 34

Si deseamos disear un mtodo para calcular el valor que corresponde a cierto nmero de la serie,
podramos definir el problema de la siguiente manera:

Fibonacci (n)

Para n=1 es decir, el primer elemento de la serie

Fibonacci (n) = 0 por definicin

Para n= 2 es decir, el segundo elemento de la serie

Fibonacci (n) = 1 por defincin

M.C. Miriam Snchez Santamaria

M.C. Luis Adrin Garca Garca
 ESTRUCTURA DE DATOS

Para n>2

Fibonacci (n) = Fibonacci (n-2) + Fibonacci (n-1)

Es decir, el nmero n de la serie, es la suma de los dos nmeros Fibonacci anteriores a n, es decir,
Fibonacci (n-2) y Fibonacci (n-1)

De esta manera, el nmero 5 de la serie fibonacci quedara determinado como sigue:

Fibonacci (5) = Fibonacci (3) + Fibonacci (4)

Para poder determinar cul es el valor del elemento 5 de la serie, se debe conocer cules son los
elementos 3 y 4 de la serie, lo que nos lleva a tener que resolver primero esta incgnita para dar
solucin a la primera.

Fibonacci (4) = Fibonacci (3) + Fibonacci (2) solucin recursiva

Fibonacci (3) = Fibonacci (2) + Fibonacci (1) solucin recursiva
Fibonacci (2) = 1 solucin directa, caso base
Fibonacci (1) = 0 solucin directa, caso base

int fibonacci (n)

{
if (n==1)
return (0);
if (n==2)
return (1);
return (fibonacci (n-2) + fibonacci (n-1));
}

El diseo de mtodos recursivos, puede parecer difcil en un principio, pero con la prctica, el
programador puede volverse un experto y utilizar esta poderosa herramienta de programacin.

Ahora bien, por otro lado, tambin es importante considerar el diseo interno del lenguaje de
programacin que permite la recursin, ya que deben considerarse los controles necesarios en las
llamadas a las funciones y la manipulacin de memoria para el almacenamiento de variables y sus
valores. Una parte fundamental, en el diseo del lenguaje de programacin es, la utilizacin de las
estructuras de datos, para lograr la recursin, se utilizan las pilas, que son ideales ya que por su
caracterstica de acceso a los datos en orden inverso al que se almacenaron, permite hacer el
regreso a los llamados de funciones que se establecen en la recursin.

M.C. Miriam Snchez Santamaria

M.C. Luis Adrin Garca Garca