Este documento presenta dos programas recursivos escritos en C++. El primer programa calcula el factorial de un número ingresado por el usuario utilizando recursividad. El segundo programa calcula el número en la secuencia de Fibonacci correspondiente a una posición dada también mediante recursividad. Ambos programas explican su lógica y concluyen explicando el uso de la recursividad como técnica de programación.

1. “2013; Año de Belisario Domínguez”
“2013; Año por una Cultura de Conservación Ambiental”
INSTITUTO TECNOLÓGICO SUPERIOR DE FELIPE CARRILLO PUERTO
ESTRUCTURA DE DATOS
DOCENTE:
MTI.NIELS HENRYK ARADA CUEVAS
TEMA:
INFORME TECNICO
ALUMNO:
Eliu Osseas Puc Puc
AULA: J4
CARRERA: INGENIERÍA EN SISTEMAS COMPUTACIONALES

2. “2013; Año de Belisario Domínguez”
“2013; Año por una Cultura de Conservación Ambiental”
Contenido
INSTITUTO TECNOLÓGICO SUPERIOR DE FELIPE CARRILLO PUERTO ............................................................ 1
Introducción: ................................................................................................................................................. 3
Explicación del programa: ......................................................................................................................... 4
CONCLUSION DEL PROGRAMA .................................................................................................................. 6
Explicación del programa 2 (Fibonacci) ..................................................................................................... 6
Conclusión del programa: ......................................................................................................................... 8
Conclusión general: ............................................................................................................................... 8

3. “2013; Año de Belisario Domínguez”
“2013; Año por una Cultura de Conservación Ambiental”
Introducción:
En esta unidad estaremos estudiando nuevos temas primeramente veremos lo que es la recursividad, que tiene una definición muy corta nos dice que es una función que se llama así misma. Bueno esto quiere decir que cuando por ejemplo tengamos un problema en la cual el programa no pueda obtener un resultado de manera directa sino solo sabiendo cual es el resultado de la siguiente, entonces con esto podemos obtener el resultado sabiendo el siente y así sucesivamente hasta llegar a una base lo que hará que calcule la de la anterior y así sucesivamente hasta llegar al resultado. Entonces la recursividad es necesaria para como herramienta de programación para el manejo de estructura de datos. De igual manera nos dice que al momento de utilizar recursividad no se debe de utilizar ciclos, entonces lo puedo aplicar cuando estoy trabajando con secuencias.

4. “2013; Año de Belisario Domínguez”
“2013; Año por una Cultura de Conservación Ambiental”
Programa 1: Factorial de un número utilizando recursividad.
Explicación del programa:
En este programa nos permitirá calcular la factorial de cualquier número, bueno como siempre empezaremos con llamar a nuestras librerías ya que sin una de ellas el programa no funcionara correctamente. Seguidamente para este programa comenzaremos declarando nuestras funciones en este caso como calcularemos la factorial de un numero “n” entonces declararemos int factorial (int n); esto quiere decir que la función factorial será de tipo entero porque ingresaremos números enteros y la
“n” que de igual manera será de tipo entero una vez declarada nuestra función ahora dentro de nuestra función principal que es el main, le diremos al usuario que ingrese un numero bueno con el cout<<"Ingrese un numero:"n le estamos diciendo al programa que se ingresara un valor “n” osea cualquier numero ahora bien con el cin>>n; estamos diciendo que se imprimirá lo que contenga “n”. Ahora bien aremos la llamada de la función factorial, con este código cout<<"El resultado es :"<<factorial(n); con esto le estamos diciendo al programa que se imprimirá la factorial que contenga (n), y le diremos que nos retornara valor cero. Ahora bien con int factorial(int n) le estamos diciendo que cuando el valor de n=0 nos retornara el valor 1 y se imprimirá la factorial de dicho numero pero de no cumplirse esta condición entonces diremos return(n*factorial(n-1)); esto significa que como el programa no sabe cuál es la factorial del numero ingresado pero sabe que la factorial de ese número es la factorial de del numero menos 1 pero tampoco sabe cuál es el valor del nuevo número y entonces toda esta información lo guarda en memoria. Como no lo sabe entonces cuando el valor de n sea igual a 1 entonces sabes que es la factorial de 1 ha llegado a la base entonces teniendo ese valor ahora puede calcular la factorial de los números anteriores y hasta llegar al valor de n que es el número que ingresaron nos imprimirá la factorial de dicho numero

5. “2013; Año de Belisario Domínguez”
“2013; Año por una Cultura de Conservación Ambiental”
#include <iostream> using namespace std;
//Declaraciones de las funciones int factorial(int n); int main(int argc, char** argv) { int n;
//Pedir datos cout<<"Ingrese un numero:"; cin>>n;
//Llamada de la funcion factorial cout<<"El resultado es :"<<factorial(n);
return (0);
}
//funcion factorial int factorial(int n){
if(n==0)
return 1;
else
return(n*factorial(n-1));
}

6. “2013; Año de Belisario Domínguez”
“2013; Año por una Cultura de Conservación Ambiental”
CONCLUSION DEL PROGRAMA.
En este primer programa aprendimos el uso de la recursividad en la programación sabemos que cuando hablamos de recursividad es una técnica de programación que utilizamos para hacer una llamada a una función desde una misma función. En este primer programa se aplicó la recursividad como tal por que calculamos la factorial de un numero en este caso como habíamos mencionado anteriormente para calcular la factorial de un número no se puede calcular de manera directa pero el programa sabe que por ejemplo queremos calcular la factorial de 5 el programa no tiene el resultado de la factorial de dicho numero pero sabe que la factorial de 5 se puede calcular teniendo la factorial de 4 pero de igual manera no tiene la factorial de dicho numero entonces va guardando la información en memoria entonces sabe que factorial de 4 se puede calcular teniendo la factorial de 3 igual no lo sabe pero lo puede calcular teniendo factorial de 2 tampoco lo tiene pero ahora si sabe que la factorial de 1 es igual a 1 entonces ha llegado a una base ahora con este resultado aplica la regla recursiva sacando la factorial de 2 de 3 de 4 y así hasta llegar al resultado entonces imprimirá el valor de la factorial de dicho número. Cabe mencionar que la factorial de 5 es 5*4*3*2*1, es así como se fue calculando aplicando la recursividad que se encontró la factorial de dicho número.
Explicación del programa 2 (Fibonacci)
En este caso estudiaremos lo que viene siendo la regla de Fibonacci que en teoría nos dice que es una función matemática de secuencia numérica que sigue una regla de sucesión de ciertos números de donde la regla de Fibonacci lo que hace es tener un numero como base y buscar la posición de dicho número, el método que emplea es obtener el siguiente número con la suma de los dos números anteriores, el cual el método realizamos su programación en este lenguaje de c utilizando el método de recursividad. Cabe mencionar que las secuencias no siempre serán como habíamos mencionado la suma de los dos números anteriores será la siguiente sino dependiendo de la secuencia que se le dé entonces será como se calculara la secuencia y su posición de cualquier número.

7. “2013; Año de Belisario Domínguez”
“2013; Año por una Cultura de Conservación Ambiental”
#include <iostream> using namespace std;
int fibonacci (int f); int main(int argc, char *argv[]) {
int f;
cout<< "Inserta posicionn"; cin>>f; cout<<fibonacci (f); return 0;
}
int fibonacci (int f){ if ((f==1)||(f==2)) return (1); else return ( fibonacci (f-2)+fibonacci (f-1));
}

8. “2013; Año de Belisario Domínguez”
“2013; Año por una Cultura de Conservación Ambiental”
Conclusión del programa:
Bueno en este programa lo que realizamos es utilizar la recursividad nuevamente para aplicar la solución de una regla antes mencionada “Fibonacci”, en la cual lo que realizamos es declarar en la primera parte debajo de la librería la función entera que lleva por nombre Fibonacci la cual que va tener como variable a f que representara la posición del número que se ingresara y que va imprimir el valor de número que se encuentra en esa posición. En la función principal declaramos la variable de posición f luego imprimimos un mensaje para pedir la posición del número el cual se va a guardar en la variable, después imprimimos la función Fibonacci, por el momento no hemos realizado la función Fibonacci por lo tanto no puede haber un valor para imprimir, entonces afuera de la función principal main, comenzamos a usar la función Fibonacci el cual declaramos un if que los que evalúa es que si f es igual a 1 tal que f sea igual que 2 entonces regresa 1, ya que no se puede obtener el numero si no tenemos los dos anteriores, de lo contrario el valor de la función Fibonacci a imprimir va ser regresar a la función Fibonacci con variable f restado 2 que obtener el primer número con la suma de la misma función con f restado 1 que va obtener el segundo valor de número a sumar para obtener la posición.
Conclusión general:
Resumiendo todo lo visto en esta unida en conclusión general trabajamos con un método diferente a la unidad anterior en donde ahora ya no trabajamos con ciclos ni con arreglos ahora trabajos con recursividad que si bien sustituye a los ciclos se trabaja de manera diferente. En donde comprendimos la lógica de funcionamiento de la recursividad en los dos programas que realizamos la primera de la factorial de un numero después pasar la regla de Fibonacci en un lenguaje de programación, todo lo que hemos visto hasta ahora va ser de gran utilidad a lo largo de nuestra formación profesional ya que a lo largo de la carrera estaremos trabajando con nuevos lenguajes de programación donde la lógica de programación va ser la misma solo con la modificación de los comandos que se van a estar utilizando, prácticamente la recursividad es una manera de manejar las secuencias de datos.