REKURSIF

Dalam matematika, faktorial dari bilangan asli n adalah hasil perkalian antara bilangan bulat positif yang kurang dari atau sama dengan n. Faktorial ditulis sebagai n! dan disebut n faktorial. Secara umum dapat dituliskan sebagai:

Sebagai contoh, nilai dari  adalah  Berikut ini adalah daftar sejumlah faktorial :

n n!
0 1
1 1
2 2
3 6
4 24
5 120
6 720
7 5040
8 40320
9 362880
10 3628800
12 479001600
14 87178291200
16 20922789888000
18 6402373705728000
20 2432902008176640000
25 1.5511210043×1025
42 1.4050061178×1051
50 3.0414093202×1064
70 1.1978571670×10100
100 9.3326215444×10157
450 1.7333687331×101.000
1000 4.0238726008×102.567
3249 6.4123376883×1010.000
10000 2.8462596809×1035.659
25206 1.2057034382×10100.000
100000 2.8242294080×10456.573
205023 2.5038989317×101.000.004
1000000 8.2639316883×105.565.708

Fungsi faktorial didefinisikan sebagai:

Selain definisi tersebut, terdapat juga definisi secara rekursif, yang didefinisikan untuk 

Untuk n yang sangat besar, akan terlalu melelahkan untuk menghitung n! menggunakan kedua definisi tersebut. Jika presisi tidak terlalu penting, pendekatan dari n! bisa dihitung menggunakan rumus Stirling. 

Juga terdapat definisi analitik untuk faktorial, yaitu menggunakan fungsi gamma.

Metoda rekursif adalah metoda mengulang dirinya sendiri. Metoda ini memanggil dirinya sendiri untuk melakukan proses berulang-ulang. Kasus sederhana yang sering muncul adalah proses berulang-ulang menghitung hasil factorial. Misalnya adalah factorial dari 5 adalah 1 x 2 x 3 x 4 x 5. Dari proses itu kita ketahui bahwa untuk menghitung factorial 5 manualnya seperti 1 x 2 = 2, lalu hasil 2 ini dikalikan 3 sehingga hasilnya adalah 6, lalu hasil 6 ini dikalikan lagi dengan 4 sehingga hasilnya adalah 36, lalu hasil 36 ini dikalikan dengan 5 sehingga hasilnya adalah 120.
            Nah inilah yang dinamakan rekursif, hasil dari proses awal digunakan lagi untuk proses berikutnya sampai batas yang diinginkan.
Langsung aja ya ke javanya :

class faktorial{
int fak_rekursif(int n){
int Hasil;

if(n==1 || n==0) return 1;

Hasil = fak_rekursif(n-1) * n;

return Hasil;
}

int fak_perulangan(int n){
int t;
int Hasil;

Hasil = 1;

for(t=1; t<=n; t++)
Hasil *= t;

return Hasil;
}
}

class faktorialDemo{
public static void main(String args[]){
faktorial fak = new faktorial();

System.out.println("Hitung Faktorial dengan Rekursif");
System.out.println("Faktorial dari 4 adalah : "+ fak.fak_rekursif(4));

System.out.println("Hitung Faktorial dengan Perulangan");
System.out.println("Faktorial dari 4 adalah : "+ fak.fak_perulangan(4));
}
}

Kode diatas saya selipkan juga factorial dengan menggunakan perulangan. Pada proses factorial dengan perulangan, awalnya adalah hasil factorial bernilai 1 dan terus bertambah dengan perkalian tiap kenaikan t dari perulangan.

Berbeda dengan factorial dengan menggunakan metoda rekursif. Code yang menunjukan bahwa proses rekursif adalah :

Hasil = fak_rekursif(n-1) * n;
Nilai dari variable Hasil ini didapat dari pemanggilan terlebih dahulu fungsi fak_rekursif dengan parameter mundur. Jadi secara tidak langsung, code ini menghitung terlebih dahulu factorial dari yang kecil. Misalnya adalah factorial 5, maka code tadi itu menghitung.

Hasil = fak_rekursif(1-1) * 1; , memanggil fungsi fak_rekursif(0)
Hasil = fak_rekursif(2-1) * 2; , memanggil fungsi fak_rekursif(1)
Hasil = fak_rekursif(3-1) * 3; , memanggil fungsi fak_rekursif(2)
Hasil = fak_rekursif(4-1) * 4; , memanggil fungsi fak_rekursif(3)
Hasil = fak_rekursif(5-1) * 5; , memanggil fungsi fak_rekursif(4)

Karena proses awalnya adalah fak_rekursif(5-1)*5; , maka otomatis fungsi itu memanggil fungsi fak_rekursif (4), di dalam fungsi fak_rekursif(4), ada proses pemanggilan fungsi fak_rekursif(4-1)*4, yaitu fungsi fak_rekursif(3). Dan seterusnya.
Moga jelas ya, jadi proses rekursif adalah proses pemanggilan dirinya sendiri.