Implementasi Queue: Mengelola Antrian Secara Efisien

Pendahuluan

Halo teman-teman developer! Senang sekali bisa bertemu kembali di artikel kelima dalam seri struktur data kita. Pada artikel sebelumnya, kita sudah membahas teori dasar mengenai perbedaan antara Stack (LIFO) dan Queue (FIFO). Kita sudah paham bahwa dalam Queue, siapa yang datang pertama, dialah yang akan dilayani pertama kali.

Namun, mengetahui teorinya saja tentu tidak cukup bagi kita sebagai developer. Pertanyaannya adalah: Bagaimana cara kita mengimplementasikan konsep antrian ini ke dalam baris kode yang nyata? Bagaimana jika kita ingin membuat sistem manajemen antrian untuk sebuah bank seperti BCA, atau sistem antrian pesanan di aplikasi seperti Gojek atau Tokopedia?

Dalam tutorial ini, kita tidak hanya akan belajar menulis kode, tetapi kita akan membangun sebuah Sistem Antrian sederhana. Kita akan membedah operasi-operasi dasar dalam Queue, melihat perbandingannya menggunakan berbagai tipe data, hingga akhirnya menggabungkannya ke dalam sebuah proyek simulasi antrian nasabah bank. Mari kita mulai!

Operasi Dasar pada Queue

Sebelum masuk ke baris kode yang kompleks, kita harus memahami “bahasa” yang digunakan saat bekerja dengan Queue. Dalam dunia profesional, ada beberapa operasi standar yang wajib ada dalam sebuah struktur data Queue:

1. Enqueue: Menambahkan elemen baru ke bagian belakang (rear/tail) antrian.
2. Dequeue: Menghapus atau mengeluarkan elemen dari bagian depan (front/head) antrian.
3. Peek/Front: Melihat elemen yang berada di urutan paling depan tanpa menghapusnya.
4. isEmpty: Mengecek apakah antrian dalam keadaan kosong atau tidak.
5. isFull (Opsional): Mengecek apakah antrian sudah mencapai kapasitas maksimal (biasanya pada implementasi array statis).

Mari kita lihat implementasi sederhana menggunakan Python untuk memahami alur logika ini.

# Implementasi dasar operasi Queue menggunakan Python
class SimpleQueue:
    def __init__(self):
        self.queue = []

    def enqueue(self, item):
        # Menambahkan elemen ke belakang
        self.queue.append(item)
        print(f"Berhasil menambahkan: {item}")

    def dequeue(self):
        # Menghapus elemen dari depan
        if not self.is_empty():
            removed_item = self.queue.pop(0)
            print(f"Berhasil mengeluarkan: {removed_item}")
            return removed_item
        else:
            print("Antrian kosong, tidak ada yang bisa dikeluarkan.")
            return None

    def peek(self):
        # Melihat elemen terdepan
        if not self.is_empty():
            return self.queue[0]
        return None

    def is_empty(self):
        # Mengecek apakah antrian kosong
        return len(self.queue) == 0

# Simulasi penggunaan
antrian_kopi = SimpleQueue()

# Budi datang membeli kopi
antrian_kopi.enqueue("Budi")
# Siti datang menyusul
antrian_kopi.enqueue("Siti")
# Andi datang terakhir
antrian_kopi.enqueue("Andi")

print(f"Antrian saat ini: {antrian_kopi.queue}")
print(f"Orang yang sedang dilayani: {antrian_kopi.peek()}")

# Melayani Budi
antrian_kopi.dequeue()
print(f"Sisa antrian: {antrian_kopi.queue}")

Perbedaan Implementasi: Array vs Deque

Sebagai developer, kita harus kritis terhadap efisiensi kode kita. Dalam contoh di atas, saya menggunakan self.queue.pop(0). Di Python, melakukan pop(0) pada sebuah list (yang secara teknis adalah array dinamis) memiliki kompleksitas waktu O(n). Mengapa? Karena ketika elemen pertama dihapus, semua elemen di belakangnya harus “bergeser” satu posisi ke depan. Jika ada 1 juta data, maka 1 juta data tersebut harus digeser. Ini tentu sangat tidak efisien untuk aplikasi skala besar.

Untuk mengatasi hal ini, di Python kita sebaiknya menggunakan collections.deque (Double-Ended Queue). deque dirancang khusus agar operasi penambahan dan penghapusan di kedua ujung (depan maupun belakang) memiliki kompleksitas waktu O(1).

Berikut adalah perbandingan implementasi menggunakan JavaScript agar kita bisa melihat perspektif bahasa lain:

// Implementasi Queue menggunakan JavaScript modern (ES6+)
class EfficientQueue {
    constructor() {
        this.items = [];
    }

    // Menambah elemen ke belakang
    enqueue(element) {
        this.items.push(element);
    }

    // Menghapus elemen dari depan
    // Note: shift() pada array JS juga memiliki O(n) complexity
    dequeue() {
        if (this.isEmpty()) return "Antrian Kosong";
        return this.items.shift();
    }

    peek() {
        return this.isEmpty() ? "Antrian Kosong" : this.items[0];
    }

    isEmpty() {
        return this.items.length === 0;
    }

    printQueue() {
        console.log("Isi Antrian:", this.items.join(" -> "));
    }
}

// Uji coba
const antrianGojek = new EfficientQueue();
antrianGojek.enqueue("Driver A");
antrianGojek.enqueue("Driver B");
antrianMakan = antrianGojek.dequeue();

console.log(`Driver yang selesai tugas: ${antrianGojek.peek()}`);
antrianGojek.printQueue();

Implementasi dalam Proyek: Sistem Antrian Bank

Sekarang, mari kita satukan semua konsep yang telah kita pelajari ke dalam proyek utama kita: Sistem Antrian Bank. Kita akan membuat sebuah sistem yang mampu mencatat nama nasabah, memanggil nasabah, dan melihat daftar antrian yang sedang menunggu.

Kita akan menggunakan Python untuk membangun sistem ini dengan pendekatan Object-Oriented Programming (OOP).

from collections import deque
import datetime

class SistemAntrianBank:
    def __init__(self, nama_cabang):
        self.nama_cabang = nama_cabang
        self.antrian = deque()
        self.nasabah_terlayani = 0

    def tambah_nasabah(self, nama):
        """Menambahkan nasabah ke dalam antrian."""
        waktu_datang = datetime.datetime.now().strftime("%H:%M:%S")
        self.antrian.append({"nama": nama, "waktu": waktu_datang})
        print(f"[{self.nama_cabang}] Nasabah {nama} berhasil masuk antrian pada {waktu_datang}.")

    def panggil_nasabah(self):
        """Memanggil nasabah terdepan untuk dilayani."""
        if not self.antrian:
            print(f"[{self.nama_cabang}] Peringatan: Tidak ada nasabah dalam antrian!")
            return None
        
        nasabah = self.antrian.popleft()
        self.nasabah_terlayani += 1
        print(f"[{self.nama_cabang}] Memanggil: {nasabah['nama']} (Waktu Tunggu: {nasabah['waktu']})")
        return nasabah

    def lihat_antrian(self):
        """Menampilkan semua nasabah yang sedang menunggu."""
        print(f"\n--- Daftar Antrian {self.nama_cabang} ---")
        if not self.antrian:
            print("Antrian saat ini kosong.")
        else:
            for i, nasabah in enumerate(self.antrian, 1):
                print(f"{i}. {nasabah['nama']}")
        print("----------------------------------\n")

# --- Simulasi Penggunaan ---

# 1. Inisialisasi Bank
bank_mandiri = SistemAntrian("Bank Mandiri Cabang Jakarta")

# 2. Nasabah datang
bank_mandiri.tambah_nasabah("Andi")
bank_melati.tambah_nasabah("Budi")
bank_melati.tambah_nasabah("Citra")

# 3. Lihat daftar antrean
bank_mandiri.lihat_antrean()

# 4. Proses pelayanan
bank_mandiri.panggil_nasabah()
bank_mandiri.panggil_nasabah()

# 5. Lihat sisa antrean
bank_mandiri.lihat_antrean()

(Catatan: Kode di atas adalah ilustrasi logika. Pastikan Anda menyesuaikan nama variabel saat melakukan implementasi nyata).

Kesimpulan

Dalam artikel ini, kita telah belajar:

1. Konsep Dasar Queue: Menggunakan prinsip FIFO (First In, First Out).
2. Operasi Utama: Memahami enqueue, dequeue, peek, dan isEmpty.
3. Efisiensi Algoritma: Mengapa penggunaan deque lebih baik daripada list biasa untuk operasi penghapusan di depan pada Python.
4. Implementasi Nyata: Bagaimana menerapkan struktur data Queue ke dalam sebuah sistem bisnis (Bank).

Struktur data Queue adalah fondasi dari banyak teknologi modern, mulai dari antrean printer, pemrosesan pesan di RabbitMQ, hingga manajemen request pada web server seperti Nginx. Memahaminya dengan baik akan membantu Anda menulis kode yang lebih efisien dan scalable.

Sampai jumpa di artikel berikutnya! Teruslahlah mengoding!