Bom dia, eu não estou entendendo o ponto de parada deste método.
public class OtherClass {
public int recursiveM(int num){
if(num==0){
return 1;
}
return num * recursiveM(num-1);
//5*recursiveM(4);
//4*recursiveM(3);
//3*recursiveM(2);
//2*recursiveM(1);
//1*recursiveM(0);
//return 1;
}
}
Alguém poderia me ajudar? Não consigo entender por que este método funciona direitinho.
Quando o parâmetro num for igual à zero, ele vai retornar 1, esse é o ponto de parada.
É só fazer um teste de mesa:
A chamada ao recursiveM(5); vai fazer o seguinte:
5 não é zero, então vai retornar 5 * recursiveM(4);
|
| A chamada do recursiveM(4), vai fazer o seguinte:
| 4 não é zero, então vai retornar 4 * recursiveM(3);
| |
| | A chamada do recursiveM(3), vai fazer o seguinte:
| | 3 não é zero, então vai retornar 3 * recursiveM(2);
| | |
| | | A chamada do recursiveM(2), vai fazer o seguinte:
| | | 2 não é zero, então vai retornar 2 * recursiveM(1);
| | | |
| | | | A chamada do recursiveM(1), vai fazer o seguinte:
| | | | 1 não é zero, então vai retornar 1 * recursiveM(0);
| | | | |
| | | | | A chamada do recursiveM(0), vai fazer o seguinte:
| | | | | 0 é zero, então vai retornar 1;
| | | | |
| | | | Então chamada do recursiveM(1), vai retornar 1*1 que é 1.
| | | |
| | | Então chamada do recursiveM(2), vai retornar 2*1 que é 2.
| | |
| | Então chamada do recursiveM(3), vai retornar 3*2 que é 6.
| |
| Então chamada do recursiveM(4), vai retornar 4*6 que é 24.
|
Então chamada do recursiveM(5), vai retornar 5*24 que é 120.
Cara, como estudante, eu ainda tenho um pouco de medo em usar recursão.
Pode me explicar uma coisa?
Pelo que sei, o método recursivo monta uma pilha de instruções, correto?
Digo, para conseguir encontrar o fatorial de 4 (por exemplo), é necessário descobrir o 3!, para descobrir o 3! é necessário descobrir o 2! e assim por diante. Tendo isso em conta, nosso ponto de parada é, por exemplo, n = 1. Nesse ponto de parada, estamos informando ao método, qual o fatorial de 1, uma vez que o if (n == 1) return 1, certo? Então ao atingir este ponto, é como se o método acessasse a pilha de instruções “de baixo para cima”, calculando os fatoriais que restaram. É isso?
Mais ou menos isso, após o return, a chamada do método atual é desempilhada, voltando a execução para o método anterior que o chamou.
Então no inicio ele vai empilhar as seguintes chamadas: recursiveM(5) --> recursiveM(4) --> recursiveM(3) --> recursiveM(2) --> recursiveM(1) --> recursiveM(0)
Lá no recursiveM(0) ele fará o return 1 e aí vai retornando a chamada para o recursiveM(1), recursiveM(2), recursiveM(3), recursiveM(4) e finalmente voltar para o método inicial recursiveM(5).
Essa volta, ou o “de baixo pra cima” como você citou, se chama backtracking.
Bom, não sei exatamente qual é meu medo, rs. Mas sempre que há algum exercício como este, fibonacci, entre outros, eu prefiro utilizar laços e não métodos recursivos. Sinto que caso use método recursivo, algo dará errado. Talvez por falta de prática, rs.
Quanto a minha dúvida: agora tudo ficou mais esclarecido.
Obrigado!