Go From Zero to Hero #14: Berpikir Khas Programmer dengan Logika Perulangan Rekursif di Go

Halo Go Developers! Selamat datang kembali di seri Go From Zero to Hero.

Di artikel ketiga belas kemarin, kita sudah berhasil membedahkan perbedaan mendasar antara Fungsi dan Prosedur, serta bagaimana cara memanipulasi data memori menggunakan parameter pointer di dalam prosedur. Kode program kita sudah semakin terstruktur sekarang!

Selama ini, kalau kita ingin melakukan perulangan (misalnya mencetak angka 1 sampai 10), alat tempur utama kita pasti adalah for-loop yang sudah kita pelajari di artikel 8.

Tapi tahu gak sih, di dunia algoritma ada satu cara perulangan ekstrem yang sangat disukai para dosen dan ilmuwan komputer? Cara tersebut dinamakan Rekursif (Recursion).

Rekursif adalah sebuah teknik di mana sebuah fungsi atau prosedur memanggil dirinya sendiri untuk menyelesaikan masalah.

Mendengarnya saja mungkin terdengar aneh dan bikin pusing, “Hah? Fungsi memanggil fungsi itu sendiri? Bukannya nanti bakal berputar terus tanpa akhir, Bang?”

Nah, di artikel ke-empat belas ini, kita akan membongkar rahasia di balik logika rekursif ini, memahami cara menghentikannya, dan melihat bagaimana penerapannya di Go-lang. Yuk, kita mulai!

Analogi Dunia Nyata: Cermin yang Berhadapan

Sebelum pusing melihat kode, bayangkan kamu sedang berdiri di antara dua cermin besar yang saling berhadapan.

Apa yang kamu lihat? Kamu akan melihat bayangan dirimu di dalam cermin, yang di dalamnya ada bayanganmu lagi, yang di dalamnya ada bayanganmu lagi, terus masuk ke dalam seolah-olah tanpa batas. Itulah gambaran visual dari rekursif: sebuah hal yang mendefinisikan dirinya sendiri di dalam dirinya sendiri.

Di dunia pemrograman, kalau kamu menyuruh fungsi memanggil dirinya sendiri tanpa aturan, laptopmu akan mengalami crash karena kehabisan memori RAM (dikenal dengan istilah Stack Overflow).

Oleh karena itu, setiap fungsi rekursif wajib memiliki satu hal sakral bernama: Base Case (Kondisi Berhenti).

Struktur Wajib Fungsi Rekursif

Sebuah fungsi rekursif yang aman wajib dibagi menjadi dua bagian:

1. Base Case: Kondisi darurat di mana fungsi harus berhenti memanggil dirinya sendiri dan mulai mengembalikan nilai.
2. Recursive Case: Bagian di mana fungsi memanggil dirinya sendiri sambil memperkecil data input menuju ke Base Case.

Mari kita lihat contoh paling legendaris: Menghitung Faktorial (misalnya 5! = 5 × 4 × 3 × 2 × 1).

package main

import "fmt"

// Fungsi rekursif untuk menghitung faktorial
func hitungFaktorial(n int) int {
    // 1. BASE CASE: Jika n sudah bernilai 1 atau 0, hentikan perulangan
    if n <= 1 {
        return 1
    }

    // 2. RECURSIVE CASE: Fungsi memanggil dirinya sendiri dengan parameter (n - 1)
    return n * hitungFaktorial(n-1)
}

func main() {
    hasil := hitungFaktorial(5)
    fmt.Println("Hasil dari 5 faktorial adalah:", hasil) // Output: 120
}

Bagaimana Cara Kerjanya di Dalam Memori RAM?

Mari kita bedah apa yang terjadi di belakang layar saat kamu memanggil hitungFaktorial(5):

1. hitungFaktorial(5) dipanggil → Belum tahu hasilnya, karena dia harus menghitung 5 * hitungFaktorial(4). (Ditumpuk di memori).
2. hitungFaktorial(4) dipanggil → Harus menghitung 4 * hitungFaktorial(3). (Ditumpuk lagi).
3. hitungFaktorial(3) dipanggil → Harus menghitung 3 * hitungFaktorial(2). (Ditumpuk lagi).
4. hitungFaktorial(2) dipanggil → Harus menghitung 2 * hitungFaktorial(1). (Ditumpuk lagi).
5. hitungFaktorial(1) dipanggil → Kena Base Case! Fungsi ini langsung mengembalikan angka 1.

Setelah Base Case tersentuh, tumpukan memori tadi akan mulai diselesaikan dari bawah ke atas secara berantai (seperti efek domino mundur):

• hitungFaktorial(2) menerima 1 → menjadi 2 × 1 = 2.
• hitungFaktorial(3) menerima 2 → menjadi 3 × 2 = 6.
• hitungFaktorial(4) menerima 6 → menjadi 4 × 6 = 24.
• hitungFaktorial(5) menerima 24 → menjadi 5 × 24 = 120.

Akhirnya, keluarlah angka 120!

Prosedur Rekursif (Mencetak Hitung Mundur)

Rekursif tidak hanya monopoli Fungsi bertipe return value saja, kamu juga bisa menerapkannya pada Prosedur untuk melakukan aksi berulang. Contohnya, membuat hitung mundur roket sebelum meluncur:

package main

import "fmt"

// Prosedur rekursif untuk hitung mundur
func hitungMundur(angka int) {
    // BASE CASE
    if angka < 0 {
        fmt.Println("Boom! Roket Meluncur! 🚀")
        return // Keluar dari prosedur
    }

    // Aksi cetak angka saat ini
    fmt.Println(angka)

    // RECURSIVE CASE
    hitungMundur(angka - 1)
}

func main() {
    fmt.Println("Memulai hitung mundur:")
    hitungMundur(5)
}

Jika dijalankan, outputnya akan langsung berurutan: 5, 4, 3, 2, 1, 0, Boom! Roket Meluncur!.

Kapan Harus Pakai Rekursif vs For-Loop Biasa?

• Gunakan For-Loop jika: Kamu butuh performa yang cepat dan hemat memori RAM, karena perulangan biasa tidak membuat tumpukan fungsi di memori (call stack).
• Gunakan Rekursif jika: Kamu menghadapi struktur data yang bercabang-cabang rumit (seperti struktur folder file di laptop, pohon keputusan, atau algoritma pencarian tingkat lanjut) yang kalau ditulis pakai for-loop kodenya bakal sangat panjang dan rumit.

Kesimpulan & Penutup

Selamat, Otak Programmermu Sudah Upgrade! 🧠

Logika rekursif melatih kita untuk memecahkan masalah besar dengan cara membaginya menjadi masalah-masalah kecil yang serupa. Selama kamu memegang erat aturan Base Case, fungsi rekursifmu akan berjalan dengan aman, indah, dan ringkas!

Yuk, Nyicip Eksperimen Kecil! 🛠️

Coba hilangkan bagian if n <= 1 pada kode faktorial di atas, lalu jalankan programnya. Lihat apa pesan eror yang dikeluarkan oleh Go-lang saat memorimu habis akibat perulangan tanpa henti!

🎯 Tantangan Untukmu (Challenge!)

Dalam matematika, ada deret angka bernama Deret Fibonacci yang polanya merupakan penjumlahan dari dua angka sebelumnya: 0, 1, 1, 2, 3, 5, 8, 13, dst. Rumus umumnya adalah: F(n) = F(n-1) + F(n-2), dengan base case F(0) = 0 dan F(1) = 1.

Buatlah sebuah fungsi rekursif bernama fibonacci(n int) int di Go-lang untuk mencari nilai deret ke-n tersebut!

Tunjukkan kode solusimu di kolom komentar di bawah ya!

Bocoran Artikel Selanjutnya 🚀

Setelah menuntaskan bab subprogram modular (Fungsi, Pointer, Prosedur, Rekursif), kita sudah resmi naik tingkat dan siap masuk ke Fase 3: Tipe Data Terstruktur.

Di artikel Go From Zero to Hero #15 berikutnya, kita akan berkenalan dengan wadah penyimpanan data raksasa pertama kita, yaitu Array: Cara Menyimpan Banyak Data dalam Satu Wadah. Bersiaplah karena dari sinilah data-data praktikum kuliahmu akan mulai diolah secara massal!

Sampai jumpa di artikel berikutnya, tetap semangat, dan happy coding!