Lalu, bentuk rumus atau notasinya seperti apa? Sebenarnya ada banyak, tapi untuk tahap awal kita cukup kenalan dengan tiga tingkatan yang paling sering kita temui sehari-hari saat menulis kode:

• O(1) - Constant Time: Ini kasta yang paling ngebut dan ideal. Sebanyak apa pun datanya, waktu eksekusinya tetap sama. Contoh sederhananya adalah saat kita memanggil data spesifik dalam array menggunakan indeksnya (misal: data[0]).

• O(n) - Linear Time: Waktu eksekusi berbanding lurus dengan jumlah data. Kalau datanya 10, butuh 10 langkah. Datanya 100, butuh 100 langkah. Contoh paling umum adalah ketika kita menggunakan perulangan seperti for loop atau array.map() untuk mengecek data satu per satu.

• O(n²) - Quadratic Time: Nah, ini yang sering bikin server menjerit atau antarmuka aplikasi (UI) terasa sangat berat jika datanya sudah puluhan ribu. Waktu eksekusi melonjak kuadratik seiring bertambahnya data. Penyebab utamanya biasanya adalah looping di dalam looping (nested loop).

• O(n \log n) - Linearithmic Time: Nah, ini dia "kasta" tempat bernaungnya algoritma pengurutan modern seperti Merge Sort. Tingkatannya sedikit lebih lambat dari O(n) tapi jauh lebih cepat dibandingkan O(n²). Ia mengombinasikan teknik memecah data (O(\log n)) lalu memprosesnya kembali (O(n)). Sangat tangguh untuk memproses data besar.

• O(n²) - Quadratic Time: Kalau yang ini, kasta yang sering bikin server menjerit atau antarmuka aplikasi (UI) terasa sangat berat jika datanya sudah puluhan ribu. Waktu eksekusi melonjak kuadratik seiring bertambahnya data. Penyebab utamanya biasanya adalah looping di dalam looping (nested loop), seperti pada Bubble Sort.

Bedah Kasus: Menganalisis Algoritma Sorting

Agar tidak sekadar teori, mari kita coba analisis salah satu algoritma pengurutan data (sorting) yang paling klasik, yaitu Bubble Sort.

Bayangkan kita punya array berisi angka acak dan ingin mengurutkannya dari terkecil ke terbesar. Cara kerja Bubble Sort adalah membandingkan dua angka yang bersebelahan, lalu menukarnya jika posisinya salah. Proses ini diulang terus-menerus dari awal sampai ujung array, hingga tidak ada lagi angka yang perlu ditukar.

Jika diterjemahkan ke dalam kode JavaScript/TypeScript, bentuknya akan seperti ini:

function bubbleSort(arr) {
  for (let i = 0; i < arr.length; i++) { // Looping pertama berjalan sebanyak n kali
    for (let j = 0; j < arr.length - i - 1; j++) { // Looping kedua berjalan di dalam looping pertama
      if (arr[j] > arr[j + 1]) {
        // Tukar posisi data
        let temp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = temp;
      }
    }
  }
  return arr;
}

Bagaimana cara kita membaca Big O dari fungsi di atas? Karena terdapat looping kedua yang berjalan di dalam looping pertama, maka operasi perbandingannya akan dieksekusi kira-kira sebanyak n * n. Hasilnya adalah n². Maka, time complexity dari algoritma Bubble Sort ini adalah O(n²).

Eksperimen 30.000 Data Acak

Agar tidak sekadar membayangkan rumus matematika, mari kita bawa konsep ini ke dunia nyata.

Katakanlah kita sedang membangun fitur web dan mendapat tugas untuk mengurutkan 30.000 data pengguna yang susunannya acak. Kita akan membandingkan algoritma Bubble Sort dengan algoritma yang lebih modern seperti Merge Sort untuk melihat seberapa besar dampaknya terhadap sistem.

1. Bubble Sort
1. Time Complexity: O(n²) Karena rumusnya kuadratik, untuk 30.000 data, jumlah operasi maksimum yang harus dilakukan prosesor adalah 30.000 pangkat 2, yaitu sekitar 900.000.000 (900 juta) operasi! Jika dieksekusi di thread utama, proses ini akan memblokir sistem hingga bermenit-menit. Bayangkan user harus menatap layar loading selama itu.
2. Space Complexity: O(1) Sisi positifnya, Bubble Sort melakukan pengurutan langsung di dalam array tersebut (in-place). Ia hanya butuh tambahan memori ekstra untuk satu variabel sementara (temp) saat menukar posisi data. Jadi, seberapa pun besarnya data, konsumsi memori (RAM) tidak akan membengkak.
2. Merge Sort
   Bagaimana jika kita menggunakan Merge Sort yang memiliki Time Complexity O(n log n)?
1. Time Complexity: O(n log n) Algoritma ini menggunakan pendekatan divide and conquer (memecah belah data sebelum mengurutkannya). Dengan data sebanyak 30.000, jumlah operasinya kira-kira adalah 30.000 dikali log₂(30.000). Nilai log₂(30.000) itu sekitar 15. Jadi, total operasinya hanya 30.000 * 15 = 450.000 operasi. Coba bandingkan: 900 juta operasi vs 450 ribu operasi. Dengan Merge Sort, sistem bisa menyelesaikannya dalam hitungan milidetik tanpa membuat aplikasi hang.
2. Space Complexity: O(n) Namun, selalu ada harga yang harus dibayar. Merge Sort membutuhkan array tambahan saat memecah dan menggabungkan data. Artinya, untuk memproses 30.000 data, sistem harus mengalokasikan ruang memori ekstra yang sebanding dengan jumlah 30.000 data tersebut.

Kesimpulan: Menemukan Titik Tengah (Trade-off)