Este documento describe la recursión y la iteración, y proporciona ejemplos de algoritmos recursivos y iterativos para calcular los números de Catalan. Explica que la recursión permite expresar soluciones simples a ciertos problemas y que los números de Catalan tienen aplicaciones en combinatoria. También incluye código de ejemplo para calcular los números de Catalan de forma recursiva e iterativa.

1. MENU
RECURSIÓN E
ITERATIVIDAD
NUMEROS DE
CATALAN
ALGORITMOS
EJECUCIÓN DE
LOS ALGORITMOS
CONCLUSIONES Y
RECOMENDACION
ES

2. La recursión o recursividad es un concepto amplio, con muchas variantes.
Aparece en numerosas actividades de la vida diaria; por ejemplo en una
fotografía donde se observa otra fotografía.
La recursión es un recurso muy poderoso que permite expresar soluciones
simples y naturales a ciertos tipos de problemas. Es importante considerar
que no todos los problemas son naturalmente recursivos.
Un objeto recursivo es aquel que aparece en la definición de sí mismo, así
como el que se llama a sí mismo.

3. Subprograma P
Directa: el programa o subprograma se llama
-------------------------- directamente a sí mismo.
--------------------------
--------------------------
--------------------------
Llamada a P
Subprograma P Subprograma Q
-------------------------- --------------------------
-------------------------- --------------------------
Indirecta: el -------------------------- --------------------------
-------------------------- --------------------------
subprograma llama a Llamada a Q Llamada a P
otro subprograma, y
éste, en algún
momento, llama
nuevamente a primero.
La iteración es la repetición de una secuencia de instrucciones o eventos por
un cierto numero de veces.

4. Estos números se utilizan en una gran variedad de problemas de
combinatoria. Tienen varias aplicaciones; por ejemplo, determinar el
numero de formas en que un polígono con n+2 lados se puede
descomponer en n triángulos.
En combinatoria los números de catalán forman una secuencia de
números naturales. Obtienen su nombre del matemático belga Eugéne
Charles Catalan
El enésimo numero de catalán se obtiene con la formula
con n>=0
La complejidad computacional de este problema es P ya que puede
ser resuelto en un tiempo polinómico por una maquina Turing
Determinista y que puede ser tratable.

5. El problema de distancia de Los numero s de catalán se puede
realizar con recursión al igual que iterativamente.
1. Inicio
2. Asignar variables: a, c, n, b=1,fac,x=1,factorial=1.
3. Pedir el numero natural la cual será la posición del numero catalán.
4. Insertar el numero.
5. Asignarlo a la variable n.
6. La formula para sacar el numero de catalán es:
Con esto separamos las operaciones en
a= 2n; fac=n+1 y x.
7. Asignamos la primera operación a=2n y ponemos un for para sacar su
factorial ya multiplicado:
a=2*n;
for(c=1;c<=a;c++)
b=c*b; 7.1El resultado de la operación pasa al for y el
resultado de la primera operación se va asignando a
la variable b, lo cual se va multiplicando esta misma
por todos los valores anteriores a n. El resultado se
asigna a la variable b.

6. 8. Lo mismo pasa con la formula fac=n+1
Se hace con otro for :
fac=n+1;
for(c=1;c<=fac;c++)
x=c*x;
Repetir paso 7.1y el resultado se asigna a la variable x.
9. Con la tercera formula se hace lo mismo :
for(c=1;c<=n;c++)
factorial=c*factorial;
Entonces se realiza lo mismo que en el paso 7.1 pero solo se saca el factorial
de n,
el resultado se asigna a la variable factorial.
10. Ya que sacamos el resultado de las tres formulas las juntamos:
catalan= b/(x*factorial)
11. Se despliega el resultado.

7. 1. Pedir el numero
2. Asignarlo a la variable n.
3. Mandar a llamar a la función numeroscatalan.
4. Preguntar si el numero es igual a cero:
Si es verdad numeroscatalan=1(estado basico)
Falso
numeroscatalan=(2*((2*n)-1))/(n+1)*numeroscatalan(n-1).
5. Imprimir numeroscatalan.
6.Fin
Asintóticamente los números de catalán crecen:

8. #include<stdio.h>
#include<conio.h>
main()
{
int catalan,a,c,n,b=1,fac,x=1,factorial=1;
printf("ttttNUMEROS DE CATALANn");
printf(“Numero:");
scanf("%d",&n);
a=2*n;
for(c=1;c<=a;c++)
{
b=c*b;
}

9. fac=n+1;
for(c=1;c<=fac;c++)
{
x=c*x;
}
for(c=1;c<=n;c++)
{
factorial=c*factorial;
}
catalan= b/(x*factorial);
printf("catalan=%d",catalan);
getche();
return 0;
}

10. #include<stdio.h>
#include<conio.h>
double res;
double numeroscatalan(double n);
main(double n)
{
printf("ttNUMEROS DE CATALANn");
printf("Numero: ");
scanf("%lf",&n);
res=numeroscatalan(n);
printf("Catalan:%.0lf",res);
getche();
}

11. double numeroscatalan(double n)
{
if (n==0) //Condicion de parada de la recursión
{
return 1;
}
else
{
return(2*((2*n)-1))/(n+1)*numeroscatalan(n-1);
}
}

12. El código se simplifica.
Cuando utilizamos una estructura de datos recursiva ejemplo: arboles.
Los algoritmos recursivos ofrecen soluciones estructuradas, modulares y
elegantemente simples.
Cuando los métodos usen arreglos largos.
Cuando el método cambie de manera impredecible de campos.
Recomendamos utilizar solo la recursión cuando algún problema no se pueda
realizar de forma iterativa o que sea más fácil realizarlo con recursión. Para
este problema el algoritmo recursivo es mejor.