Cara Kerja Rekursi
Kasus dasar dan tumpukan pemanggilan.
Cara Kerja Rekursi adalah pelajaran C Academy gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar C Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus C Academy mencakup 4 pelajaran total.
Apa Itu Rekursi?
Rekursi adalah keadaan ketika sebuah fungsi memanggil dirinya sendiri untuk menyelesaikan masalah. Setiap pemanggilan mengerjakan bagian yang lebih kecil dari masalah awal.
Dalam C, fungsi apa pun dapat memanggil dirinya sendiri selama ada cara agar pemanggilan tersebut akhirnya berhenti.
Kasus Dasar
Setiap fungsi rekursif memerlukan kasus dasar: kondisi ketika fungsi berhenti memanggil dirinya sendiri dan langsung mengembalikan nilai.
Tanpa kasus dasar, fungsi akan memanggil dirinya sendiri selamanya dan menyebabkan program berhenti karena galat.
int countdown(int n) {
if (n == 0) return 0; /* base case */
return countdown(n - 1);
}Kasus Rekursif
Kasus rekursif adalah bagian ketika fungsi memanggil dirinya sendiri dengan argumen yang berubah.
Argumen tersebut harus bergerak mendekati kasus dasar; jika tidak, rekursi tidak akan pernah berakhir.
int sum_to(int n) {
if (n == 0) return 0; /* base case */
return n + sum_to(n - 1); /* recursive case */
}Program Lengkap Pertama
Mari kita jalankan program lengkap yang menjumlahkan bilangan dari 1 hingga 5 menggunakan rekursi.
Hasilnya seharusnya 15.
#include <stdio.h>
int sum_to(int n) {
if (n == 0) return 0;
return n + sum_to(n - 1);
}
int main(void) {
printf("%d\n", sum_to(5));
return 0;
}Menelusuri Pemanggilan
Menelusuri rekursi secara manual dapat membantu. Untuk sum_to(3):
sum_to(3) = 3 + sum_to(2)
sum_to(2) = 2 + sum_to(1)
sum_to(1) = 1 + sum_to(0)
sum_to(0) = 0
Kemudian pemanggilan tersebut mengembalikan nilai dari bawah ke atas: 1, lalu 3, kemudian 6.
Tumpukan Pemanggilan
Setiap pemanggilan fungsi mendapatkan ruangnya sendiri pada tumpukan pemanggilan, yang menyimpan parameternya dan variabel lokalnya.
Saat masuk semakin dalam, bingkai-bingkai akan menumpuk. Ketika sebuah pemanggilan mengembalikan nilai, bingkainya dihapus dan kendali kembali ke pemanggilnya.
Proses Menurun dan Menaik
Rekursi memiliki dua tahap. Proses menurun terjadi ketika pemanggilan terus bergerak semakin dalam menuju kasus dasar.
Proses menaik terjadi ketika kasus dasar mengembalikan nilai dan setiap pemanggilan menyelesaikan pekerjaannya menggunakan nilai yang dikembalikan.
#include <stdio.h>
int factorial(int n) {
if (n <= 1) return 1;
return n * factorial(n - 1);
}
int main(void) {
printf("%d\n", factorial(4));
return 0;
}Nilai Kembalian Mengalir Kembali
Nilai yang dikembalikan oleh pemanggilan yang lebih dalam digunakan oleh pemanggilan yang membuatnya.
Inilah alasan urutan penting: pemanggilan terdalam selesai terlebih dahulu, lalu hasilnya digabungkan saat kembali ke atas tumpukan.
int power(int base, int exp) {
if (exp == 0) return 1;
return base * power(base, exp - 1);
}Mencetak Selama Rekursi
Anda dapat mencetak sebelum atau sesudah pemanggilan rekursif. Mencetak sebelum pemanggilan menampilkan bilangan saat bergerak turun; mencetak sesudahnya menampilkan bilangan saat kembali naik.
#include <stdio.h>
void down(int n) {
if (n == 0) return;
printf("%d ", n);
down(n - 1);
}
int main(void) {
down(5);
printf("\n");
return 0;
}Mencetak Saat Perjalanan Naik
Pindahkan printf setelah pemanggilan rekursif dan urutannya akan berbalik. Pemanggilan terdalam mencetak terlebih dahulu.
Hasilnya adalah 1 2 3 4 5, bukan 5 4 3 2 1.
#include <stdio.h>
void up(int n) {
if (n == 0) return;
up(n - 1);
printf("%d ", n);
}
int main(void) {
up(5);
printf("\n");
return 0;
}Dua Aturan yang Perlu Diingat
Fungsi rekursif yang benar mengikuti dua aturan:
1. Fungsi tersebut memiliki setidaknya satu kasus dasar yang mengembalikan nilai tanpa melakukan rekursi.
2. Setiap pemanggilan rekursif menggerakkan argumen mendekati kasus dasar.
Jika salah satu aturan dilanggar, program akan berulang selamanya.
Pemeriksaan Singkat
Uji pemahaman Anda tentang dasar-dasar rekursi.
Rangkuman
Rekursi menyelesaikan masalah dengan memanggil dirinya sendiri menggunakan input yang lebih kecil. Anda selalu memerlukan kasus dasar untuk berhenti dan kasus rekursif yang bergerak mendekatinya.
Setiap pemanggilan menggunakan bingkai tumpukan; hasil mengalir kembali saat pemanggilan-pemanggilan tersebut kembali naik.
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Cara Kerja Rekursi” gratis?
Ya — teks lengkap “Cara Kerja Rekursi” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus C Academy, upgrade ke CoddyKit PRO. Kursus C Academy mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “Cara Kerja Rekursi”?
Kasus dasar dan tumpukan pemanggilan. Kamu berlatih C Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.
Apakah aku perlu pengalaman untuk memulai C Academy?
Tidak diperlukan pengalaman sebelumnya. C Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.
Berapa lama pelajaran “Cara Kerja Rekursi” memakan waktu?
Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.
Bisakah aku menulis dan menjalankan kode dalam pelajaran C Academy ini?
Ya. Setiap pelajaran C Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.
Semua pelajaran dalam kursus ini
- Cara Kerja Rekursi
- Masalah Rekursif Klasik
- Rekursi vs Iterasi
- Menghindari Stack Overflow