MAKALAH

SUBPROGRAM DAN REKURSI

DISUSUN OLEH:
 ARKAN MUNTAZARI

Dosen pembimbing:
ILAL MAHDI , ST.MT

UNIVERSITAS JABAL GHAFUR SIGLI

FAKULTAS TEKNIK
TEKNIK INFORMATIKA
2023/2024
 Daftar Isi
Kata Pengantar...........................................................................................................

BAB I Pendahuluan...................................................................................................

1.1 Latar Belakang ...................................................................................................

1.2 Tujuan Penulisan ................................................................................................

BAB II Pembahasan ................................................................................................

2.1 Struktur Data........................................................................................................

- Pengertian Struktur Data .........................................................................................

- Jenis-jenis Struktur Data .........................................................................................

- Array........................................................................................................................

- Linked List...............................................................................................................

- Stack ........................................................................................................................

- Queue ......................................................................................................................

- Tree ........................................................................................................................

- Graph ......................................................................................................................

- Contoh Penggunaan Struktur Data dalam Perangkat Lunak...................................

2.2 Subprogram..........................................................................................................

- Definisi Subprogram ..............................................................................................

- Fungsi dan Prosedur................................................................................................

- Contoh Penggunaan Subprogram dalam Perangkat Lunak.....................................

2.3 Rekursi................................................................................................................

- Pengertian Rekursi...................................................................................................

- Keuntungan dan Kerugian Rekursi ........................................................................

- Contoh Kasus Penggunaan Rekursi dalam Algoritma.............................................

2.4 Hubungan Antar Topik........................................................................................

- Implementasi Struktur Data dalam Subprogram.....................................................

- Penggunaan Rekursi dalam Struktur Data...............................................................

- Contoh Implementasi Gabungan dari Struktur Data, Subprogram, dan Rekursi.....

BAB III Penutupan ...................................................................................................

7. Kesimpulan............................................................................................................

Kata Pengantar

Pengembangan perangkat lunak merupakan bidang yang dinamis dan terus

berkembang dengan cepat. Dalam upaya untuk menciptakan aplikasi yang efisien,
dapat dipercaya, dan mudah dipelihara, pengembang perangkat lunak dituntut untuk
memahami dan mengimplementasikan berbagai konsep dan teknik yang kompleks. Di
antara konsep-konsep ini, struktur data, subprogram, dan rekursi memainkan peran
yang krusial dalam membangun fondasi yang kokoh bagi pembangunan perangkat
lunak yang sukses.

Makalah ini bertujuan untuk menyelidiki konsep-konsep tersebut secara lebih

mendalam, memberikan pemahaman yang kuat tentang prinsip-prinsip dasar,
kegunaan, dan implementasi dalam konteks pengembangan perangkat lunak. Melalui
penjelasan yang jelas, contoh-contoh konkret, dan panduan praktis, kami berharap
makalah ini dapat memberikan kontribusi yang berarti bagi pembaca, baik bagi
mereka yang baru dalam dunia pemrograman maupun yang telah berpengalaman.

Kami ingin mengucapkan terima kasih kepada semua yang telah memberikan
dukungan dan inspirasi dalam penyusunan makalah ini. Semoga makalah ini dapat
menjadi sumber pengetahuan yang berguna dan bermanfaat bagi para pembaca. Kritik
dan saran untuk perbaikan selalu kami terima dengan tangan terbuka.

Terima kasih.

Penulis

BAB I
 Pendahuluan

1.1 Latar belakang

Dalam era teknologi informasi yang terus berkembang,

pengembangan perangkat lunak menjadi semakin kompleks dan menuntut.
Para pengembang perangkat lunak dihadapkan pada berbagai tantangan,
termasuk kebutuhan untuk mengelola dan memanipulasi data dengan
efisien, merancang subprogram yang dapat digunakan ulang, serta
menerapkan teknik rekursi untuk menyelesaikan masalah dengan lebih
elegan.

Dalam konteks ini, pemahaman yang kuat tentang struktur data,

subprogram, dan rekursi menjadi sangat penting. Struktur data
menyediakan kerangka kerja untuk menyimpan dan mengorganisir data
dengan efisien, sementara subprogram memungkinkan untuk
mengelompokkan kode secara logis dan memudahkan pengelolaan
kompleksitas. Di sisi lain, rekursi merupakan teknik pemrograman yang
memungkinkan pemanggilan fungsi atau prosedur dari dalam dirinya
sendiri, yang sering kali diperlukan dalam penyelesaian masalah
matematis atau algoritma tertentu.

1.2 Tujuan Penulisan

1. Memberikan pemahaman yang jelas tentang konsep dasar dan pentingnya

struktur data, subprogram, dan rekursi dalam pengembangan perangkat
modern kepada pembaca
2. Menunjukkan bagaimana konsep-konsep tersebut digunakandalam praktik
nyata melalui contoh kasus dan studi kasus yang relevan
3. Membantu pembaca untuk memahami keuntungan dan kerugian dari
penggunaan berbagai struktur data,subprogram,dan rekursi dalam
penyelesaian masalah perangkat lunak
4. Menjelaskan bagaimana struktur data
5. Menginspirasi pembaca untuk menjelajahi lebih lanjut tentang topic ini
atau bahkan melakukan penelitian lebih lanjut untuk meningkatkan
pemahaman dan penerapan konsep-konsep ini dalama konteks yang lebih
luas

BAB II
 Pembahasan

2.1 Struktur data

 Pengertian

Struktur data adalah cara untuk menyusun dan menyimpan data dalam
komputer agar dapat diakses dan dimanipulasi secara efisien. Ini melibatkan
penggunaan berbagai tipe data dan teknik penyimpanan yang disusun
dengan baik, seperti array, linked list, stack, queue, tree, dan graph.
Pemilihan struktur data yang tepat sangat penting karena dapat
memengaruhi kinerja dan kompleksitas suatu program atau algoritma.

 Jenis-jenis struktur data

1. **Array**: Kumpulan elemen dengan tipe data yang sama yang

disimpan secara berurutan dalam memori. Akses ke elemen-elemen array
dapat dilakukan dengan cepat menggunakan indeks.

2. **Linked List**: Kumpulan simpul yang terhubung di mana setiap

simpul memiliki dua bagian: data itu sendiri dan referensi ke simpul
berikutnya. Ini memungkinkan penyisipan dan penghapusan elemen dengan
cepat di tengah-tengah struktur.

3. **Stack**: Struktur data LIFO (Last-In-First-Out) di mana elemen yang

terakhir dimasukkan adalah yang pertama diambil. Operasi utamanya
adalah push (menambahkan elemen) dan pop (mengambil elemen).

4. **Queue**: Struktur data FIFO (First-In-First-Out) di mana elemen

yang pertama dimasukkan adalah yang pertama diambil. Operasi utamanya
adalah enqueue (menambahkan elemen) dan dequeue (mengambil elemen).

5. **Tree**: Struktur data hirarkis yang terdiri dari simpul-simpul yang

terhubung. Terdapat berbagai jenis pohon seperti pohon biner, pohon
pencarian biner, dan pohon merah-hitam.

6. **Graph**: Struktur data yang terdiri dari kumpulan simpul dan sisi
yang menghubungkan pasangan simpul. Graph dapat berupa directed
(berarah) atau undirected (tidak berarah), serta weighted (dengan bobot)
atau unweighted (tanpa bobot).

Setiap jenis struktur data memiliki kelebihan dan kekurangan serta

digunakan untuk tujuan yang berbeda-beda dalam pengembangan
perangkat lunak. Pemilihan struktur data yang tepat sangat penting untuk
meningkatkan kinerja dan efisiensi program.

2.2 Subprogram
 Definisi Subprogram

Subprogram, juga dikenal sebagai prosedur atau fungsi, adalah blok kode
yang memiliki fungsi tertentu dan dapat dipanggil dari bagian lain dari
program. Subprogram digunakan untuk mengelompokkan instruksi-instruksi
yang sering digunakan secara bersama-sama, mempromosikan kegunaan
kembali kode, dan membagi program menjadi bagian-bagian yang lebih
kecil dan lebih mudah dikelola. Dengan menggunakan subprogram,
pengembang dapat meningkatkan modularitas, memperbaiki pemeliharaan,
dan meningkatkan keterbacaan kode program.

 Prosedur dan fungsi

1. **Prosedur**:

- Prosedur adalah blok kode yang berisi serangkaian instruksi untuk

melakukan tugas tertentu.

- Prosedur tidak mengembalikan nilai ke pemanggilnya.

- Prosedur digunakan ketika kita hanya ingin menjalankan serangkaian

pernyataan tertentu tanpa harus menghasilkan nilai kembali.

- Contoh prosedur adalah subprogram untuk mencetak teks ke layar atau

melakukan operasi matematika tertentu.

2. **Fungsi**:

- Fungsi adalah blok kode yang juga berisi serangkaian instruksi untuk
melakukan tugas tertentu.

- Namun, fungsi mengembalikan nilai ke pemanggilnya setelah

menjalankan operasi yang ditentukan di dalamnya.

- Fungsi digunakan ketika kita perlu menghitung atau menghasilkan nilai

kembali berdasarkan masukan yang diberikan.

- Contoh fungsi adalah subprogram untuk menghitung nilai matematika

seperti penjumlahan, pengurangan, atau penentuan nilai maksimum.

 Contoh penggunaan subprogram dalam perangkat lunak

1. **Penghitungan Matematika**: Sebuah perangkat lunak kalkulator bisa

menggunakan subprogram (fungsi) untuk menjalankan operasi matematika
seperti penambahan, pengurangan, perkalian, dan pembagian. Setiap operasi
matematika tersebut dapat diimplementasikan sebagai subprogram terpisah.

2. **Pencarian**: Dalam aplikasi basis data, subprogram dapat digunakan

untuk melakukan pencarian data berdasarkan kriteria tertentu. Sebagai
 contoh, sebuah subprogram bisa dibuat untuk mencari data karyawan
berdasarkan nomor identitas karyawan.

3. **Pengolahan Gambar**: Dalam perangkat lunak pengolahan gambar,

subprogram bisa digunakan untuk menerapkan filter atau efek tertentu pada
gambar. Misalnya, sebuah subprogram dapat mengimplementasikan efek blur
atau efek grayscale pada gambar.

4. **Pengolahan Teks**: Dalam pengembangan aplikasi teks, subprogram

dapat digunakan untuk memanipulasi teks, seperti memisahkan kata-kata,
mengonversi huruf kecil menjadi huruf besar, atau menghitung jumlah kata
dalam sebuah kalimat.

5. **Manajemen File**: Dalam aplikasi manajemen file, subprogram bisa

digunakan untuk melakukan operasi-operasi seperti pembukaan, penulisan,
atau penutupan file. Contohnya, sebuah subprogram dapat dibuat untuk
membaca data dari file teks.

6. **Perhitungan Statistik**: Dalam aplikasi analisis data, subprogram dapat

digunakan untuk menghitung statistik seperti rata-rata, median, atau standar
deviasi dari sejumlah data.

Penggunaan subprogram memungkinkan untuk membagi logika program

menjadi bagian-bagian yang lebih kecil dan terkelola dengan baik,
meningkatkan kegunaan kembali kode, serta membuat kode lebih mudah
dipahami dan dikelola.

2.3 Rekursi

 Pengertian Rekursi

Rekursi adalah teknik di dalam pemrograman di mana sebuah fungsi atau

subprogram memanggil dirinya sendiri secara berulang untuk
menyelesaikan tugas atau masalah. Dalam rekursi, fungsi akan terus
memanggil dirinya sendiri dengan argumen yang lebih kecil atau berbeda
hingga mencapai kondisi dasar yang akan menghentikan pemanggilan
rekursif. Konsep ini mirip dengan konsep "Induksi Matematika", di mana
untuk menyelesaikan masalah kompleks, kita mereduksinya menjadi kasus-
kasus yang lebih sederhana dan lebih kecil. Rekursi umumnya digunakan
untuk menyelesaikan masalah matematis atau algoritma tertentu dengan
cara yang elegan dan efisien.

 Keuntungan dan kerugian Rekursi

  Keuntungan Rekursi:
1. **Kode Lebih Elegan**: Rekursi sering kali menghasilkan kode yang
lebih bersih dan lebih mudah dipahami, terutama untuk masalah-masalah
yang intrinsiknya rekursif seperti pencarian dalam struktur data bertingkat
(seperti pohon atau graf).

2. **Solusi Kompak**: Dalam beberapa kasus, rekursi dapat menghasilkan

solusi yang lebih ringkas dan sederhana dibandingkan dengan pendekatan
iteratif.

3. **Peningkatan Efisiensi**: Dalam beberapa kasus, rekursi dapat

menghasilkan algoritma yang lebih efisien secara komputasional
dibandingkan dengan pendekatan iteratif, terutama jika struktur data yang
digunakan cocok dengan pola rekursif.

4. **Mudah diimplementasikan untuk Struktur Data Rekursif**: Rekursi

sangat cocok untuk bekerja dengan struktur data rekursif seperti pohon atau
graf, karena konsepnya cocok dengan alamiahnya.

 Kerugian Rekursi:
1. **Overhead Memori**: Setiap pemanggilan rekursif akan menambahkan
frame ke dalam stack memori, yang dapat menyebabkan overhead memori
yang signifikan terutama untuk masalah dengan rekursi yang dalam atau
panjang.

2. **Kesulitan Pemahaman**: Rekursi dapat sulit dipahami bagi beberapa

pengembang, terutama mereka yang kurang berpengalaman atau tidak
terbiasa dengan konsep rekursi. Hal ini dapat menyebabkan kesalahan
dalam pemrograman dan pemecahan masalah.

3. **Kinerja**: Dalam beberapa kasus, pendekatan rekursif mungkin lebih

lambat daripada pendekatan iteratif karena overhead pemanggilan fungsi
yang berulang-ulang.

4. **Bahaya Stack Overflow**: Jika rekursi tidak terbatas atau jika

kedalaman rekursi terlalu dalam, itu dapat menyebabkan stack overflow,
yaitu kondisi di mana stack memori penuh karena terlalu banyak frame
rekursif yang tersimpan di dalamnya.

 Contoh kasus penggunaan Rekursi dalam Algoritma

1. **Faktorial**:
 Rekursi sering digunakan untuk menghitung faktorial dari suatu bilangan.
Misalnya, faktorial dari n (ditulis n!) adalah hasil perkalian dari semua
bilangan bulat positif kurang dari atau sama dengan n. Contohnya adalah:

int factorial(int n) {
if (n == 0) {
return 1;
} else {
return n * factorial(n - 1);
}
}
```

2. **Fibonacci**:
Deret Fibonacci adalah deret bilangan di mana setiap angka adalah jumlah
dari dua angka sebelumnya. Rekursi dapat digunakan untuk menghitung
nilai deret Fibonacci. Contohnya adalah:

int fibonacci(int n) {
if (n <= 1) {
return n;
} else {
return fibonacci(n - 1) + fibonacci(n - 2);
}
}
```

3. **Pencarian pada Struktur Data Rekursif**:

Misalnya, pencarian dalam pohon biner atau pohon n-ary bisa
diimplementasikan secara rekursif. Dalam pencarian biner, kita dapat
melakukan pencarian secara rekursif pada sub-pohon kiri atau kanan
tergantung pada nilai yang dicari.

4. **Pemrosesan File dan Direktori**:

Saat melakukan pemrosesan file atau direktori yang memiliki struktur
hierarkis, rekursi bisa digunakan untuk melakukan traversal (penjelajahan)
ke dalam struktur tersebut. Misalnya, kita dapat menggunakan rekursi untuk
menelusuri seluruh struktur direktori pada sistem file komputer.

5. **Penyelesaian Masalah Pembagi dan Penakluk (Divide and Conquer)**:

Algoritma yang mengikuti pola "divide and conquer" seperti pengurutan
cepat (quick sort) atau pencarian biner (binary search) sering kali
diimplementasikan secara rekursif.
2.4 Hubungan antar topik

 Contoh implementasi struktur data dalam subprogram menggunakan bahasa

pemrograman Python:

 Contoh 1: Linked List dalam Subprogram

```python
class Node:
def __init__(self, data):
self.data = data
self.next = None

class LinkedList:
def __init__(self):
self.head = None

def insert(self, data):

new_node = Node(data)
if self.head is None:
self.head = new_node
else:
current = self.head
while current.next:
current = current.next
current.next = new_node

def display(self):
current = self.head
while current:
print(current.data, end=" -> ")
current = current.next
print("None")

# Penggunaan:
ll = LinkedList()
ll.insert(1)
ll.insert(2)
ll.insert(3)
ll.display()
```
 Contoh 2: Stack dalam Subprogram

```python
class Stack:
def __init__(self):
self.items = []

def push(self, item):

self.items.append(item)

def pop(self):
if not self.is_empty():
return self.items.pop()

def is_empty(self):
return len(self.items) == 0

def peek(self):
if not self.is_empty():
return self.items[-1]

# Penggunaan:
stack = Stack()
stack.push(1)
stack.push(2)
stack.push(3)
print(stack.peek()) # Output: 3
print(stack.pop()) # Output: 3
print(stack.pop()) # Output: 2

Dalam contoh di atas, struktur data (Linked List dan Stack)

diimplementasikan dalam bentuk kelas Python, dan subprogram-
subprogramnya (seperti `insert`, `display`, `push`, `pop`, `is_empty`, `peek`)
digunakan untuk mengakses dan memanipulasi data dalam struktur tersebut.
Implementasi ini memungkinkan penggunaan yang mudah dan modular dari
struktur data tersebut dalam program Python.

 Penggunaan Rekursi dalam struktur data

Salah satu penggunaan rekursi dalam struktur data adalah untuk

melakukan traversal (penelusuran) dalam struktur data rekursif seperti
 pohon (tree). Berikut adalah contoh penggunaan rekursi untuk melakukan
traversal dalam pohon:

 Contoh: Traversal dalam Pohon (Tree) menggunakan Rekursi

```python
class TreeNode:
def __init__(self, data):
self.data = data
self.children = []

def add_child(self, child):

self.children.append(child)

def traverse_tree(node):
print(node.data)
for child in node.children:
traverse_tree(child)

# Penggunaan:
# Membangun pohon
root = TreeNode("A")
b = TreeNode("B")
c = TreeNode("C")
d = TreeNode("D")
e = TreeNode("E")
f = TreeNode("F")
g = TreeNode("G")

root.add_child(b)
root.add_child(c)
b.add_child(d)
b.add_child(e)
c.add_child(f)
c.add_child(g)

# Melakukan traversal
traverse_tree(root)
```

Dalam contoh ini, kita memiliki struktur data pohon (tree) yang terdiri dari
node-node yang saling terhubung. Kita menggunakan rekursi dalam fungsi
`traverse_tree` untuk melakukan traversal pada setiap node dalam pohon,
 dimulai dari root, kemudian rekursif menjelajahi setiap anak dari setiap
node.

Dengan menggunakan rekursi, kita dapat dengan mudah melakukan

traversal dalam struktur data rekursif seperti pohon tanpa harus menuliskan
banyak kode yang repetitif. Ini membuat implementasi lebih ringkas, mudah
dipahami, dan mudah dikelola.

 Contoh implementasi Gabungan dari struktur data,Subprogram ,dan Rekursi

Mari kita lihat contoh implementasi gabungan dari struktur data,

subprogram, dan rekursi. Dalam contoh ini, kita akan membuat sebuah
aplikasi sederhana untuk menghitung jumlah total nilai dari sebuah pohon
biner yang berisi nilai-nilai numerik. Kita akan menggunakan struktur data
pohon biner, subprogram untuk melakukan traversal rekursif dalam pohon,
dan rekursi untuk menghitung jumlah nilai secara rekursif.

```python
class TreeNode:
def __init__(self, data):
self.data = data
self.left = None
self.right = None

def insert(root, data):

if root is None:
return TreeNode(data)
else:
if data < root.data:
root.left = insert(root.left, data)
else:
root.right = insert(root.right, data)
return root

def inorder_traversal(root):
if root:
inorder_traversal(root.left)
print(root.data, end=" ")
inorder_traversal(root.right)

def sum_of_values(root):
if root is None:
return 0
return root.data + sum_of_values(root.left) + sum_of_values(root.right)
# Penggunaan:
root = None
values = [5, 3, 8, 1, 4, 7, 9]

for value in values:

root = insert(root, value)

print("Traversal in-order:")
inorder_traversal(root)
print("\nTotal sum of values:", sum_of_values(root))
```

Dalam contoh ini, kita menggunakan struktur data pohon biner untuk
menyimpan nilai-nilai. Subprogram `insert` digunakan untuk memasukkan
nilai ke dalam pohon biner. Subprogram `inorder_traversal` digunakan
untuk melakukan traversal rekursif dalam pohon biner untuk mencetak nilai
secara terurut. Subprogram `sum_of_values` digunakan untuk menghitung
jumlah total dari nilai-nilai dalam pohon secara rekursif.

Dengan menggabungkan struktur data, subprogram, dan rekursi, kita dapat

membuat aplikasi yang lebih kompleks dan efisien untuk memproses data
dalam berbagai skenario.

BAB III
Penutupan
3.1 Kesimpulan

Makalah ini membahas konsep struktur data, subprogram, dan rekursi dalam
pengembangan perangkat lunak. Struktur data adalah cara untuk menyusun dan
menyimpan data dalam komputer agar dapat diakses dan dimanipulasi secara
efisien. Contoh struktur data meliputi array, linked list, stack, queue, tree, dan
graph. Subprogram, seperti fungsi dan prosedur, adalah blok kode yang memiliki
fungsi tertentu dan dapat dipanggil dari bagian lain dari program. Rekursi adalah
teknik di mana sebuah fungsi atau subprogram memanggil dirinya sendiri secara
berulang untuk menyelesaikan tugas atau masalah.

Penggunaan struktur data, subprogram, dan rekursi dapat memperbaiki modularitas,

kegunaan kembali kode, dan efisiensi dalam pengembangan perangkat lunak.
Contoh penggunaan termasuk penghitungan matematika (seperti faktorial dan deret
Fibonacci), traversal dalam struktur data rekursif (seperti pohon), pemrosesan file,
dan algoritma pembagi dan penakluk (divide and conquer).

Dengan memahami dan mengimplementasikan konsep-konsep ini dengan benar,

pengembang perangkat lunak dapat membuat program yang lebih terstruktur,
efisien, dan mudah dipelihara. Meskipun penggunaan rekursi membutuhkan hati-
hati dalam menghindari stack overflow, penggunaannya dapat menyederhanakan
dan mempercepat solusi dalam banyak kasus.

Dalam kesimpulan, makalah ini menekankan pentingnya pemahaman yang

mendalam tentang struktur data, subprogram, dan rekursi dalam pengembangan
perangkat lunak serta menyediakan panduan dan contoh implementasi untuk
membantu pengembang dalam memahami dan mengimplementasikan konsep-
konsep tersebut dengan efektif.

Daftar Pustaka
1. Cormen, Thomas H., et al. "Introduction to Algorithms." MIT Press, 2009.
2. Carrano, Frank M., dan Timothy M. Henry. "Data Structures and Abstractions with
Java." Pearson, 2015.
3. Malik, D.S. "C++ Programming: From Problem Analysis to Program Design." Cengage
Learning, 2012.
4. Horowitz, Ellis, et al. "Fundamentals of Data Structures in C++." Silicon Press, 2014.
5. Sedgewick, Robert, dan Kevin Wayne. "Algorithms." Addison-Wesley Professional,
2011.