Queue adalah struktur data yang mengikuti prinsip FIFO — First In, First Out. Elemen pertama masuk adalah yang pertama keluar.

Analogi: Antrian di kasir — yang datang duluan dilayani duluan.

Operasi utama:

class Queue {
  constructor() {
    this.items = {};
    this.head = 0;
    this.tail = 0;
  }

  enqueue(item) {
    this.items[this.tail] = item;
    this.tail++;
  }

  dequeue() {
    if (this.isEmpty()) return undefined;
    const item = this.items[this.head];
    delete this.items[this.head];
    this.head++;
    return item;
  }

  front() {
    return this.items[this.head];
  }

  isEmpty() {
    return this.tail - this.head === 0;
  }
}

const q = new Queue();
q.enqueue("A"); // [A]
q.enqueue("B"); // [A, B]
q.enqueue("C"); // [A, B, C]
q.dequeue();    // "A" → [B, C]
q.front();      // "B"

Catatan: Implementasi di atas menggunakan object dan pointer (head/tail) agar dequeue tetap O(1). Jika pakai array.shift(), hasilnya O(n) karena semua elemen harus digeser.

Kegunaan nyata:

• Task queue — antrian pekerjaan (print queue, job queue)
• BFS (Breadth-First Search) pada graph/tree
• Message queue — sistem chat, notifikasi
• Rate limiting — kontrol antrian request

💡 Kenapa harus pakai pointer (head/tail), bukan arr.shift()? arr.shift() itu O(n) — semua elemen harus geser index ke kiri. Loop 1jt dequeue dengan shift = 1jt × geser n elemen = O(n²). Pakai pointer = O(1) per operasi. Beda performa jauh saat data besar.

🎭 Analogi sehari-hari (selain antrian kasir):

• Pesan WhatsApp yang dibalas urut masuk
• Antrian print di kantor
• Buffer streaming — frame video diproses urut datangnya

⚠️ Jebakan umum:

• Memory leak di Queue object-based: jika tidak delete this.items[head], memori tetap dipegang walau head naik. Jangan lupa hapus
• Array.shift() jebakan klasik: banyak yang nulis Queue pakai array.push + array.shift, lalu heran kok lambat saat data besar
• BFS lupa visited set: queue terus diisi node yang sama = infinite loop

🎯 Kapan pakai Queue?

• Tugas harus diproses urut datang (fairness)
• BFS — eksplorasi level-by-level di graph/tree
• Producer-consumer — satu sisi nambah, sisi lain ngambil
• Buffer sementara sebelum diproses batch

🧪 Tebakan cepat: Enqueue 1,2,3 lalu dequeue dequeue — outputnya? 1, 2. Sama dengan urutan masuk.

TL;DR: Queue = FIFO. Push belakang, pop depan. Pakai pointer (bukan shift) supaya O(1). Cocok untuk antrian, BFS, dan task processing fair-order.