Reporte Recursividad

Descargar como pdf o txt
Descargar como pdf o txt
Está en la página 1de 8

Universidad Autónoma de Nuevo León

Facultad de Ingeniería Mecánica y Eléctrica

Estructura de datos
Investigacion de Recursividad y ejemplos

Ing. Selene Guadalupe Pinal


Grupo. 003
Equipo 2
Matricula Nombre Carrera
1745628 César Alejandro Hernández Puente IAS
1945635 Jesús Miguel Hernández Estevane IAS
1977531 Cristofer Alejandro Esquivel Rivera IAS
1995438 Juan Carlos Treviño Lopez ITS
1995623 Daniela Cosette Gonzalez Briones ITS
2011232 Ricardo Acevedo Rodríguez IAS
2082365 René Torres Cruz IAS

1 De octubre de 2022, San Nicolás de los Garza.


Índice
Índice ............................................................................................................................................... 2
Recursividad ........................................................................................................................................ 3
1 Introducción ............................................................................................................................ 3
2. Desarrollo ................................................................................................................................ 4
2.1 Recursividad .................................................................................................................... 4
2.2 Tipos de recursion: .......................................................................................................... 4
2.3 Cuando usar el método de recursividad ......................................................................... 4
2.4 La pila de recursión ......................................................................................................... 5
3. Ejemplos .................................................................................................................................. 6
4. Conclusión ............................................................................................................................... 8
1 Introducción
El área de la programación es muy amplia y con muchos detalles. Los
programadores necesitan ser capaces de resolver todos los problemas que se les
presente a través del computador aun cuando en el lenguaje que utilizan no haya
una manera directa de resolver los problemas.
En el lenguaje de programación C, así como en otros lenguajes de programación,
se puede aplicar una técnica que se le dio el nombre de recursividad por su
funcionalidad. Esta técnica es utilizada en la programación estructurada para
resolver problemas que tengan que ver con la factorial de un número, o juegos de
lógica.
Las asignaciones de memoria pueden ser dinámicas o estáticas y hay diferencias
entre estas dos y se pueden aplicar las dos en un programa cualquiera.
Al momento de ver este tema haremos un pequeño recordatorio en ciertos
conceptos importantes, pero ya antes visto como:
- Función: En la informática, más precisamente en los lenguajes de
programación, una función es un tipo de subalgoritmo que describe una
secuencia de órdenes. Estas órdenes cumplen con una tarea específica de
una aplicación más grande.

- Algoritmos Iterativos: Los algoritmos iterativos son algoritmos que se


caracterizan por ejecutarse mediante ciclos. Estos algoritmos son muy útiles
al momento de realizar tareas repetitivas (como recorrer un arreglo de datos).
Casi todos los lenguajes de programación modernos tienen palabras
reservadas para la realización de iteraciones.

- Pila: es una lista ordenada o estructura de datos que permite almacenar y


recuperar datos, siendo el modo de acceso a sus elementos de tipo LIFO (del
inglés Last In, First Out, «último en entrar, primero en salir»).

Teniendo presente esto y habiendo repasado esta información podemos continuar


con el tema de recursividad.
2. Desarrollo

Es una técnica de programación que se utiliza en comúnmente en la programación


dinámica, para mejorar el proceso de resolución de problemas matemáticos y así
tener una codificación compacta y elegante.
Para comprender mejor la recursividad hay que entender como funciona se usan
los registros de activación en una Pila de ejecución del programa para recordar la
dirección de retorno del procedimiento y almacenar sus variables locales.
La recursividad va ligada a la repetición y podemos decir que son recursivos todos
los algoritmos que estes encapsulados dentro de una función y son llamados
desde ella misma una y otra vez, contraponiéndose a los algoritmos iterativos, que
usan bucles while, do-while, for, etc.

Recursión simple
 Aquella en cuya definición solo aparece una llamada recursiva.
 Se puede transformar con facilidad en algoritmo iterativos

Recursión Múltiple
 Se da cuando hay mas de una llamada de si misma dentro del cuerpo de la
función.
 Resulta ser más difícil de hacer de forma iterativa.

é
Podemos utilizar recursividad para reemplazar cualquier tipo de bucle. A pesar de
ello en el mundo laboral no se utiliza demasiado, debido a que un error puede ser
trágico en la memoria, así como tener una lista con millones de datos, puede
hacer que utilice mucha memoria. Aun así, la gran mayoría de las veces,
utilizamos recursividad para algoritmos de búsqueda u ordenación.
ó
La memoria de un ordenador se divide en 4 segmentos
 Segmento de código: almacena las instrucciones del programa en código
máquina.
 Segmento de datos: almacena las variables estáticas o constantes.
 Montículo: almacena las variables dinámicas
 Pila del programa: Parte destinada a las variables locales y parámetros de
la función que se está ejecutando.

Cuando llamamos a una función (o método) el proceso es el siguiente


 Se reserva espacio en la pila para los parámetros de la función y sus
variables locales.
 Se guarda en la pila la dirección de la línea del código desde donde se ha
llamado al método.
 Se almacenan los parámetros de la función y sus valores en la pila.
 Finalmente se libera la memora asignada en la pila cuando la función
termina y se vuelve a la llamada de código original.
En cambio, cuando la función es recursiva:
 Cada llamada genera una nueva llamada a una función con los
correspondientes objetos locales.
 Volviéndose a ejecutar completamente, hasta la llamada a si misma. Donde
vuelve a crear en la pila los nuevos parámetros y variables locales. Tantos
como llamadas recursivas generemos.
Al terminar, se van liberando la memoria en la pila, empezando desde la última
función creada hasta la primera, la cual será la última en liberarse.
3. Ejemplos

 El ejemplo clásico de recursividad es el cálculo de la factorial de un número. La factorial de


un número N es el producto de todos los números enteros que se encuentren entre 1 y N.
Por ejemplo, la factorial de 3 es 1 × 2 × 3, es decir, es 6.

El siguiente programa muestra una forma recursiva de calcular la factorial de un número.


Para propósitos de comparación, también se incluye un equivalente no recursivo
(iterativo).

 Otro ejemplo es el de mostrar las cifras de un entero

Sea un entero de valor 45671. Se trata de mostrar sucesivamente los caracteres 4, 5, 6, 7,


1, y no el valor del entero. Para ello, mientras el resultado sea superior a 0, se hace el
módulo 10 lo que da la última cifra, se divide entre 10 y se vuelve a comenzar.
 En este ejemplo vamos a hacer que el usuario escriba una frase y nosotros la repetimos un
determinado número de veces.
Evidentemente será mucho más fácil resolver el problema utilizando un bucle, pero aquí
se trata de ver cómo se puede resolver también mediante una función recursiva.
4. Conclusión

Nosotros dimos a la conclusión de que este tema de la recursividad es un concepto


fundamental en matemáticas y en computación, es una alternativa diferente para
implementar estructuras de repetición (ciclos).

Se puede usar en toda situación, en la cual la solución pueda ser expresada como
una secuencia de movimientos, pasos o transformaciones gobernadas por un
conjunto de reglas además como se pudo notar la recursividad también se puede
trabajar mediante pilas, así como también se mencionó algunos ejemplos para
utilizar la recursividad.

En resumen, la recursividad consume mucha memoria y tiempo de ejecución,


además, puede dar lugar a la redundancia (resolver el mismo problema más de una
vez).

También podría gustarte