UNIVERSIDAD DE ORIENTE

NÚCLEO DE MONAGAS.
INGENIERÍA DE SISTEMAS
MATURÍN ESTADO MONAGAS
VENEZUELA

Recursivi
dad en la
programa
ción

Profesor: Estudiantes:
Frank Diaz Aarón Romero
V-26.532.038

Maturín junio del 2021

 Índice

Contenido
La recursividad...........................................................................................................4
Ejemplo de un programa...........................................................................................4
Recursividad directa vs indirecta...............................................................................6
Propiedades de las definiciones o algoritmos recursivos:........................................6
Programación Recursiva...........................................................................................6
Algoritmos recursivos................................................................................................7
Las claves para construir un subprograma recurrente son:......................................8
¿Por qué escribir programas recursivos?..................................................................9
Comparación entre funciones recursivas e iterativas................................................9
Dividir para vencer...................................................................................................10
Conclusión...............................................................................................................11
Bibliografía...............................................................................................................12
 Introducción

En la programación hay varias formas de resolver un problema , ya que eso

depende de la imaginación del programador o como él vea la respuesta ,teniendo
a su vez diferentes forma de hacerlo para que puedan ser los más óptimos posible
en sus programas y lo más ligeros posible para la maquina a su vez , además que
los programadores deben ser capaces de resolver problemas que no se
solucionen de manera directa, para estos tipos de problema se necesitan del uso
de la recursividad la cual es una técnica que se le dio ese nombre por su función,
ya que se basan en llamarse varias veces para solucionar problemas complejos y
que se necesiten de mucha lógica, siendo fundamental en matemáticas y en
computación.
 Desarrollo

La recursividad
La recursividad es una técnica muy empleada en la programación informática y
consiste en que una función se llame a sí misma. El ejemplo clásico es la función
que calcula la factorial de un número. Una factorial consiste en multiplicar un
número natural por el número anterior, y este a su vez por el anterior, y así
sucesivamente hasta llegar al número 1. Por ejemplo, la factorial de 8 sería el
resultado de multiplicar 8 por 7, luego por 6 y así sucesivamente hasta llegar a
uno.

Una función recursiva que hiciera este cálculo multiplicaría el número que se le
pasa por el resultado de llamar a la función restando uno a ese número. En
nuestro ejemplo, multiplicar 8 por la factorial de 7. Cuando el número que se le
pasa es un 1, pues devuelve ese 1. Es la llamada "condición de salida", y es
esencial para impedir que la función se esté llamando a sí misma eternamente.

Un ejemplo de la vida real de la recursividad es La Matrushka es una artesanía

tradicional rusa. Es una muñeca de madera que contiene otra muñeca más
pequeña dentro de sí. Esta muñeca, también contiene otra muñeca dentro. Y así,
una dentro de otra.

La recursividad es un concepto fundamental en matemáticas y en computación.

Es una alternativa diferente para implementar estructuras de repetición (ciclos).
Los módulos se hacen llamadas recursivas. 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 no ambiguas. Es una
forma de atajar y solventar problemas. consistiendo en resolver un problema
mediante recursión significa que la solución depende de las soluciones de
pequeñas instancias del mismo problema.2
 Ejemplo de un programa
Un algoritmo recursivo es un algoritmo que expresa la solución de un problema
en términos de una llamada a sí mismo. La llamada a sí mismo se conoce como
llamada recursiva o recurrente.

#include <iostream>

#include <cstdlib>

using namespace std;

int Factorial(int n);

int main(){

int valor;

system("clear");

cout << "Introduzca numero a calcular: ";

cin >> valor;

cout << "\nEl Factorial de " << valor << " es: " << Factorial(valor) << endl;

return 0;

int Factorial(int n){

if (n < 0){

cout << “No existe el factorial de un numero negativo.\n”;

}else if(n < 2){

return 1;

}else

return n * Factorial(n-1);
}

Generalmente, si la primera llamada al subprograma se plantea sobre un

problema de tamaño u orden N, cada nueva ejecución recurrente del mismo se
planteará sobre problemas, de igual naturaleza que el original, pero de un tamaño
menor que N. De esta forma, al ir reduciendo progresivamente la complejidad del
problema a resolver, llegará un momento en que su resolución sea más o menos
trivial (o, al menos, suficientemente manejable como para resolverlo de forma no
recursiva). En esa situación diremos que estamos ante un caso base de la
recursividad.

Recursividad directa vs indirecta.

Cuando un procedimiento incluye una llamada a sí mismo se conoce como

recursión directa. Y Cuando un procedimiento llama a otro procedimiento y éste
causa que el procedimiento original sea invocado, se conoce como recursión
indirecta.

Subrutina_A → Subrutina_A → Subrutina_A

Subrutina_A → Subrutina_B → Subrutina_C → Subrutina_D → Subrutina_A

Propiedades de las definiciones o algoritmos recursivos:

● No debe generar una secuencia infinita de llamadas así mismo, dicho de otro
modo, ha de existir al menos un caso base.

● Una función recursiva f debe definirse en términos que no impliquen a f al menos

en un argumento o grupo de argumentos.

● Debe existir una "salida" de la secuencia de llamadas recursivas.

● Cada llamada recurrente se debería definir sobre un problema de menor

complejidad (algo más fácil de resolver).
 Programación Recursiva
Es mucho más difícil desarrollar una solución recursiva en un lenguaje
determinado para resolver un problema específico cuando no se tiene un
algoritmo. No es solo el programa sino las definiciones originales y los algoritmos
los que deben desarrollarse. En general, cuando encaramos la tarea de escribir un
programa para resolver un problema no hay razón para buscar una solución
recursiva. La mayoría de los problemas pueden resolverse de una manera directa
usando métodos no recursivos. Sin embargo, otros pueden resolverse de una
manera más lógica y elegante mediante la recursión.

Volviendo a examinar la función factorial. El factor es, probablemente, un

ejemplo fundamental de un problema que no debe resolverse de manera
recursiva, dado que su solución iterativa es directa y simple. Sin embargo,
examinaremos los elementos que permiten dar una solución recursiva. Antes que
nada, puede reconocerse un gran número de casos distintos que se deben
resolver. Es decir, ¡quiere escribirse un programa para calcular 0!, 1!, 2! Y así
sucesivamente. Puede identificarse un caso "trivial" para el cual la solución no
recursiva pueda obtenerse en forma directa. ¡Es el caso de 0!, que se define como
1. El siguiente paso es encontrar un método para resolver un caso "complejo" en
términos de uno más "simple", lo cual permite la reducción de un problema
complejo a uno más simple. La transformación del caso complejo al simple
resultaría al final en el caso trivial. Esto significaría que el caso complejo se define,
en lo fundamental, en términos del más simple.

Algoritmos recursivos
Un algoritmo recursivo es un algoritmo que expresa la solución de un problema
en términos de una llamada a sí mismo. La llamada a sí mismo se conoce como
llamada recursiva o recurrente.

Generalmente, si la primera llamada al subprograma se plantea sobre un

problema de tamaño u orden N, cada nueva ejecución recurrente del mismo se
planteará sobre problemas, de igual naturaleza que el original, pero de un tamaño
menor que N. De esta forma, al ir reduciendo progresivamente la complejidad del
problema que resolver, llegará un momento en que su resolución sea más o
menos trivial (o, al menos, suficientemente manejable como para resolverlo de
forma no recursiva). En esa situación diremos que estamos ante un caso base de
la recursividad.

Las claves para construir un subprograma recurrente son:

 Cada llamada recurrente se debería definir sobre un problema de menor

complejidad (algo más fácil de resolver).
 Ha de existir al menos un caso base para evitar que la recurrencia sea
infinita.

Es frecuente que los algoritmos recurrentes sean más ineficientes en tiempo

que los iterativos aunque suelen ser mucho más breves en espacio.

Un método frecuente para simplificar es dividir un problema en problemas

derivados de menor tamaño del mismo tipo. Esto se conoce como dialecting.
Como técnica de programación se denomina divide y vencerás y es pieza
fundamental para el diseño de muchos algoritmos de importancia, así como parte
esencial de la programación dinámica.

Virtualmente todos los lenguajes de programación modernos permiten la

especificación directa de funciones y subrutinas recursivas. Cuando se llama una
función de este tipo, el ordenador, para la mayoría de los lenguajes en casi todas
las arquitecturas basadas en una pila (stack) o en la implementación del lenguaje,
lleva la cuenta de las distintas instancias de la función, en numerosas
arquitecturas mediante el uso de un call stack, aunque no de forma exclusiva. A la
inversa, toda función recursiva puede transformarse en una función iterativa
usando un stack.

La mayoría (aunque no todas) de las funciones y subrutinas que pueden ser

evaluadas por un ordenador, pueden expresarse en términos de una función
recursiva (sin tener que utilizar una iteración pura); a la inversa, cualquier función
recursiva puede expresarse en términos de una iteración pura, dado que la
recursión es, de por sí, también iterativa. Para evaluar una función por medio de la
recursión, tiene que definirse como una función de sí misma (ej. el factor n! = n *
(n - 1)! , donde 0! se define como 1). Resulta evidente que no todas las
evaluaciones de funciones se prestan a un acercamiento recursivo. Por lo general,
todas las funciones finitas pueden describirse directamente de forma recursiva; las
funciones infinitas (ej. las series de e = 1/1! + 2/2! + 3/3!...) necesitan un criterio
extra para detenerse, ej. el número de iteraciones, o el número de dígitos
significativos, en caso contrario una iteración recursiva resultaría en un bucle
infinito.

A modo de ilustración: Si se encuentra una palabra desconocida en un libro, el

lector puede anotar la página actual en un papel y ponerlo en una pila (hasta
entonces vacía). El lector consulta la palabra en otro artículo y, de nuevo,
descubre otra palabra desconocida, la anota y la pone en la pila, y así
sucesivamente. Llega un momento que el lector lee un artículo que donde todas
las palabras son conocidas. El lector retorna entonces a la última página y
continua la lectura desde ahí, y así hasta que se retira la última nota de la pila
retornando entonces al libro original. Este modus operandi es recursivo.

Algunos lenguajes diseñados para programación lógica y programación

funcional ofrecen la recursión como el único medio de repetición directa disponible
para el programador. Estos lenguajes suelen conseguir que la recursión de cola
sea tan eficiente como la iteración, permitiendo a los programadores expresar
otras estructuras repetitivas (tales como map y for de scheme) en términos de
recursión.

La recursión está profundamente anclada en la teoría de computación, con la

equivalencia teórica de función microrecursiva y máquinas de Turing en la
cimentación de ideas sobre la universalidad del ordenador moderno.

¿Por qué escribir programas recursivos?

• Son mas cercanos a la descripción matemática.
• Generalmente mas fáciles de analizar

• Se adaptan mejor a las estructuras de datos recursivas.

• Los algoritmos recursivos ofrecen soluciones estructuradas, modulares y

elegantemente simples.

Comparación entre funciones recursivas e iterativas

Recursivas Iterativas
• Se basan en una estructura de • las iterativas utilizan una
control estructura de repetición; las recursivas
una estructura de selección.
Incluyen un ciclo de repetición: la iteración utiliza una estructura de
repetición explícita; la recursión lo
hace mediante llamadas de función
repetidas.
Incluyen una prueba de terminación: la iteración termina cuando falla la
condición de continuación del ciclo; la
recursión termina cuando se reconoce
el caso base.
En el caso de la recursión el invocar . Por el contrario la iteración se
repetidamente la misma función, produce dentro de una función.
puede resultar costosa en tiempo de
procesador y espacio de memoria

Dividir para vencer

Muchas veces es posible dividir un problema es subproblemas más pequeños,
generalmente del mismo tamaño, resolver los subproblemas y entonces combinar
sus soluciones para obtener la solución del problema original. Dividir para vencer
es una técnica natural para las estructuras de datos, ya que por definición están
compuestas por piezas. Cuando una estructura de tamaño finito se divide, las
últimas piezas ya no podrán ser divididas.
 Conclusión
Podemos concluir la recursividad es una forma de programar que resulta de
gran importancia para resolver problemas complejos que se solucionen llamando
el mismo programa un número determinado de veces, donde el problema se hace
mas sencillo con cada repetición, esto nos sirve para poder variar el uso de los
ciclos como el for o while, ya que no son necesarios para poder solucionar el
problema , además de que estos se centran en solucionar un problema
descomponiéndolo en partes más sencillas ,estas a su vez serán problemas de
menor nivel de complejidad que el original para luego poder juntarlo todo y
llegando a un problema más simple que se tenía al principio. Por lo tanto, no debe
generar una secuencia infinita de llamadas así mismo, ha de existir al menos un
caso base.
 Bibliografía
https://www.netmentor.es/entrada/Recursividad-programacion
https://www.uv.mx/personal/ocastillo/files/2011/04/Recursividad.pdf
https://es.wikipedia.org/wiki/Recursi%C3%B3n_(ciencias_de_computaci
%C3%B3n)
https://www.libertaddigital.com/internet/que-es-la-recursividad-que-es-la-
recursividad-que-es-la-recursividad-1276366373/
http://webdelprofesor.ula.ve/nucleotrujillo/jalejandro/Prog2/Unidad3.pdf
https://www.utm.mx/~dtorres/cursos/programacionestructurada/Tema5-
Recursividad.pdf
https://www.campusmvp.es/recursos/post/Que-es-la-recursividad-o-
recursion-Un-ejemplo-con-JavaScript.aspx