Upload
eliu-osseas-puc-puc
View
23
Download
2
Embed Size (px)
Citation preview
“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
“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
“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.
“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
“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));
}
“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.
“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 posicion\n";
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));
}
“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.