Recursividad

Recursividad
Rafael Palacios 2005
Programa para calcular el factorial
/* Programa para calcular el factorial */
#include <stdio.h>
int Factorial(int a);
int main(void)
{
int n; /* número del cual calculamos n! */
int fact; /* resultado del factorial */
printf("Dame un número entero: ");
scanf("%d", &n);
fact=Factorial(n);
printf("%d!=%d\n",n,fact);
return 0;
}
Inicio del programa
/* Programa para calcular el factorial */
#include <stdio.h>
int Factorial(int a);
int main(void)
{
int n; /* número del cual calculamos n! */
int fact; /* resultado del factorial */
Memoria
printf("Dame un número entero: ");
scanf("%d", &n);
fact=Factorial(n);
printf("%d!=%d\n",n,fact);
return 0;
}
n
????
fact
????
Después de leer n
/* Programa para calcular el factorial */
#include <stdio.h>
int Factorial(int a);
int main(void)
{
int n; /* número del cual calculamos n! */
int fact; /* resultado del factorial */
Memoria
printf("Dame un número entero: ");
scanf("%d", &n);
fact=Factorial(n);
printf("%d!=%d\n",n,fact);
return 0;
}
n
fact
3
????
Llamada
/* Programa para calcular el factorial */
int Factorial(int a)
#include <stdio.h>
/* Factorial recursivo
int Factorial(int a);
*/
{
int main(void)
{
int res; /* resultado */
int n; /* número del cual calculamos n! */
int fact; /* resultado del factorial */
if (a < 1) {
printf("Dame un número entero: ");
res = 1;
scanf("%d", &n);
} else
{
res = a * Factorial(a-1);
fact=Factorial(n);
printf("%d!=%d\n",n,fact);
}
return res;
return 0;
}
}
Memoria
Stack
copia
n
fact
3
????
a
res
3
????
Entra en else
/* Programa para calcular el factorial */
int Factorial(int a)
#include <stdio.h>
/* Factorial recursivo
int Factorial(int a);
*/
{
int main(void)
{
int res; /* resultado */
int n; /* número del cual calculamos n! */
int fact; /* resultado del factorial */
if (a < 1) {
printf("Dame un número entero: ");
res = 1;
scanf("%d", &n);
} else
{
res = a * Factorial(a-1);
fact=Factorial(n);
printf("%d!=%d\n",n,fact);
}
return res;
return 0;
}
}
Memoria
Stack
n
fact
3
????
a
res
3
????
2
Llamada recursiva
#2
#1
int Factorial(int a)
int Factorial(int a)
/* Factorial recursivo
/* Factorial recursivo
*/
*/
{
{
int res; /* resultado */
int res; /* resultado */
if (a < 1) {
if (a < 1) {
res = 1;
} else
res = 1;
{
} else
res = a * Factorial(a-1);
}
return res;
}
{
res = a * Factorial(a-1);
}
2
return res;
}
Stack
a
res
3
????
Stack
a
res
2
????
Entra en else
#2
#1
int Factorial(int a)
int Factorial(int a)
/* Factorial recursivo
/* Factorial recursivo
*/
*/
{
{
int res; /* resultado */
int res; /* resultado */
if (a < 1) {
if (a < 1) {
res = 1;
} else
res = 1;
{
} else
res = a * Factorial(a-1);
{
res = a * Factorial(a-1);
}
}
return res;
return res;
}
}
Stack
a
res
3
????
Stack
a
res
2
????
1
Llamada recursiva
#3
#2
int Factorial(int a)
int Factorial(int a)
/* Factorial recursivo
/* Factorial recursivo
*/
*/
{
{
int res; /* resultado */
int res; /* resultado */
if (a < 1) {
if (a < 1) {
res = 1;
} else
res = 1;
{
} else
res = a * Factorial(a-1);
}
return res;
}
{
res = a * Factorial(a-1);
}
1
return res;
}
Stack
a
res
2
????
Stack
a
res
1
????
Entra en else
#3
#2
int Factorial(int a)
int Factorial(int a)
/* Factorial recursivo
/* Factorial recursivo
*/
*/
{
{
int res; /* resultado */
int res; /* resultado */
if (a < 1) {
if (a < 1) {
res = 1;
} else
res = 1;
{
} else
res = a * Factorial(a-1);
{
res = a * Factorial(a-1);
}
}
return res;
return res;
}
}
Stack
a
res
2
????
Stack
a
res
1
????
0
Llamada recursiva
#4
#3
int Factorial(int a)
int Factorial(int a)
/* Factorial recursivo
/* Factorial recursivo
*/
*/
{
{
int res; /* resultado */
int res; /* resultado */
if (a < 1) {
if (a < 1) {
res = 1;
} else
res = 1;
{
} else
res = a * Factorial(a-1);
}
return res;
}
{
res = a * Factorial(a-1);
}
0
return res;
}
Stack
a
res
1
????
Stack
a
res
0
????
Entra en if
#4
#3
int Factorial(int a)
int Factorial(int a)
/* Factorial recursivo
/* Factorial recursivo
*/
*/
{
{
int res; /* resultado */
int res; /* resultado */
if (a < 1) {
if (a < 1) {
res = 1;
} else
res = 1;
{
} else
res = a * Factorial(a-1);
{
res = a * Factorial(a-1);
}
}
return res;
return res;
}
}
Stack
a
res
1
????
Stack
a
res
0
????
El resultado es 1
#4
#3
int Factorial(int a)
int Factorial(int a)
/* Factorial recursivo
/* Factorial recursivo
*/
*/
{
{
int res; /* resultado */
int res; /* resultado */
if (a < 1) {
if (a < 1) {
res = 1;
} else
res = 1;
{
} else
res = a * Factorial(a-1);
{
res = a * Factorial(a-1);
}
}
return res;
return res;
}
}
Stack
a
res
1
????
Stack
a
0
res
1
La función retorna 1
#4
#3
int Factorial(int a)
int Factorial(int a)
/* Factorial recursivo
/* Factorial recursivo
*/
*/
{
{
int res; /* resultado */
int res; /* resultado */
if (a < 1) {
if (a < 1) {
res = 1;
} else
res = 1;
{
} else
res = a * Factorial(a-1);
}
return res;
}
{
res = a * Factorial(a-1);
}
1
return res;
}
Stack
a
res
1
????
Stack
a
0
res
1
#4
#3
int Factorial(int a)
int Factorial(int a)
/* Factorial recursivo
/* Factorial recursivo
*/
*/
{
{
int res; /* resultado */
int res; /* resultado */
if (a < 1) {
if (a < 1) {
res = 1;
} else
res = 1;
{
} else
res = a * Factorial(a-1);
}
return res;
}
{
res = a * Factorial(a-1);
}
1
return res;
}
Stack
a
res
1
????
Stack
a
0
res
1
El resultado es 1
#4
#3
int Factorial(int a)
int Factorial(int a)
/* Factorial recursivo
/* Factorial recursivo
*/
*/
{
{
int res; /* resultado */
int res; /* resultado */
if (a < 1) {
if (a < 1) {
res = 1;
} else
res = 1;
{
} else
res = a * Factorial(a-1);
}
return res;
}
{
res = a * Factorial(a-1);
}
1
return res;
}
Stack
Stack
a
1
a
0
res
1
res
1
La función retorna 1
#3
#2
int Factorial(int a)
int Factorial(int a)
/* Factorial recursivo
/* Factorial recursivo
*/
*/
{
{
int res; /* resultado */
int res; /* resultado */
if (a < 1) {
if (a < 1) {
res = 1;
} else
res = 1;
{
} else
res = a * Factorial(a-1);
}
return res;
}
{
res = a * Factorial(a-1);
}
1
return res;
}
Stack
a
res
2
????
Stack
a
1
res
1
#3
#2
int Factorial(int a)
int Factorial(int a)
/* Factorial recursivo
/* Factorial recursivo
*/
*/
{
{
int res; /* resultado */
int res; /* resultado */
if (a < 1) {
if (a < 1) {
res = 1;
} else
res = 1;
{
} else
res = a * Factorial(a-1);
}
return res;
}
{
res = a * Factorial(a-1);
}
1
return res;
}
Stack
a
res
2
????
Stack
a
1
res
1
El resultado es 2
#3
#2
int Factorial(int a)
int Factorial(int a)
/* Factorial recursivo
/* Factorial recursivo
*/
*/
{
{
int res; /* resultado */
int res; /* resultado */
if (a < 1) {
if (a < 1) {
res = 1;
} else
res = 1;
{
} else
res = a * Factorial(a-1);
}
return res;
}
{
res = a * Factorial(a-1);
}
1
return res;
}
Stack
Stack
a
2
a
1
res
2
res
1
La función retorna 2
#2
#1
int Factorial(int a)
int Factorial(int a)
/* Factorial recursivo
/* Factorial recursivo
*/
*/
{
{
int res; /* resultado */
int res; /* resultado */
if (a < 1) {
if (a < 1) {
res = 1;
} else
res = 1;
{
} else
res = a * Factorial(a-1);
}
return res;
}
{
res = a * Factorial(a-1);
}
2
return res;
}
Stack
a
res
3
????
Stack
a
2
res
2
#2
#1
int Factorial(int a)
int Factorial(int a)
/* Factorial recursivo
/* Factorial recursivo
*/
*/
{
{
int res; /* resultado */
int res; /* resultado */
if (a < 1) {
if (a < 1) {
res = 1;
} else
res = 1;
{
} else
res = a * Factorial(a-1);
}
return res;
}
{
res = a * Factorial(a-1);
}
2
return res;
}
Stack
a
res
3
????
Stack
a
2
res
2
El resultado es 6
#2
#1
int Factorial(int a)
int Factorial(int a)
/* Factorial recursivo
/* Factorial recursivo
*/
*/
{
{
int res; /* resultado */
int res; /* resultado */
if (a < 1) {
if (a < 1) {
res = 1;
} else
res = 1;
{
} else
res = a * Factorial(a-1);
}
return res;
}
{
res = a * Factorial(a-1);
}
2
return res;
}
Stack
Stack
a
3
a
2
res
6
res
2
La función retorna 6 al main
/* Programa para calcular el factorial */
int Factorial(int a)
#include <stdio.h>
/* Factorial recursivo
int Factorial(int a);
*/
{
int main(void)
int res; /* resultado */
{
int n; /* número del cual calculamos n! */
if (a < 1) {
int fact; /* resultado del factorial */
res = 1;
printf("Dame un número entero: ");
} else
scanf("%d", &n);
fact=Factorial(n);
{
res = a * Factorial(a-1);
6
}
return res;
printf("%d!=%d\n",n,fact);
}
return 0;
Memoria
}
Stack
n
fact
3
????
a
3
res
6
/* Programa para calcular el factorial */
int Factorial(int a)
#include <stdio.h>
/* Factorial recursivo
int Factorial(int a);
*/
{
int main(void)
int res; /* resultado */
{
int n; /* número del cual calculamos n! */
if (a < 1) {
int fact; /* resultado del factorial */
res = 1;
printf("Dame un número entero: ");
} else
scanf("%d", &n);
fact=Factorial(n);
{
res = a * Factorial(a-1);
6
}
return res;
printf("%d!=%d\n",n,fact);
}
return 0;
Memoria
}
Stack
n
fact
3
????
a
3
res
6
Se almacena el resultado final
/* Programa para calcular el factorial */
#include <stdio.h>
int Factorial(int a);
int main(void)
{
int n; /* número del cual calculamos n! */
int fact; /* resultado del factorial */
printf("Dame un número entero: ");
scanf("%d", &n);
fact=Factorial(n);
6
printf("%d!=%d\n",n,fact);
return 0;
Memoria
}
n
3
fact
6
Resumen del factorial de 3
/* Programa para calcular el factorial */
#include <stdio.h>
int Factorial(int a);
int main(void)
{
int n; /* número del cual calculamos n! */
int fact; /* resultado del factorial */
printf("Dame un número entero: ");
scanf("%d", &n);
fact=Factorial(n);
printf("%d!=%d\n",n,fact);
return 0;
}
Resumen
/* Programa para calcular el factorial */
#include <stdio.h>
3
int Factorial(int a);
int main(void)
{
int n; /* número del cual calculamos n! */
int Factorial(int a)
int fact; /* resultado del factorial */
/* Factorial recursivo
printf("Dame un número entero: ");
*/
scanf("%d", &n);
{
int res; /* resultado */
fact=Factorial(n);
printf("%d!=%d\n",n,fact);
if (a < 1) {
res = 1;
return 0;
} else
}
{
res = a * Factorial(a-1);
}
return res;
}
Resumen
/* Programa para calcular el factorial */
#include <stdio.h>
int Factorial(int a);
int main(void)
{
int n; /* número del cual calculamos n! */
2
int Factorial(int a)
int fact; /* resultado del factorial */
/* Factorial recursivo
printf("Dame un número entero: ");
*/
scanf("%d", &n);
{
fact=Factorial(n);
int Factorial(int a)
int res; /* resultado */
/* Factorial recursivo
*/
printf("%d!=%d\n",n,fact);
if (a < 1) {
{
res = 1;
return 0;
} else
}
int res; /* resultado */
{
res = a * Factorial(a-1);
if (a < 1) {
}
res = 1;
return res;
} else
}
{
res = a * Factorial(a-1);
}
return res;
}
Resumen
/* Programa para calcular el factorial */
#include <stdio.h>
int Factorial(int a);
int main(void)
{
int n; /* número del cual calculamos n! */
int Factorial(int a)
int fact; /* resultado del factorial */
/* Factorial recursivo
printf("Dame un número entero: ");
*/
scanf("%d", &n);
{
fact=Factorial(n);
1
int Factorial(int a)
int res; /* resultado */
/* Factorial recursivo
*/
printf("%d!=%d\n",n,fact);
if (a < 1) {
/* Factorial recursivo
int res; /* resultado */
*/
res = 1;
return 0;
} else
}
int Factorial(int a)
{
{
{
res = a * Factorial(a-1);
if (a < 1) {
}
int res; /* resultado */
res = 1;
return res;
} else
}
}
{
if (a < 1) {
res = a * Factorial(a-1);
res = 1;
} else
return res;
{
res = a * Factorial(a-1);
}
}
return res;
}
Resumen
/* Programa para calcular el factorial */
#include <stdio.h>
int Factorial(int a);
int main(void)
{
int n; /* número del cual calculamos n! */
int Factorial(int a)
int fact; /* resultado del factorial */
/* Factorial recursivo
printf("Dame un número entero: ");
*/
scanf("%d", &n);
{
fact=Factorial(n);
int Factorial(int a)
int res; /* resultado */
/* Factorial recursivo
*/
printf("%d!=%d\n",n,fact);
if (a < 1) {
{
int Factorial(int a)
/* Factorial recursivo
int res; /* resultado */
*/
} else {
int Factorial(int a)
{
res = a * Factorial(a-1);
if (a < 1) {
/* Factorial recursivo
int res; /* resultado */
}
res = 1;
*/
return res;
} else {
{
if (a < 1) {
res = a * Factorial(a-1); int res; /* resultado */
res = 1;
}
} else {
return res;
if (a < 1) {
res = a * Factorial(a-1);
}
res = 1;
}
} else {
return res;
res = a * Factorial(a-1);
}
}
res = 1;
return 0;
}
}
0
return res;
}
Resumen
/* Programa para calcular el factorial */
#include <stdio.h>
int Factorial(int a);
int main(void)
{
int n; /* número del cual calculamos n! */
int Factorial(int a)
int fact; /* resultado del factorial */
/* Factorial recursivo
printf("Dame un número entero: ");
*/
scanf("%d", &n);
{
fact=Factorial(n);
int Factorial(int a)
int res; /* resultado */
/* Factorial recursivo
*/
printf("%d!=%d\n",n,fact);
if (a < 1) {
{
int Factorial(int a)
/* Factorial recursivo
int res; /* resultado */
*/
} else {
int Factorial(int a)
{
res = a * Factorial(a-1);
if (a < 1) {
/* Factorial recursivo
int res; /* resultado */
}
res = 1;
*/
return res;
} else {
{
if (a < 1) {
res = a * Factorial(a-1); int res; /* resultado */
res = 1;
}
} else {
return res;
if (a < 1) {
res = a * Factorial(a-1);
}
res = 1;
}
} else {
return res;
res = a * Factorial(a-1);
}
}
res = 1;
return 0;
}
}
1
return res;
}
Resumen
/* Programa para calcular el factorial */
#include <stdio.h>
int Factorial(int a);
int main(void)
{
int n; /* número del cual calculamos n! */
int Factorial(int a)
int fact; /* resultado del factorial */
/* Factorial recursivo
printf("Dame un número entero: ");
*/
scanf("%d", &n);
{
fact=Factorial(n);
int Factorial(int a)
int res; /* resultado */
/* Factorial recursivo
*/
printf("%d!=%d\n",n,fact);
if (a < 1) {
/* Factorial recursivo
int res; /* resultado */
*/
res = 1;
return 0;
} else
}
int Factorial(int a)
{
{
{
res = a * Factorial(a-1);
if (a < 1) {
}
int res; /* resultado */
res = 1;
return res;
} else
}
}
{
if (a < 1) {
res = a * Factorial(a-1);
res = 1;
} else
return res;
{
res = a * Factorial(a-1);
}
}
1
return res;
}
Resumen
/* Programa para calcular el factorial */
#include <stdio.h>
int Factorial(int a);
int main(void)
{
int n; /* número del cual calculamos n! */
int Factorial(int a)
int fact; /* resultado del factorial */
/* Factorial recursivo
printf("Dame un número entero: ");
*/
scanf("%d", &n);
{
fact=Factorial(n);
int Factorial(int a)
int res; /* resultado */
/* Factorial recursivo
*/
printf("%d!=%d\n",n,fact);
if (a < 1) {
{
res = 1;
return 0;
} else
}
int res; /* resultado */
{
res = a * Factorial(a-1);
if (a < 1) {
}
res = 1;
return res;
} else
}
{
res = a * Factorial(a-1);
2
}
return res;
}
Resumen
/* Programa para calcular el factorial */
#include <stdio.h>
int Factorial(int a);
int main(void)
{
int n; /* número del cual calculamos n! */
int Factorial(int a)
int fact; /* resultado del factorial */
/* Factorial recursivo
printf("Dame un número entero: ");
*/
scanf("%d", &n);
{
int res; /* resultado */
fact=Factorial(n);
printf("%d!=%d\n",n,fact);
if (a < 1) {
res = 1;
return 0;
} else
}
{
res = a * Factorial(a-1);
}
6
return res;
}
Resumen
/* Programa para calcular el factorial */
#include <stdio.h>
int Factorial(int a);
int main(void)
{
int n; /* número del cual calculamos n! */
int fact; /* resultado del factorial */
printf("Dame un número entero: ");
scanf("%d", &n);
fact=Factorial(n);
printf("%d!=%d\n",n,fact);
return 0;
}
El resultado es 6