Big O Notation: Panduan Paling Jelas untuk Developer yang Tidak dari CS

Kamu tidak perlu gelar Computer Science untuk memahami Big O. Yang kamu butuhkan adalah intuisi tentang "bagaimana kode ini berperilaku kalau datanya 10x lebih banyak?"

Intuisi Dasar: Bukan Kecepatan, tapi Pertumbuhan

Big O bukan mengukur seberapa cepat kode berjalan dalam detik — itu tergantung hardware. Big O mengukur bagaimana waktu eksekusi tumbuh seiring bertambahnya input (n).

O(1) — Konstan: Tidak Peduli Seberapa Besar Data

function getFirstItem(arr) {
  return arr[0]; // Selalu 1 operasi, array 10 atau 10 juta item = sama
}

const myMap = new Map();
myMap.get("key"); // Lookup Map/Object: O(1)

Analogi: Ambil buku dari meja — tidak peduli rak buku di sampingmu sebesar apa.

O(n) — Linear: Tumbuh Proporsional dengan Data

function findItem(arr, target) {
  for (let item of arr) {  // Cek satu per satu
    if (item === target) return item;
  }
}
// 10 item: maks 10 cek. 10.000 item: maks 10.000 cek.

Analogi: Cari nama di daftar yang tidak diurutkan — harus baca satu per satu.

O(n²) — Quadratic: Ini yang Berbahaya

function findDuplicates(arr) {
  for (let i = 0; i < arr.length; i++) {
    for (let j = i + 1; j < arr.length; j++) { // Loop di dalam loop
      if (arr[i] === arr[j]) console.log("Duplikat:", arr[i]);
    }
  }
}
// 100 item: ~5.000 operasi
// 1.000 item: ~500.000 operasi
// 10.000 item: ~50.000.000 operasi — ini lambat!

Fix ke O(n) dengan Set:

function findDuplicatesFast(arr) {
  const seen = new Set();
  for (let item of arr) {
    if (seen.has(item)) console.log("Duplikat:", item);
    seen.add(item);
  }
} // Hanya satu loop: O(n)

O(log n) — Logaritmik: Sangat Efisien

Binary search: setiap langkah membuang setengah data yang tersisa.

// Array HARUS terurut
function binarySearch(arr, target) {
  let left = 0, right = arr.length - 1;
  while (left <= right) {
    const mid = Math.floor((left + right) / 2);
    if (arr[mid] === target) return mid;
    if (arr[mid] < target) left = mid + 1;
    else right = mid - 1;
  }
  return -1;
}
// 1.000.000 item: cukup ~20 langkah!

Cheat Sheet Praktis

Kapan Ini Penting dalam Kerja Nyata?

Kalau data kamu kecil (di bawah 1000 item), perbedaan O(n) vs O(n²) hampir tidak terasa. Tapi kalau kamu proses ribuan transaksi, jutaan record, atau real-time data streaming — pilihan algoritma yang tepat bisa berarti perbedaan antara sistem yang responsif dan sistem yang crash.