Ricorsione in Java

La ricorsione in Java è la chiamata di un metodo, con il metodo, dall'interno del metodo. Questa azione si ripete fino a quando non viene soddisfatta una condizione. Il metodo dovrebbe essere un metodo in una classe, diverso da uno nella classe principale. La classe principale è la classe che ha il metodo principale (). Il nome del file Java è quello della classe principale. Un metodo statico nella classe principale può ancora essere reso ricorsivo, ma questo non sarà affrontato in questo articolo. Questo articolo spiega la ricorsione in Java, con tre buoni esempi.

Contare i numeri interi da zero

Considera un file Java con due classi: una classe privata come segue:

classe aclass
void mthd (int no)
Sistema.fuori.stampa (no); Sistema.fuori.stampa(");
no = no + 1;
Se (no < 5)
MTHD (NO);

Il metodo da chiamare se stesso è, mthd (). Ha il parametro "int no". Il metodo è nella classe, aclass. Questo metodo conta da 0 a 4. La prima riga nel metodo ha due dichiarazioni. Il primo stampica il parametro, no. Il secondo sta stampa uno spazio a destra di questo parametro stampato. La riga successiva aggiunge 1 a no. La riga che segue è un'istruzione IF-COMPOUND. Ha la condizione che deve essere soddisfatta. La condizione da soddisfare è quando non raggiunge 5. Se 5 non è stato raggiunto, "MTHD (NO);" si chiama con no che ha 1 aggiunto ad esso.

La classe principale per questo metodo può essere,

Classe pubblica TheClass
public static void main (string [] args)
int num = 0;
Aclass obj = new aclass ();
obj.MTHD (num);
Sistema.fuori.println ();

La prima istruzione nel metodo principale () dichiara l'intero, num che ci assegna zero. Per un metodo da chiamare, un oggetto dovrebbe essere istanziato dalla sua classe. L'istruzione successiva nel metodo principale () istanzia un oggetto, OBJ di ACLASS. L'istruzione dopo usa questo oggetto per chiamare il metodo, mthd (), passando ad esso l'argomento, num, che è 0. Questo è l'inizio del conteggio. L'ultima istruzione nel metodo principale () stampica una nuova riga, dopo che tutto il risultato è stato stampato. L'output è:

0 1 2 3 4

Il metodo ricorsivo, mthd (), è chiamato la prima volta dal metodo principale (). Dopodiché continua a chiamarsi, fino a quando una condizione non viene soddisfatta.

Questo tipo di conteggio può essere fatto per qualsiasi intervallo. Per raggiungerlo per qualsiasi intervallo, il numero iniziale dell'intervallo deve essere assegnato a num. Invece di 5 per la condizione if nel metodo, il numero subito dopo l'intervallo dovrebbe essere digitato.

Aggiunta di una gamma di numeri non continui

Considera i numeri:

10, 20, 30, 40, 50, 60

La somma dei primi 4 numeri è 100. Cioè: 10 + 20 = 30; 30 + 30 = 60; e 60 + 40 = 100. Un metodo ricorsivo può essere aggiungere questi numeri a una somma crescente fino a quando la somma non è inferiore o uguale a 100. Per aggiungere i primi cinque numeri, il metodo ricorsivo può essere aggiungere i numeri a una somma crescente fino a quando la somma non è inferiore o uguale a 150.

La strategia è quella di avere tutti questi numeri in un array nel metodo principale (). Quindi, passare l'array come argomento al metodo ricorsivo. Se è richiesta l'aggiunta dei primi quattro numeri, quando la somma raggiunge 100, il metodo ricorsivo dovrebbe smettere di chiamarsi. Se è richiesta l'aggiunta dei primi cinque numeri, quando la somma raggiunge 150, il metodo ricorsivo dovrebbe smettere di chiamarsi. Se è richiesta l'aggiunta dei primi sei numeri, quando la somma raggiunge 210, il metodo ricorsivo dovrebbe smettere di chiamarsi.

La classe per questo metodo ricorsivo può essere:

classe aclass
int sum = 0, i = 0;
void mthd (int [] arry)
Sum = sum + arry [i];
i = i + 1;
Se (somma < 100)
MTHD (ARRY);

Questo è per l'aggiunta dei primi quattro numeri. La classe ha due campi, che sono somme e io. Io sta per iterare attraverso l'array, a partire dall'indice 0. La prima affermazione nel metodo ricorsivo, mthd (), aggiunge il numero successivo, alla somma, che inizialmente è zero. L'istruzione successiva aumenta i di 1, per il prossimo indice di array della chiamata successiva. L'istruzione dopo è il composto if-statement. La condizione qui è che la somma non dovrebbe essere superiore a 100. Quindi, per ogni chiamata che la somma non è fino a 100 (o superiore), il metodo viene nuovamente chiamato, passando lo stesso array. In questa situazione, la condizione è alla fine dell'implementazione del metodo.

La classe principale () per questo può essere:

Classe pubblica 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.fuori.println (obj.somma);

La prima affermazione nel metodo principale () istanzia l'array, con i suoi elementi. La seconda istruzione istanzia l'oggetto per ACLASS. L'istruzione dopo, chiama il metodo ricorsivo, passando l'array come argomento. Questa è la prima chiamata del metodo ricorsivo. Successivamente, il metodo sarà chiamato se stesso fino al raggiungimento della somma richiesta. L'ultima dichiarazione stampica la somma finale. L'output per questo caso è 100.

Fattoriale

Il fattoriale di 0, scritto come 0!, è 1. I fattoriali di 5, 4, 3, 2, 1 sono i seguenti:

Faziale di 5 = 5 x 4 x 3 x 2 x 1 x 0! = 120
Faziale di 4 = 4 x 3 x 2 x 1 x 0! = 24
Fattoriale di 3 = 3 x 2 x 1 x 0! = 6
Fattoriale di 2 = 2 x 1 x 0! = 2
Faziale di 1 = 1 x 0! = 1

Un programma può essere scritto in modo che quando un numero viene inviato a un metodo ricorsivo, il metodo ricorsivo restituirà finalmente il fattoriale risultante. Si noti che il fattoriale può essere calcolato fino a 1, anziché 0, e il risultato sarà comunque lo stesso.

La classe per il metodo ricorsivo può essere:

classe aclass
int mthd (int no)
if (no == 1)
Ritorno 1;
altro
return (no * mthd (no-1));

L'intero corpo del metodo è un composto if-statement. Se il numero il cui fattoriale è necessario, è 1, ciò che verrà restituito sarà 1, poiché il fattoriale di 1 è 1. Se il numero è maggiore di 1, allora tutta la moltiplicazione dovrà essere fatta, a partire dal numero stesso, scendendo di 1 unità.

Il risultato è ottenuto quando tutta la moltiplicazione è stata fatta. L'espressione di ritorno qui è una chiamata del metodo. Il suo argomento è il prodotto del numero e del metodo ricorsivo.

Supponiamo che il numero il cui fattoriale è necessario, sia 5, quindi l'argomento della prima chiamata di ritorno sarà:

5 x mthd (4)

Questa espressione sarà riservata in memoria e la prossima chiamata sarà

5 x 4 x mthd (3)

Questa espressione sarà riservata in memoria e la prossima chiamata sarà

5 x 4 x 3 x mthd (2)

Questa espressione sarà riservata in memoria e la prossima chiamata sarà

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

Ora, MTHD (1) restituisce 1, a causa dell'istruzione IF-Part, "if (no == 1) return 1;", risultante,

5 x 4 x 3 x 2 x 1 = 120

Per il valore di restituzione finale.

La classe principale per questo può essere:

Classe pubblica TheClass
public static void main (string [] args)
Aclass obj = new aclass ();
int ret = obj.MTHD (5);
Sistema.fuori.println (ret);

Con un argomento di 5 per la prima chiamata, nel metodo principale (), il valore restituito finale è 120.

Conclusione

La ricorsione in Java è la chiamata di un metodo, con il metodo, dall'interno del metodo. Questa azione si ripete fino a quando non viene soddisfatta una condizione.