Description

1. Pembukaan

Kompleksitas algoritma merupakan fondasi penting dalam memahami bagaimana sebuah program bekerja secara efisien ketika jumlah data terus meningkat. Dalam dunia modern yang serba terhubung, sistem Internet of Things (IoT) menjadi contoh nyata penerapan algoritma yang harus cepat, hemat daya, dan mampu menangani ribuan data sensor secara real-time.

 Contohnya kasus saya sebuah rumah pintar dengan beberapa sensor suhu yang tersebar di setiap ruangan. Sensor-sensor tersebut mengirimkan data suhu setiap detik untuk memastikan kenyamanan penghuni dan mengatur sistem pendingin secara otomatis. Jika algoritma pengolah datanya tidak efisien, maka keterlambatan proses dapat menyebabkan suhu ruangan tidak stabil atau konsumsi energi meningkat.

Portofolio ini membahas analisis efisiensi algoritma iteratif dan rekursif dalam konteks sistem monitoring suhu ruangan berbasis IoT. Analisis dilakukan melalui dua pendekatan iteratif dan rekursif divide & conquer, untuk membandingkan perbedaan kompleksitas waktu, jumlah iterasi, dan dampaknya terhadap kinerja sistem.

2. Penjelasan Algoritma dan Logika Kerja

Dalam konteks ini, dua algoritma utama digunakan untuk menghitung total kumulatif data suhu dari sensor-sensor ruangan.

a. Algoritma Iteratif (Loop Bersarang)
Pendekatan iteratif dilakukan dengan menjumlahkan data satu per satu menggunakan dua perulangan bersarang. Logikanya seperti seseorang yang menghitung suhu setiap ruangan satu per satu lalu menambahkannya ke total keseluruhan.

Pseudocode sederhana:

Struktur perulangan ganda (nested loop) membuat jumlah langkah bertambah secara kuadrat terhadap banyaknya data sensor.

b. Algoritma Rekursif (Divide & Conquer)
Pendekatan kedua menggunakan pembagian tugas menjadi dua bagian kecil, kemudian digabungkan kembali. Logikanya menyerupai server cloud yang membagi data sensor ke dua prosesor, menghitungnya secara paralel, lalu menggabungkan hasilnya.

Pendekatan ini secara alami mendukung paralelisasi dan memiliki kompleksitas waktu yang jauh lebih baik pada data besar.

3. Perhitungan Jumlah Iterasi (n = 10 dan n = 20)

Untuk memahami perbedaan kedua algoritma, perhitungan jumlah iterasi dilakukan sebagai berikut:

Algoritma Iteratif:
Loop luar berjalan n kali, sedangkan loop dalam berjalan sebanyak i kali. Total iterasi:
T(n) = 1 + 2 + 3 + ... + n = n(n + 1)/2 ≈ O(n²)

n = 10 → T(10) = 55

n = 20 → T(20) = 210

Pertambahan jumlah data dari 10 ke 20 menyebabkan iterasi meningkat hampir empat kali lipat, menunjukkan pertumbuhan kuadrat.

Algoritma Rekursif:
Struktur divide & conquer menghasilkan:
T(n) = 2T(n/2) + O(1)
→ berdasarkan Master Theorem, T(n) = Θ(n).

Untuk n = 10 dan n = 20, jumlah operasi meningkat dua kali lipat, bukan empat kali seperti iteratif.

4. Analisis Kompleksitas (Big-O, Ω, dan Θ)

a. Algoritma Iteratif (Nested Loop)

Persamaan waktu: T(n) = n(n + 1)/2

Big-O: O(n²) → pertumbuhan kuadrat

Ω(n²) → batas bawah

Θ(n²) → pertumbuhan rata-rata

b. Algoritma Rekursif (Divide & Conquer)

Persamaan waktu: T(n) = 2T(n/2) + O(1)

Big-O: O(n)

Ω(n) dan Θ(n) → pertumbuhan linear

Secara teori, rekursif jauh lebih efisien untuk data besar karena pertambahan waktu berbanding lurus dengan ukuran data.

5. Simulasi dan Visualisasi Hasil Eksekusi

a. Visualisasi Teori Kompleksitas

Untuk memperlihatkan dampak nyata dari pertumbuhan kompleksitas waktu, dilakukan simulasi perbandingan antara dua algoritma — satu efisien dengan kompleksitas O(n) dan satu brute-force dengan kompleksitas O(n²). Grafik berikut menampilkan perbandingan jumlah operasi yang dibutuhkan terhadap ukuran input (n) menggunakan skala logaritmik.

import matplotlib.pyplot as plt
import numpy as np

n = np.logspace(1, 5, num=100)
T_iteratif = n**2 / 2
T_rekursif = n

plt.figure(figsize=(8,5))
plt.loglog(n, T_iteratif, label='Iteratif O(n²)')
plt.loglog(n, T_rekursif, label='Rekursif O(n)')
plt.title('Perbandingan Kompleksitas O(n²) vs O(n)')
plt.xlabel('Ukuran Input (n)')
plt.ylabel('Waktu Eksekusi (T(n))')
plt.legend()
plt.grid(True)
plt.show()
 

Hasil Output :

Hasil grafik menunjukkan bahwa garis merah (O(n²)) tumbuh jauh lebih cepat daripada garis hijau (O(n)). Ketika nilai n mencapai 100.000, selisih waktu antara kedua algoritma menjadi sangat besar. Hal ini menegaskan pentingnya memilih algoritma dengan kompleksitas rendah untuk sistem IoT yang harus bekerja secara real-time.

b. Simulasi Data Suhu (Kasus IoT Nyata)

Simulasi berikut memperlihatkan perbedaan waktu eksekusi antara algoritma iteratif dan rekursif untuk menghitung total suhu dari sensor-sensor ruangan.

import random
import time
import matplotlib.pyplot as plt
import numpy as np

plt.style.use('seaborn-v0_8-whitegrid')
random.seed(42)

def simple_iterative_sum(data):
   total = 0
   for val in data:
       total += val
   return total

def simple_recursive_sum(data):
   n = len(data)
   if n == 0:
       return 0
   if n == 1:
       return data[0]
   tengah = n // 2
   return simple_recursive_sum(data[:tengah]) + simple_recursive_sum(data[tengah:])

n_values = np.linspace(100, 2000, 12, dtype=int)
t_iter, t_rek = [], []

for n in n_values:
   data = [random.randint(20, 35) for _ in range(n)]
   start = time.perf_counter()
   simple_iterative_sum(data)
   t_iter.append(time.perf_counter() - start)
   start = time.perf_counter()
   simple_recursive_sum(data)
   t_rek.append(time.perf_counter() - start)

fig, ax = plt.subplots(figsize=(12, 7))
ax.plot(n_values, t_iter, marker='o', linestyle='-', color='#1a759f', label='Iteratif (O(n))')
ax.plot(n_values, t_rek, marker='s', linestyle='--', color='#f28482', label='Rekursif (O(n log n) karena slicing)')

ax.set_title('Analisis Kinerja: Iteratif vs. Rekursif untuk Penjumlahan Sederhana', fontsize=16, pad=20)
ax.set_xlabel('Jumlah Data Sensor (n)', fontsize=12)
ax.set_ylabel('Waktu Eksekusi (detik)', fontsize=12)
ax.legend(title='Metode Algoritma', frameon=True, shadow=True, fontsize=11)
ax.grid(True, which='both', linestyle=':', linewidth=0.6)

ax.text(n_values[-1], t_rek[-1], '  Overhead slicing  + pemanggilan fungsi', va='center', color='#d62828')
ax.text(n_values[-1], t_iter[-1], '  Lebih cepat (linear)', va='center', color='#1a759f')

fig.tight_layout()
plt.show()
 

Hasil Output :

Hasil visualisasi menunjukkan bahwa untuk n kecil (<100), waktu eksekusi keduanya hampir sama. Namun saat data bertambah (ratusan sensor), algoritma iteratif meningkat drastis, sedangkan rekursif tetap stabil. Ini membuktikan perbedaan kompleksitas O(n²) vs O(n) secara nyata.

C. Visualisasi Tren Data Lingkungan (Multi-sensor IoT)

Selain menganalisis efisiensi algoritma, dilakukan pula simulasi visual sederhana untuk menggambarkan hasil pemantauan sensor suhu dan kelembapan dalam ruangan pintar berbasis IoT.
Simulasi ini menggunakan data hipotetik selama lima hari untuk menunjukkan stabilitas suhu dan kelembapan yang dikontrol secara otomatis oleh sistem.

Selain menganalisis efisiensi algoritma, dilakukan pula simulasi visual sederhana untuk menggambarkan hasil pemantauan sensor suhu dan kelembapan dalam ruangan pintar berbasis IoT.
Simulasi ini menggunakan data hipotetik selama lima hari untuk menunjukkan stabilitas suhu dan kelembapan yang dikontrol secara otomatis oleh sistem.

import matplotlib.pyplot as plt
import numpy as np

plt.style.use('seaborn-v0_8-whitegrid')

days = np.arange(1, 6)
temp = [22, 25, 23, 29, 30]
humidity = [60, 58, 62, 55, 53]

fig, ax = plt.subplots(figsize=(10,6))
ax.plot(days, temp, marker='o', linewidth=2.5, color='#1a759f', label='Suhu (°C)')
ax.plot(days, humidity, marker='s', linewidth=2.5, color='#52b788', label='Kelembapan (%)')

ax.set_title('Tren Data Lingkungan Ruangan IoT', fontsize=16, fontweight='bold', color='#1a3d5f')
ax.set_xlabel('Hari', fontsize=12)
ax.set_ylabel('Nilai Sensor', fontsize=12)
ax.set_xticks(days)
ax.legend(loc='upper left', frameon=False)

ax.text(5.2, 30, '95% Stabilitas Suhu', fontsize=11, color='white',
       bbox=dict(boxstyle='round,pad=0.5', fc='#1a759f', ec='none'))
ax.text(5.2, 53, '90% Kelembapan Optimal', fontsize=11, color='white',
       bbox=dict(boxstyle='round,pad=0.5', fc='#52b788', ec='none'))

plt.tight_layout()
plt.show()

hasil output :

Pada visualisasi tren lingkungan, data sintetik bertanggal digunakan untuk mensimulasikan perilaku sistem monitoring suhu dan kelembapan ruangan pintar selama lima hari. Sumbu waktu diformat ke tanggal harian agar interpretasi lebih realistis. Dua metrik utama suhu (°C) dan kelembapan (%) ditampilkan sebagai kurva terpisah dengan penandaan nilai terbaru untuk menegaskan kondisi terkini. Area berarsir menyoroti kenaikan suhu yang signifikan pada periode akhir, sedangkan kotak ringkasan di kanan atas merangkum rata-rata suhu dan rata-rata kelembapan secara otomatis. Hasil ini menunjukkan bahwa suhu cenderung meningkat di akhir periode, sementara kelembapan tetap berada dalam rentang nyaman. Visualisasi ini memperlihatkan bagaimana sistem IoT tidak hanya mengumpulkan data, tetapi juga menyajikan indikasi perubahan penting secara ringkas untuk mendukung pengambilan keputusan pengendalian lingkungan.

6. Evaluasi Algoritma dalam Kasus IoT (Iteratif vs Rekursif)

Dalam sistem monitoring suhu ruangan, setiap sensor mengirimkan data secara periodik. Berikut evaluasi dampak kedua algoritma terhadap performa sistem.

1. Waktu Respon (Latency)
Algoritma iteratif memiliki waktu respon yang lebih lama karena setiap pembaruan data menyebabkan seluruh loop berjalan ulang. Pada sistem real-time, ini bisa menimbulkan keterlambatan pengendalian suhu.
Sebaliknya, algoritma rekursif memiliki respon cepat karena setiap data hanya diproses sekali dalam struktur pohon rekursi.

2. Konsumsi Daya
Algoritma iteratif (O(n²)) membutuhkan lebih banyak langkah komputasi, sehingga meningkatkan konsumsi energi pada mikrokontroler.
Rekursif (O(n)) jauh lebih hemat karena jumlah operasi lebih sedikit dan cocok untuk perangkat dengan daya terbatas seperti ESP32.

3. Skalabilitas Sistem
Ketika jumlah sensor meningkat dari 10 ke 1000, algoritma iteratif akan kewalahan. Sedangkan rekursif dapat dibagi ke beberapa thread atau prosesor server (divide & conquer), menjadikannya highly scalable.

4. Ringkasan Perbandingan

7. Kesimpulan 

Dari hasil analisis, simulasi, dan evaluasi di atas, dapat disimpulkan bahwa:

Algoritma menentukan efisiensi sistem. Struktur loop berganda menyebabkan pertumbuhan waktu kuadrat, sementara rekursif linear jauh lebih efisien.

Pendekatan iteratif cocok untuk data kecil, tetapi tidak ideal untuk perangkat IoT yang memproses data sensor terus menerus.

Pendekatan rekursif divide & conquer unggul pada data besar, karena mendukung paralelisasi dan efisiensi daya.

Untuk sistem monitoring suhu ruangan, kombinasi algoritma linear streaming di sisi sensor dan rekursif paralel di sisi server merupakan solusi optimal.

Rekomendasi

Berdasarkan hasil analisis dan simulasi, disarankan penggunaan algoritma iteratif untuk perangkat IoT dengan daya dan kapasitas komputasi terbatas karena memiliki kompleksitas waktu linear dan lebih hemat energi. Sementara itu, algoritma rekursif lebih sesuai diterapkan pada sistem cloud dengan kemampuan paralelisasi tinggi.

Untuk pengembangan sistem di masa depan, sistem monitoring suhu dan kelembapan dapat diperluas dengan penambahan sensor seperti kualitas udara (AQI) dan intensitas cahaya, sehingga mampu memberikan gambaran lingkungan yang lebih menyeluruh. Selain itu, integrasi fitur notifikasi otomatis dan analisis prediktif berbasis algoritma efisien akan meningkatkan kemampuan sistem dalam menjaga kestabilan lingkungan secara real-time dan berkelanjutan.