Struktur Data â Pertemuan 13 List Rekursif.
Struktur Data – Pertemuan 13
List Rekursif
Prajanto Wahyu Adi
prajanto@dsn.dinus.ac.id
+6285 641 73 00 22
Struktur Data
Prajanto Wahyu Adi, M.Kom, M.CS
Rencana Kegiatan Perkuliahan Semester
#
Pokok Bahasan
1 Pengenalan Struktur
Data
2 ADT Stack & Queue
3 List Linear
4 List Linear
5 List Linear
6 Representasi Fisik List
Linear
7 Variasi List Linear
8 Ujian Tengah Semester
Struktur Data
#
9
Pokok Bahasan
Variasi List Linear
10 Variasi List Linear
11 Stack dengan Representasi
List
12 Queue dengan Representasi
List
13 List Rekursif
14 Pohon dan Pohon Biner
15 Studi Kasus Multi List
16 Ujian Akhir Semester
Prajanto Wahyu Adi, M.Kom, M.CS
Konten
1
• Pendekatan Iteratif dan Rekursif
2
• Membalik List secara Iteratif
3
• Fungsi Rekursif pada Memory
4
• Membalik List secara Rekursif
Struktur Data
Prajanto Wahyu Adi, M.Kom, M.CS
Pendekatan Iteratif dan Rekursif
• Pendekatan iteratif menggunakan proses perulangan
(loop) untuk menyelesaikan masalah
• Dala ko teks prosedural kita e iliki loop
sebagai mekanisme untuk mengulang
• Suatu entitas disebut rekursif jika pada definisinya
terkandung dirinya sendiri
• Program prosedural juga dapat bersifat rekursif
• Fungsi rekursif adalah fungsi yang memanggil dirinya
sendiri
Struktur Data
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Iteratif
• Input:
10
100
Head
8
200
100
14
300
200
7
400
300
Null
400
• Output:
10
Null
100
Struktur Data
8
100
200
14
200
300
7
300
400
400
Head
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Iteratif
• Diperlukan tiga buah variabel pointer:
– current
membentuk link baru sekaligus memutus link sebelumnya
– next
memindahkan pointer current ke node selanjutnya setelah
link sebelumnya diputus
– previous
menyimpan alamat node sebelumnya setelah link diputus
100
head
Struktur Data
10
Null
8
14
300
100
200
prev
100
curr
200
400
300
7
Null
400
next
200
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Iteratif
• Diperlukan tiga buah variabel pointer:
– current
membentuk link baru sekaligus memutus link sebelumnya
– next
memindahkan pointer current ke node selanjutnya setelah
link sebelumnya diputus
– previous
menyimpan alamat node sebelumnya setelah link diputus
100
head
Struktur Data
10
Null
8
300
14
400
100
200
300
prev
100
curr
200
next
200
7
Null
400
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Iteratif
• Diperlukan tiga buah variabel pointer:
– current
membentuk link baru sekaligus memutus link sebelumnya
– next
memindahkan pointer current ke node selanjutnya setelah
link sebelumnya diputus
– previous
menyimpan alamat node sebelumnya setelah link diputus
100
head
Struktur Data
10
Null
8
100
14
400
100
200
300
prev
100
curr
200
next
200
7
Null
400
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Iteratif
//Fungsi membalik list secara Iteratif
void balikListIteratif(){
Node *curr, *prev, *next;
curr = head;
prev = NULL;
while(curr != NULL){
next = curr->next;
curr->next = prev;
prev = curr;
curr = next;
}
head = prev;
}
Struktur Data
Prajanto Wahyu Adi, M.Kom, M.CS
Fungsi Rekursif pada Memory
• Memori yang dialokasikan pada sebuah program/
aplikasi umumnya dibagi menjadi 4 bagian:
Heap /
Free Store
Stack
Static/Global
Bersifat Dinamis:
Ukuran memori dapat berubah ketika program
dijalankan
Bersifat Statis:
• ukuran memori ditentukan ketika
kompilasi
• ukuran memori tidak dapat berubah
Code(Text)
Struktur Data
Prajanto Wahyu Adi, M.Kom, M.CS
Fungsi Rekursif pada Memory
• Memori yang dialokasikan pada sebuah program/
aplikasi umumnya dibagi menjadi 4 bagian:
Heap /
Free Store
Memori yang dapat di-request selama program
berjalan
Stack
Menyimpan semua informasi tentang
pemanggilan fungsi untuk menyimpan
semua variabel lokal
Menyimpan variabel global selama program
Static/Global berjalan
Code(Text)
Struktur Data
Menyimpan semua perintah yang akan
dijalankan/dieksekusi
Prajanto Wahyu Adi, M.Kom, M.CS
Fungsi Rekursif pada Memory
• Stack memory dialokasikan ketika terjadi
pemanggilan fungsi tertentu
main ()
Stack Memory
Struktur Data
Prajanto Wahyu Adi, M.Kom, M.CS
Fungsi Rekursif pada Memory
• Stack memory dialokasikan ketika terjadi
pemanggilan fungsi tertentu
• Nilai dan kondisi terakhir pada
pemanggilan fungsi tetap tersimpan pada
stack memory
• Fu gsi baru aka ditu puk berjala
diatas fungsi sebelumnya (sekaligus
menghentikan sementara eksekusi fungsi
sebelumnya) pada stack memory
main ()
Stack Memory
Struktur Data
Prajanto Wahyu Adi, M.Kom, M.CS
Fungsi Rekursif pada Memory
• Stack memory dialokasikan ketika terjadi
pemanggilan fungsi tertentu
• Nilai dan kondisi terakhir pada
pemanggilan fungsi tetap tersimpan pada
stack memory
• Fu gsi baru aka ditu puk berjala
diatas fungsi sebelumnya (sekaligus
menghentikan sementara eksekusi fungsi
sebelumnya) pada stack memory
Fungsi_1(x)
main ()
Stack Memory
Struktur Data
Prajanto Wahyu Adi, M.Kom, M.CS
Fungsi Rekursif pada Memory
Fungsi_1(y)
• Stack memory dialokasikan ketika terjadi
pemanggilan fungsi tertentu
• Nilai dan kondisi terakhir pada
pemanggilan fungsi tetap tersimpan pada
stack memory
• Fu gsi baru aka ditu puk berjala
diatas fungsi sebelumnya (sekaligus
menghentikan sementara eksekusi fungsi
sebelumnya) pada stack memory
Fungsi_1(x)
main ()
Stack Memory
Struktur Data
Prajanto Wahyu Adi, M.Kom, M.CS
Fungsi Rekursif pada Memory
Fungsi_1(z)
Fungsi_1(y)
• Stack memory dialokasikan ketika terjadi
pemanggilan fungsi tertentu
• Nilai dan kondisi terakhir pada
pemanggilan fungsi tetap tersimpan pada
stack memory
• Fu gsi baru aka ditu puk berjala
diatas fungsi sebelumnya (sekaligus
menghentikan sementara eksekusi fungsi
sebelumnya) pada stack memory
Fungsi_1(x)
main ()
Stack Memory
Struktur Data
Prajanto Wahyu Adi, M.Kom, M.CS
Fungsi Rekursif pada Memory
Fungsi_1(z)
Fungsi_1(y)
Fungsi_1(x)
main ()
• Stack memory dialokasikan ketika terjadi
pemanggilan fungsi tertentu
• Nilai dan kondisi terakhir pada
pemanggilan fungsi tetap tersimpan pada
stack memory
• Fu gsi baru aka ditu puk berjala
diatas fungsi sebelumnya (sekaligus
menghentikan sementara eksekusi fungsi
sebelumnya) pada stack memory
• Jika fungsi pada tumpukkan paling atas
selesai dijalankan, maka fungsi yang
berada pd tumpukkan dibawahnya akan
dijalankan kembali (resume).
Stack Memory
Struktur Data
Prajanto Wahyu Adi, M.Kom, M.CS
Fungsi Rekursif pada Memory
Fungsi_1(y)
Fungsi_1(x)
main ()
• Stack memory dialokasikan ketika terjadi
pemanggilan fungsi tertentu
• Nilai dan kondisi terakhir pada
pemanggilan fungsi tetap tersimpan pada
stack memory
• Fu gsi baru aka ditu puk berjala
diatas fungsi sebelumnya (sekaligus
menghentikan sementara eksekusi fungsi
sebelumnya) pada stack memory
• Jika fungsi pada tumpukkan paling atas
selesai dijalankan, maka fungsi yang
berada pd tumpukkan dibawahnya akan
dijalankan kembali (resume).
Stack Memory
Struktur Data
Prajanto Wahyu Adi, M.Kom, M.CS
Fungsi Rekursif pada Memory
Fungsi_1(y)
Fungsi_1(x)
main ()
• Stack memory dialokasikan ketika terjadi
pemanggilan fungsi tertentu
• Nilai dan kondisi terakhir pada
pemanggilan fungsi tetap tersimpan pada
stack memory
• Fu gsi baru aka ditu puk berjala
diatas fungsi sebelumnya (sekaligus
menghentikan sementara eksekusi fungsi
sebelumnya) pada stack memory
• Jika fungsi pada tumpukkan paling atas
selesai dijalankan, maka fungsi yang
berada pd tumpukkan dibawahnya akan
dijalankan kembali (resume).
Stack Memory
Struktur Data
Prajanto Wahyu Adi, M.Kom, M.CS
Fungsi Rekursif pada Memory
Fungsi_1(x)
main ()
• Stack memory dialokasikan ketika terjadi
pemanggilan fungsi tertentu
• Nilai dan kondisi terakhir pada
pemanggilan fungsi tetap tersimpan pada
stack memory
• Fu gsi baru aka ditu puk berjala
diatas fungsi sebelumnya (sekaligus
menghentikan sementara eksekusi fungsi
sebelumnya) pada stack memory
• Jika fungsi pada tumpukkan paling atas
selesai dijalankan, maka fungsi yang
berada pd tumpukkan dibawahnya akan
dijalankan kembali (resume).
Stack Memory
Struktur Data
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
• Input:
10
100
Head
8
200
100
14
300
200
7
400
300
Null
400
• Output:
10
Null
100
Struktur Data
8
100
200
14
200
300
7
300
400
400
Head
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next); //rekursif
p->next->next = p;
p->next = NULL;
7
Null
400
14
400
300
8
300
200
}
10
200
100
head = 100
Struktur Data
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
7
Null
400
14
400
300
8
300
200
main()
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
7
Null
400
14
400
300
balikRekursif()
p = 100
main()
8
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
7
Null
400
14
400
300
balikRekursif()
p = 100
main()
8
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
7
Null
400
14
400
300
balikRekursif()
p = 100
main()
8
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
7
Null
400
14
400
300
balikRekursif()
p = 100
main()
8
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
7
Null
400
14
400
300
balikRekursif()
p = 100
main()
8
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
balikRekursif()
p = 300
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
balikRekursif()
p = 300
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
balikRekursif()
p = 300
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
balikRekursif()
p = 300
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
balikRekursif()
p = 400
balikRekursif()
p = 300
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
balikRekursif()
p = 400
balikRekursif()
p = 300
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
balikRekursif()
p = 400
balikRekursif()
p = 300
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
balikRekursif()
p = 400
balikRekursif()
p = 300
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
balikRekursif()
p = 400
balikRekursif()
p = 300
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
balikRekursif()
p = 300
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
balikRekursif()
p = 300
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
balikRekursif()
p = 300
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
balikRekursif()
p = 300
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
balikRekursif()
p = 300
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
balikRekursif()
p = 300
7
balikRekursif()
p = 200
14
balikRekursif()
p = 100
8
main()
300
400
400
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
balikRekursif()
p = 300
7
balikRekursif()
p = 200
14
balikRekursif()
p = 100
8
main()
300
400
400
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
balikRekursif()
p = 300
7
balikRekursif()
p = 200
14
Null
300
balikRekursif()
p = 100
8
300
main()
300
400
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
balikRekursif()
p = 300
7
balikRekursif()
p = 200
14
Null
300
balikRekursif()
p = 100
8
300
main()
300
400
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
balikRekursif()
p = 200
14
Null
300
balikRekursif()
p = 100
8
300
main()
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
balikRekursif()
p = 200
14
Null
300
balikRekursif()
p = 100
8
300
main()
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
balikRekursif()
p = 200
14
Null
300
balikRekursif()
p = 100
8
300
main()
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
balikRekursif()
p = 200
14
Null
300
balikRekursif()
p = 100
8
300
main()
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
balikRekursif()
p = 200
14
Null
300
balikRekursif()
p = 100
8
300
main()
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
balikRekursif()
p = 200
14
balikRekursif()
p = 100
8
main()
200
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
balikRekursif()
p = 200
14
balikRekursif()
p = 100
8
main()
200
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
balikRekursif()
p = 200
14
balikRekursif()
p = 100
8
Null
200
10
200
main()
200
300
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
balikRekursif()
p = 200
14
balikRekursif()
p = 100
8
Null
200
10
200
main()
200
300
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
14
200
300
balikRekursif()
p = 100
main()
8
Null
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
14
200
300
balikRekursif()
p = 100
main()
8
Null
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
14
200
300
balikRekursif()
p = 100
main()
8
Null
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
14
200
300
balikRekursif()
p = 100
main()
8
Null
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
14
200
300
balikRekursif()
p = 100
main()
8
Null
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
14
200
300
balikRekursif()
p = 100
main()
8
100
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
14
200
300
balikRekursif()
p = 100
main()
8
100
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
14
200
300
balikRekursif()
p = 100
main()
Stack Memory
8
100
200
10
Null
100
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
14
200
300
balikRekursif()
p = 100
main()
Stack Memory
8
100
200
10
Null
100
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
14
200
300
8
100
200
main()
Stack Memory
10
Null
100
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
fungsi sudah dijalankan sebelumnya
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
14
200
300
8
100
200
main()
Stack Memory
10
Null
100
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
fungsi sudah dijalankan sebelumnya
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
14
200
300
8
100
200
main()
Stack Memory
10
Null
100
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
14
200
300
8
100
200
main()
Stack Memory
10
Null
100
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
7
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
300
400
14
200
300
8
100
200
10
Null
100
Prajanto Wahyu Adi, M.Kom, M.CS
Sekian
TERIMAKASIH
Struktur Data
Prajanto Wahyu Adi, M.Kom, M.CS
List Rekursif
Prajanto Wahyu Adi
prajanto@dsn.dinus.ac.id
+6285 641 73 00 22
Struktur Data
Prajanto Wahyu Adi, M.Kom, M.CS
Rencana Kegiatan Perkuliahan Semester
#
Pokok Bahasan
1 Pengenalan Struktur
Data
2 ADT Stack & Queue
3 List Linear
4 List Linear
5 List Linear
6 Representasi Fisik List
Linear
7 Variasi List Linear
8 Ujian Tengah Semester
Struktur Data
#
9
Pokok Bahasan
Variasi List Linear
10 Variasi List Linear
11 Stack dengan Representasi
List
12 Queue dengan Representasi
List
13 List Rekursif
14 Pohon dan Pohon Biner
15 Studi Kasus Multi List
16 Ujian Akhir Semester
Prajanto Wahyu Adi, M.Kom, M.CS
Konten
1
• Pendekatan Iteratif dan Rekursif
2
• Membalik List secara Iteratif
3
• Fungsi Rekursif pada Memory
4
• Membalik List secara Rekursif
Struktur Data
Prajanto Wahyu Adi, M.Kom, M.CS
Pendekatan Iteratif dan Rekursif
• Pendekatan iteratif menggunakan proses perulangan
(loop) untuk menyelesaikan masalah
• Dala ko teks prosedural kita e iliki loop
sebagai mekanisme untuk mengulang
• Suatu entitas disebut rekursif jika pada definisinya
terkandung dirinya sendiri
• Program prosedural juga dapat bersifat rekursif
• Fungsi rekursif adalah fungsi yang memanggil dirinya
sendiri
Struktur Data
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Iteratif
• Input:
10
100
Head
8
200
100
14
300
200
7
400
300
Null
400
• Output:
10
Null
100
Struktur Data
8
100
200
14
200
300
7
300
400
400
Head
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Iteratif
• Diperlukan tiga buah variabel pointer:
– current
membentuk link baru sekaligus memutus link sebelumnya
– next
memindahkan pointer current ke node selanjutnya setelah
link sebelumnya diputus
– previous
menyimpan alamat node sebelumnya setelah link diputus
100
head
Struktur Data
10
Null
8
14
300
100
200
prev
100
curr
200
400
300
7
Null
400
next
200
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Iteratif
• Diperlukan tiga buah variabel pointer:
– current
membentuk link baru sekaligus memutus link sebelumnya
– next
memindahkan pointer current ke node selanjutnya setelah
link sebelumnya diputus
– previous
menyimpan alamat node sebelumnya setelah link diputus
100
head
Struktur Data
10
Null
8
300
14
400
100
200
300
prev
100
curr
200
next
200
7
Null
400
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Iteratif
• Diperlukan tiga buah variabel pointer:
– current
membentuk link baru sekaligus memutus link sebelumnya
– next
memindahkan pointer current ke node selanjutnya setelah
link sebelumnya diputus
– previous
menyimpan alamat node sebelumnya setelah link diputus
100
head
Struktur Data
10
Null
8
100
14
400
100
200
300
prev
100
curr
200
next
200
7
Null
400
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Iteratif
//Fungsi membalik list secara Iteratif
void balikListIteratif(){
Node *curr, *prev, *next;
curr = head;
prev = NULL;
while(curr != NULL){
next = curr->next;
curr->next = prev;
prev = curr;
curr = next;
}
head = prev;
}
Struktur Data
Prajanto Wahyu Adi, M.Kom, M.CS
Fungsi Rekursif pada Memory
• Memori yang dialokasikan pada sebuah program/
aplikasi umumnya dibagi menjadi 4 bagian:
Heap /
Free Store
Stack
Static/Global
Bersifat Dinamis:
Ukuran memori dapat berubah ketika program
dijalankan
Bersifat Statis:
• ukuran memori ditentukan ketika
kompilasi
• ukuran memori tidak dapat berubah
Code(Text)
Struktur Data
Prajanto Wahyu Adi, M.Kom, M.CS
Fungsi Rekursif pada Memory
• Memori yang dialokasikan pada sebuah program/
aplikasi umumnya dibagi menjadi 4 bagian:
Heap /
Free Store
Memori yang dapat di-request selama program
berjalan
Stack
Menyimpan semua informasi tentang
pemanggilan fungsi untuk menyimpan
semua variabel lokal
Menyimpan variabel global selama program
Static/Global berjalan
Code(Text)
Struktur Data
Menyimpan semua perintah yang akan
dijalankan/dieksekusi
Prajanto Wahyu Adi, M.Kom, M.CS
Fungsi Rekursif pada Memory
• Stack memory dialokasikan ketika terjadi
pemanggilan fungsi tertentu
main ()
Stack Memory
Struktur Data
Prajanto Wahyu Adi, M.Kom, M.CS
Fungsi Rekursif pada Memory
• Stack memory dialokasikan ketika terjadi
pemanggilan fungsi tertentu
• Nilai dan kondisi terakhir pada
pemanggilan fungsi tetap tersimpan pada
stack memory
• Fu gsi baru aka ditu puk berjala
diatas fungsi sebelumnya (sekaligus
menghentikan sementara eksekusi fungsi
sebelumnya) pada stack memory
main ()
Stack Memory
Struktur Data
Prajanto Wahyu Adi, M.Kom, M.CS
Fungsi Rekursif pada Memory
• Stack memory dialokasikan ketika terjadi
pemanggilan fungsi tertentu
• Nilai dan kondisi terakhir pada
pemanggilan fungsi tetap tersimpan pada
stack memory
• Fu gsi baru aka ditu puk berjala
diatas fungsi sebelumnya (sekaligus
menghentikan sementara eksekusi fungsi
sebelumnya) pada stack memory
Fungsi_1(x)
main ()
Stack Memory
Struktur Data
Prajanto Wahyu Adi, M.Kom, M.CS
Fungsi Rekursif pada Memory
Fungsi_1(y)
• Stack memory dialokasikan ketika terjadi
pemanggilan fungsi tertentu
• Nilai dan kondisi terakhir pada
pemanggilan fungsi tetap tersimpan pada
stack memory
• Fu gsi baru aka ditu puk berjala
diatas fungsi sebelumnya (sekaligus
menghentikan sementara eksekusi fungsi
sebelumnya) pada stack memory
Fungsi_1(x)
main ()
Stack Memory
Struktur Data
Prajanto Wahyu Adi, M.Kom, M.CS
Fungsi Rekursif pada Memory
Fungsi_1(z)
Fungsi_1(y)
• Stack memory dialokasikan ketika terjadi
pemanggilan fungsi tertentu
• Nilai dan kondisi terakhir pada
pemanggilan fungsi tetap tersimpan pada
stack memory
• Fu gsi baru aka ditu puk berjala
diatas fungsi sebelumnya (sekaligus
menghentikan sementara eksekusi fungsi
sebelumnya) pada stack memory
Fungsi_1(x)
main ()
Stack Memory
Struktur Data
Prajanto Wahyu Adi, M.Kom, M.CS
Fungsi Rekursif pada Memory
Fungsi_1(z)
Fungsi_1(y)
Fungsi_1(x)
main ()
• Stack memory dialokasikan ketika terjadi
pemanggilan fungsi tertentu
• Nilai dan kondisi terakhir pada
pemanggilan fungsi tetap tersimpan pada
stack memory
• Fu gsi baru aka ditu puk berjala
diatas fungsi sebelumnya (sekaligus
menghentikan sementara eksekusi fungsi
sebelumnya) pada stack memory
• Jika fungsi pada tumpukkan paling atas
selesai dijalankan, maka fungsi yang
berada pd tumpukkan dibawahnya akan
dijalankan kembali (resume).
Stack Memory
Struktur Data
Prajanto Wahyu Adi, M.Kom, M.CS
Fungsi Rekursif pada Memory
Fungsi_1(y)
Fungsi_1(x)
main ()
• Stack memory dialokasikan ketika terjadi
pemanggilan fungsi tertentu
• Nilai dan kondisi terakhir pada
pemanggilan fungsi tetap tersimpan pada
stack memory
• Fu gsi baru aka ditu puk berjala
diatas fungsi sebelumnya (sekaligus
menghentikan sementara eksekusi fungsi
sebelumnya) pada stack memory
• Jika fungsi pada tumpukkan paling atas
selesai dijalankan, maka fungsi yang
berada pd tumpukkan dibawahnya akan
dijalankan kembali (resume).
Stack Memory
Struktur Data
Prajanto Wahyu Adi, M.Kom, M.CS
Fungsi Rekursif pada Memory
Fungsi_1(y)
Fungsi_1(x)
main ()
• Stack memory dialokasikan ketika terjadi
pemanggilan fungsi tertentu
• Nilai dan kondisi terakhir pada
pemanggilan fungsi tetap tersimpan pada
stack memory
• Fu gsi baru aka ditu puk berjala
diatas fungsi sebelumnya (sekaligus
menghentikan sementara eksekusi fungsi
sebelumnya) pada stack memory
• Jika fungsi pada tumpukkan paling atas
selesai dijalankan, maka fungsi yang
berada pd tumpukkan dibawahnya akan
dijalankan kembali (resume).
Stack Memory
Struktur Data
Prajanto Wahyu Adi, M.Kom, M.CS
Fungsi Rekursif pada Memory
Fungsi_1(x)
main ()
• Stack memory dialokasikan ketika terjadi
pemanggilan fungsi tertentu
• Nilai dan kondisi terakhir pada
pemanggilan fungsi tetap tersimpan pada
stack memory
• Fu gsi baru aka ditu puk berjala
diatas fungsi sebelumnya (sekaligus
menghentikan sementara eksekusi fungsi
sebelumnya) pada stack memory
• Jika fungsi pada tumpukkan paling atas
selesai dijalankan, maka fungsi yang
berada pd tumpukkan dibawahnya akan
dijalankan kembali (resume).
Stack Memory
Struktur Data
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
• Input:
10
100
Head
8
200
100
14
300
200
7
400
300
Null
400
• Output:
10
Null
100
Struktur Data
8
100
200
14
200
300
7
300
400
400
Head
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next); //rekursif
p->next->next = p;
p->next = NULL;
7
Null
400
14
400
300
8
300
200
}
10
200
100
head = 100
Struktur Data
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
7
Null
400
14
400
300
8
300
200
main()
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
7
Null
400
14
400
300
balikRekursif()
p = 100
main()
8
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
7
Null
400
14
400
300
balikRekursif()
p = 100
main()
8
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
7
Null
400
14
400
300
balikRekursif()
p = 100
main()
8
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
7
Null
400
14
400
300
balikRekursif()
p = 100
main()
8
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
7
Null
400
14
400
300
balikRekursif()
p = 100
main()
8
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
balikRekursif()
p = 300
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
balikRekursif()
p = 300
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
balikRekursif()
p = 300
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
balikRekursif()
p = 300
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
balikRekursif()
p = 400
balikRekursif()
p = 300
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
balikRekursif()
p = 400
balikRekursif()
p = 300
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=100
}
Struktur Data
balikRekursif()
p = 400
balikRekursif()
p = 300
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
balikRekursif()
p = 400
balikRekursif()
p = 300
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
balikRekursif()
p = 400
balikRekursif()
p = 300
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
balikRekursif()
p = 300
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
balikRekursif()
p = 300
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
balikRekursif()
p = 300
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
balikRekursif()
p = 300
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
balikRekursif()
p = 300
7
Null
400
balikRekursif()
p = 200
14
400
balikRekursif()
p = 100
8
main()
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
balikRekursif()
p = 300
7
balikRekursif()
p = 200
14
balikRekursif()
p = 100
8
main()
300
400
400
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
balikRekursif()
p = 300
7
balikRekursif()
p = 200
14
balikRekursif()
p = 100
8
main()
300
400
400
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
balikRekursif()
p = 300
7
balikRekursif()
p = 200
14
Null
300
balikRekursif()
p = 100
8
300
main()
300
400
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
balikRekursif()
p = 300
7
balikRekursif()
p = 200
14
Null
300
balikRekursif()
p = 100
8
300
main()
300
400
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
balikRekursif()
p = 200
14
Null
300
balikRekursif()
p = 100
8
300
main()
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
balikRekursif()
p = 200
14
Null
300
balikRekursif()
p = 100
8
300
main()
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
balikRekursif()
p = 200
14
Null
300
balikRekursif()
p = 100
8
300
main()
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
balikRekursif()
p = 200
14
Null
300
balikRekursif()
p = 100
8
300
main()
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
balikRekursif()
p = 200
14
Null
300
balikRekursif()
p = 100
8
300
main()
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
balikRekursif()
p = 200
14
balikRekursif()
p = 100
8
main()
200
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
balikRekursif()
p = 200
14
balikRekursif()
p = 100
8
main()
200
300
300
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
balikRekursif()
p = 200
14
balikRekursif()
p = 100
8
Null
200
10
200
main()
200
300
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
balikRekursif()
p = 200
14
balikRekursif()
p = 100
8
Null
200
10
200
main()
200
300
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
14
200
300
balikRekursif()
p = 100
main()
8
Null
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
14
200
300
balikRekursif()
p = 100
main()
8
Null
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
14
200
300
balikRekursif()
p = 100
main()
8
Null
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
14
200
300
balikRekursif()
p = 100
main()
8
Null
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
14
200
300
balikRekursif()
p = 100
main()
8
Null
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
14
200
300
balikRekursif()
p = 100
main()
8
100
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
14
200
300
balikRekursif()
p = 100
main()
8
100
200
10
200
100
Stack Memory
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
14
200
300
balikRekursif()
p = 100
main()
Stack Memory
8
100
200
10
Null
100
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
sudah
dijalankan sebelumnya
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
14
200
300
balikRekursif()
p = 100
main()
Stack Memory
8
100
200
10
Null
100
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
14
200
300
8
100
200
main()
Stack Memory
10
Null
100
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
fungsi sudah dijalankan sebelumnya
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
14
200
300
8
100
200
main()
Stack Memory
10
Null
100
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
fungsi sudah dijalankan sebelumnya
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
14
200
300
8
100
200
main()
Stack Memory
10
Null
100
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
7
300
400
14
200
300
8
100
200
main()
Stack Memory
10
Null
100
Heap Memory
Prajanto Wahyu Adi, M.Kom, M.CS
Studi Kasus: Membalik List secara Rekursif
//Fungsi membalik list secara Rekursif
head = 400
void balikRekursif (Node *p){
7
if(p->next == NULL){
head = p;
return;
}
balikRekursif(p->next);
p->next->next = p;
p->next = NULL;
}
void main(){
balikRekursif(head);//head=400
}
Struktur Data
300
400
14
200
300
8
100
200
10
Null
100
Prajanto Wahyu Adi, M.Kom, M.CS
Sekian
TERIMAKASIH
Struktur Data
Prajanto Wahyu Adi, M.Kom, M.CS