Big-OAlgorithmsComplexity

Notasi Big-O untuk kode sehari-hari, dijelaskan

Ditulis oleh Harry Osmar Sitohang·Jun 2026·8 mnt

Big-O menjawab satu pertanyaan saja: kalau datanya membesar, kerjanya membesar secepat apa? Bukan soal detik di jam dinding — itu beda mesin beda hasil — tapi soal bentuk pertumbuhannya. Begitu Anda bisa membaca bentuknya, Anda bisa menebak apakah kode akan tetap mulus di data 10 baris dan di 10 juta baris hanya dengan melihatnya.

Kabar baiknya: hampir semua kode sehari-hari jatuh ke segelintir bentuk, dan tiap bentuk lahir dari pola yang gampang dikenali — if/else, satu loop, loop bersarang, rekursi, dan binary search. Mari bedah satu per satu: kodenya, grafiknya, lalu kenapa kode itu menghasilkan bentuk tersebut.

O(1) — waktu konstan

Pola: satu keputusan dengan jumlah cabang yang tetap. if/else, switch, akses array lewat indeks, baca/tulis ke hash map.

function statusBayar(order) {
  if (order.lunas) return "lunas"
  return "belum"
}

Garis datar — biaya tak ikut membesar saat n bertambah.

O(log n) — logaritmik

Pola: tiap langkah membuang separuh sisa pekerjaan. Contoh klasiknya binary search dan operasi pada balanced tree.

function cari(terurut, target) {
  let lo = 0, hi = terurut.length - 1
  while (lo <= hi) {
    const tengah = (lo + hi) >> 1
    if (terurut[tengah] === target) return tengah
    if (terurut[tengah] < target) lo = tengah + 1
    else hi = tengah - 1
  }
  return -1
}

Naik cepat di awal lalu mendatar — membuang separuh tiap langkah.

O(n) — linear

Pola: satu loop yang menyentuh tiap item tepat sekali.

function total(angka) {
  let jumlah = 0
  for (const a of angka) jumlah += a
  return jumlah
}

Garis lurus — biaya naik seiring n dengan kecepatan tetap.

O(n log n) — linearithmik

Pola: "bagi lalu satukan". Algoritma sort yang baik (merge sort, quicksort) hidup di sini.

const terurut = [...angka].sort((a, b) => a - b)
// merge sort: membelah data jadi log n tingkat,
// lalu menggabung n item di tiap tingkat

Sedikit di atas linear dan melengkung naik — bagi lalu satukan.

O(n²) — kuadratik

Pola: loop di dalam loop, memasangkan tiap item dengan tiap item lain.

function adaDuplikat(arr) {
  for (let i = 0; i < arr.length; i++)
    for (let j = i + 1; j < arr.length; j++)
      if (arr[i] === arr[j]) return true
  return false
}

Parabola — n dua kali lipat berarti kerja empat kali lipat.

O(2ⁿ) — eksponensial

Pola: rekursi yang bercabang — tiap panggilan memunculkan beberapa panggilan baru.

function fib(n) {
  if (n < 2) return n
  return fib(n - 1) + fib(n - 2)
}

Dinding — meledak nyaris tegak begitu n bertambah sedikit.

Papan peringkat

Ditumpuk berdampingan, urutannya jelas — dari yang biayanya nyaris tak bergerak sampai yang meledak:

Papan peringkat: dari yang paling murah (atas) ke yang paling mahal (bawah) saat data membesar.

Aturan praktis yang bisa langsung dipakai saat membaca kode:

Satu loop menambah faktor n.
Loop bersarang mengalikan dengan n lagi (dua tingkat → n², tiga → n³).
Membelah-dua tiap langkah membaginya jadi log n (binary search, balanced tree).
"Bagi lalu satukan" memberi n log n (sort yang baik).
Rekursi yang bercabang meledak jadi eksponensial — biasanya pertanda butuh memoisasi atau pendekatan lain.

Dan jangan lupa: O(1) menang secara asimptotik, tapi konstanta tetap penting di dunia nyata. O(log n) yang ramping bisa mengalahkan O(1) yang berat untuk semua n yang realistis. Big-O memberi tahu Anda bagaimana kode berskala, bukan persis berapa cepat ia berjalan hari ini.

Sources