Recursão em Java

Recursão em Java é o chamado de um método, pelo método, de dentro do método. Esta ação se repete até que uma condição seja atendida. O método deve ser um método em uma classe, além de um na classe principal. A classe principal é a classe que possui o método principal (). O nome do arquivo java é o da classe principal. Um método estático na classe principal ainda pode ser recursivo, mas isso não será abordado neste artigo. Este artigo explica a recursão em Java, com três bons exemplos.

Contando números inteiros de zero

Considere um arquivo Java com duas classes: uma aula privada da seguinte forma:

classe Aclass
Void MTHD (int não)
Sistema.fora.impressão (não); Sistema.fora.imprimir(");
Não = não + 1;
se não < 5)
MTHD (NO);

O método a se chamar é, MTHD (). Tem o parâmetro "int não". O método está na classe, Aclass. Este método conta de 0 a 4. A primeira linha no método tem duas declarações. O primeiro imprime o parâmetro, não. O segundo imprime um espaço à direita deste parâmetro impresso. A próxima linha adiciona 1 a não. A linha a seguir é uma declaração IF composta. Tem a condição que deve ser atendida. A condição a ser atendida é quando nenhum alcance 5. Se 5 não foi alcançado, "MTHD (não);" se chama sem que não tenha acrescentado.

A classe principal para este método pode ser,

classe pública theClass
public static void main (string [] args)
int num = 0;
Aclass obj = new aclass ();
obj.MTHD (NUM);
Sistema.fora.println ();

A primeira declaração no método Main () declara o número inteiro, numerando zero a ele. Para que um método seja chamado, um objeto deve ser instanciado de sua classe. A próxima declaração no método Main () instancia um objeto, obj da Aclass. A declaração após usa esse objeto para chamar o método, mthd (), passando para ele o argumento, num, que é 0. Este é o começo da contagem. A última declaração no método Main () imprime uma nova linha, depois de todo o resultado ter sido impresso. A saída é:

0 1 2 3 4

O método recursivo, MTHD (), é chamado a primeira vez do método principal (). Depois disso, continua se chamando, até que uma condição seja atendida.

Este tipo de contagem pode ser feito para qualquer intervalo. Para alcançá -lo para qualquer intervalo, o número de início do intervalo deve ser atribuído a num. Em vez de 5 para a condição if no método, o número logo após o intervalo deve ser digitado.

Adicionando uma variedade de números não contínuos

Considere os números:

10, 20, 30, 40, 50, 60

A soma dos 4 primeiros números é 100. Isto é: 10 + 20 = 30; 30 + 30 = 60; e 60 + 40 = 100. Um método recursivo pode estar adicionando esses números a uma soma crescente até que a soma seja menor ou igual a 100. Para adicionar os cinco primeiros números, o método recursivo pode estar adicionando os números a uma soma crescente até que a soma seja menor ou igual a 150.

A estratégia é ter todos esses números em uma matriz no método principal (). Em seguida, passe a matriz como um argumento para o método recursivo. Se a adição dos quatro primeiros números for necessária, quando a soma atingir 100, o método recursivo deve parar de se chamar. Se a adição dos cinco primeiros números for necessária, quando a soma atingir 150, o método recursivo deve parar de se chamar. Se a adição dos seis primeiros números for necessária, quando a soma atingir 210, o método recursivo deve parar de se chamar.

A classe para este método recursivo pode ser:

classe Aclass
int sum = 0, i = 0;
Void Mthd (int [] arry)
soma = soma + arry [i];
i = i + 1;
se (soma < 100)
MTHD (Arry);

Isto é para adicionar os quatro primeiros números. A classe tem dois campos, que são soma e eu. Eu sou para iterar através da matriz, começando do índice 0. A primeira declaração no método recursivo, mthd (), adiciona o próximo número, à soma, que é inicialmente zero. A próxima declaração aumenta i em 1, para o próximo índice de matriz da próxima chamada. A declaração depois é o composto IF-Statement. A condição aqui é que a soma não deve estar acima de 100. Portanto, para cada chamada que a soma não é de até 100 (ou acima), o método é chamado novamente, passando a mesma matriz. Nesta situação, a condição está no final da implementação do método.

A classe principal () para isso pode ser:

classe pública theClass
public static void main (string [] args)
int [] arr = new int [] 10, 20, 30, 40, 50, 60;
Aclass obj = new aclass ();
obj.MTHD (ARR);
Sistema.fora.println (obj.soma);

A primeira declaração no método Main () instancia a matriz, com seus elementos. A segunda declaração instancia o objeto para o Aclass. A declaração depois chama o método recursivo, passando a matriz como argumento. Esta é a primeira chamada do método recursivo. Depois disso, o método se chamará até que a soma necessária seja alcançada. A última declaração imprime a soma final. A saída para este caso é 100.

Fatorial

O fatorial de 0, escrito como 0!, é 1. Os fatores de 5, 4, 3, 2, 1 são os seguintes:

Fatorial de 5 = 5 x 4 x 3 x 2 x 1 x 0! = 120
Fatorial de 4 = 4 x 3 x 2 x 1 x 0! = 24
Fatorial de 3 = 3 x 2 x 1 x 0! = 6
Fatorial de 2 = 2 x 1 x 0! = 2
Fatorial de 1 = 1 x 0! = 1

Um programa pode ser escrito para que, quando um número for enviado para um método recursivo, o método recursivo finalmente retorne o fatorial resultante resultante. Observe que o fatorial pode ser calculado até 1, em vez de 0, e o resultado ainda será o mesmo.

A classe para o método recursivo pode ser:

classe Aclass
int mthd (int não)
se (não == 1)
retornar 1;
outro
retornar (não * mthd (não-1));

Todo o corpo do método é um composto se estatem. Se o número cujo fatorial for necessário é 1, o que será devolvido será 1, pois o fatorial de 1 é 1. Se o número for maior que 1, toda a multiplicação deverá ser feita, começando do próprio número, caindo por 1 unidade.

O resultado é obtido quando toda a multiplicação foi feita. A expressão de retorno aqui é uma chamada de método. Seu argumento é o produto do número e o método recursivo.

Suponha que o número cujo fatorial seja necessário seja 5, então o argumento da primeira chamada de retorno será:

5 x MTHD (4)

Esta expressão será reservada na memória, e a próxima chamada será

5 x 4 x MTHD (3)

Esta expressão será reservada na memória, e a próxima chamada será

5 x 4 x 3 x MTHD (2)

Esta expressão será reservada na memória, e a próxima chamada será

5 x 4 x 3 x 2 x MTHD (1)

Agora, o MTHD (1) retorna 1, devido à declaração IF-Part, “se (não == 1) retornar 1;”, resultando em,

5 x 4 x 3 x 2 x 1 = 120

Para o valor final de retorno.

A classe principal para isso, pode ser:

classe pública theClass
public static void main (string [] args)
Aclass obj = new aclass ();
int ret = obj.MTHD (5);
Sistema.fora.println (ret);

Com um argumento de 5 para a primeira chamada, no método Main (), o valor final retornado é 120.

Conclusão

Recursão em Java é o chamado de um método, pelo método, de dentro do método. Esta ação se repete até que uma condição seja atendida.