9th Grade

ALOGARITMA
REKURSIF
Arif Fahrizal Launu | 13020200247
Teori Dasar
Fungsi rekursif adalah sebuah fungsi yang memanggil dirinya sendiri.  Dalam artian sebuah rekursif
merupakan suatu perulangan yang menggunakan metode memanggil dirinya sendiri dalam sebuah
algoritma pemrograman. Jadi metode rekursif, melakukan siklus tanpa menggunakan sintax
perulangan seperti, (for, while do, repeat untill, dan sejenisnya).

Bentuk rekursif :
1.suatu subrutin/fungsi/ prosedur yang memanggil dirinya sendiri.
2.Bentuk dimana pemanggilan subrutin terdapat dalam body subrutin.
3.Dengan rekursi, program akan lebih mudah dilihat.

Syarat bentuk rekursif :

4.ada kondisi terminal (basis).
5.ada subroutine call yang melibatkan parameter yang nilainya menuju kondisi terminal
(recurrence).

 Contoh kasus yang biasa menggunakan rekursif adalah faktorial.

Contoh Fungsi Rekursif
Contoh paling sederhana dari proses rekursi
adalah menghitung nilai faktorial dari
bilangan bulat. Nilai faktorial, secara rekursif
dapat ditulis sebagai :
0! = 1
N! = N x (N-1)!, Untuk N > 0
yang secara notasi pemrograman bisa ditulis
sebagai:
FAKTORIAL (0) = 1 1)
FAKTORIAL (N) = N * FAKTORIAL (N-1)
Menghitung Kompleksitas Waktu dari Alogaritma Rekursif
   Untuk bentuk rekursif, digunakan teknik perhitungan kompleksitas dengan relasi rekurens.

A. Contoh (Algoritma Menghitung Deret 2*n)

* Menghitung T(n)
Function S(input n : integer)→integer
Jadi Relasi Rekuens :
Kamus : T(n) =  →         1                    ,n = 1
→      T(n-1) + 2n    ,n > 1
{Tidak ada}
T(n)     = 2n + T(n-1)
Algoritma : = 2n + T(n-2) = 2n + T(n-2)
If (n==1) = 2n + T(n-3) = 2n + T(n-3)
    Then = ………
return (2) = 2n + T(0)
    Else = 2n + 0
return (2*n+S(n-1)) Jadi T(n)= n → O(2n)
Endif
 
B. Contoh 2 (Algoritma Faktorial)
Function Faktorial (input n : integer)→integer Menghitung faktorial Kompleksitas waktu :
untuk kasus basis, tidak ada operasi perkalian → (0)
Kamus : untuk kasus rekurens, kompleksitas waktu diukur dari
{Tidak ada} jumlah perkalian (1) ditambah kompleksitas waktu untuk
faktorial (n-1)
Algoritma :
* Menghitung T(n)
Jadi Relasi Rekuens :
        If  (n=0) T(n)=  →          0                           ,n = 0
→      T(n-1) + 1                ,n > 0
Then
T(n)      = 1 + T(n-1)
return 1 = 1 + 1 + T(n-2) = 2 + T(n-2)
Else = 2 + 1 + T(n-3) = 3 + T(n-3)
= ………
return (n * faktorial(n-1)) = n + T(0)
        Endif =n+0
Jadi T(n) = n → O(n)
EndFunction
 Rekursif dengan memoisasi
(Recursive with memorization)
Memoisasi adalah cara untuk membuat fungsi yang menggunakan rekursi
berjalan lebih cepat. Seperti yang akan saya tunjukkan dalam contoh di bawah
ini, fungsi rekursif mungkin akan melakukan perhitungan yang sama dengan
input yang sama beberapa kali. Ini berarti proses ini bisa memakan waktu lebih
lama daripada alternatif yang berulang. Fungsi memoization memungkinkan
kita menyimpan input di samping hasil kalkulasi. Oleh karena itu, daripada
harus melakukan pekerjaan yang sama lagi menggunakan input yang sama, ini
dapat mengembalikan nilai yang disimpan dalam cache.
Contoh menggunakan rekursi untuk menghitung
angka ke - n dalam deret Fibonacci

Catatan singkat tentang Urutan Fibonacci : Ini adalah urutan angka di mana setiap angka adalah jumlah dari dua angka
sebelumnya. Kita selalu mulai dengan 0 dan 1. Angka berikutnya adalah 1 lainnya, karena 0 + 1 = 1. Kemudian kita akan
mendapatkan 2 (1 + 1 = 2), lalu 3 (1 + 2 = 3), dan seterusnya di.

Berikut adalah solusi rekursif

Contoh memoization

Dengan fungsi memoization, kita

bisa membuat cache tempat kita
menyimpan input beserta hasil
perhitungannya. Kemudian, setiap
kali kita memiliki masukan yang
telah kita lihat, kita bisa langsung
mengambil hasilnya daripada
mengulang pekerjaan kita.
TERIMA
KASIH