Apa itu Struktur Data Queue? Pengertian, Jenis, dan Kegunaannya!

29 Oktober 2025

Apa itu Struktur Data Queue? Pengertian, Jenis, dan Kegunaannya!

Bayangkan Anda sedang berada di bank. Nasabah yang datang pertama kali pasti akan dilayani lebih dulu oleh teller, lalu diikuti oleh nasabah berikutnya secara berurutan. Atau, perhatikan bagaimana sistem print job bekerja. Dokumen yang Anda kirim ke printer pertama kali akan dicetak lebih dulu, baru kemudian dokumen dari rekan Anda. Konsep antrean yang tertib dan teratur ini bukan hanya ada di dunia nyata, tetapi juga merupakan fondasi kritis dalam ilmu komputer, yang diwujudkan dalam bentuk Struktur Data Queue.

Pemahaman mendalam tentang Struktur Data Queue adalah salah satu pilar bagi siapa saja yang ingin menjadi Software Engineer yang andal. Dalam dunia pemrograman yang kompleks, di mana ratusan ribu permintaan data harus dikelola setiap detiknya, memiliki mekanisme untuk mengatur aliran informasi secara tertib bukanlah sebuah kemewahan, melainkan kebutuhan mutlak. Artikel ini akan membedah secara tuntas segala hal dengan lengkap, mulai dari pengertian fundamental, prinsip kerja, jenis-jenisnya, hingga implementasi kodenya dalam skenario dunia nyata.

Pengertian Queue

Secara sederhana, Struktur Data Queue adalah sebuah koleksi linier dari elemen-elemen data yang operasi penyisipan (insertion) dan penghapusan (deletion)-nya dilakukan pada dua ujung yang berbeda. Konsep ini sangat ketat dan mengikuti sebuah prinsip yang telah menjadi jiwa dari struktur itu sendiri: First-In, First-Out (FIFO).

Apa artinya? Elemen data yang pertama kali dimasukkan ke dalam antrean akan menjadi elemen pertama yang dikeluarkan. Analoginya persis seperti antrean di kasir supermarket atau loket tiket. Pelanggan yang datang lebih dulu, akan dilayani lebih dulu dan juga keluar lebih dulu dari antrean.

Dalam konteks teknis, ujung antrean tempat penghapusan elemen terjadi disebut front atau head. Di sinilah elemen yang akan "dilayani" berikutnya berada. Sebaliknya, ujung tempat penyisipan elemen baru disebut rear atau tail. Dua operasi dasar yang mendefinisikannya adalah:

Enqueue: Proses menambahkan sebuah elemen ke dalam antrean pada posisi rear. Jika antrean penuh, operasi ini akan menghasilkan kondisi yang disebut overflow.
Dequeue: Proses menghapus sebuah elemen dari antrean pada posisi front. Jika antrean kosong, operasi ini akan menghasilkan kondisi underflow.

Operasi tambahan lain yang umumnya ada untuk mendukung fungsi utama adalah isEmpty (memeriksa apakah antrean kosong), isFull (memeriksa apakah antrean sudah penuh, terutama pada implementasi array statis), dan peek atau front (melihat elemen di front tanpa menghapusnya).

Mengulik Prinsip FIFO pada Queue

Prinsip FIFO adalah napas dari Struktur Data Queue. Prinsip inilah yang membedakannya dengan saudara dekatnya, Stack, yang menganut prinsip LIFO (Last-In, First-Out). Dalam FIFO, urutan kedatangan adalah segalanya. Ini menjamin keadilan dan keterprediksian, yang merupakan hal krusial dalam banyak sistem.

Mari kita lihat ilustrasinya:

Operasi:         Status Antrean (dari Front ke Rear):   Keterangan:
---------------------------------------------------------------------
-                 [ ]                                    Antrean Kosong
enqueue(A)        [A]                                    A masuk, jadi front & rear.
enqueue(B)        [A, B]                                 B masuk, menempati rear.
enqueue(C)        [A, B, C]                              C masuk, menempati rear.
dequeue()         [B, C]                                 A (yang pertama masuk) keluar. B menjadi front baru.
enqueue(D)        [B, C, D]                              D masuk, menempati rear.
dequeue()         [C, D]                                 B keluar. C menjadi front baru.

Dari ilustrasi di atas, terlihat jelas bagaimana elemen A, yang pertama masuk, juga menjadi yang pertama keluar. Setelah A keluar, B yang menjadi "yang tertua" dalam antrean kemudian dikeluarkan. Keteraturan ini adalah kekuatan utama.

Fungsi dan Kegunaan Queue: Pahlawan di Balik Layar

Mengapa Struktur Data Queue begitu vital? Fungsinya jauh lebih dari sekadar mengatur data secara abstrak. Ia adalah pahlawan tanpa tanda jasa yang bekerja di balik layar untuk memastikan aplikasi dan sistem yang kita gunakan sehari-hari berjalan mulus. Berikut adalah beberapa kegunaannya yang paling umum:

Manajemen Proses dalam Sistem Operasi: Sistem operasi modern harus menangani puluhan bahkan ratusan proses secara bersamaan. CPU (Central Processing Unit) tidak bisa menjalankan semua proses dalam waktu yang benar-benar bersamaan. Proses-proses yang siap dijalankan, tetapi menunggu giliran untuk mendapatkan waktu CPU, ditempatkan dalam sebuah antrean yang disebut Ready Queue. Penjadwal (scheduler) CPU akan mengambil proses dari depan antrean ini untuk dieksekusi.
Resource Sharing dan Buffering: Dalam sistem dimana terdapat ketidaksesuaian kecepatan antara produsen (producer) dan konsumen (consumer) data, queue bertindak sebagai buffer. Misalnya, dalam pemutar video (streaming). Data video diterima dari jaringan (produsen) dengan kecepatan yang fluktuatif, sementara pemutar video (konsumen) membutuhkan data dengan kecepatan konstan. Data yang sudah diterima tetapi belum diputar akan disimpan dalam sebuah antrean buffer. Pemutar video akan mengambil data frame-by-frame dari antrean ini, memastikan video berjalan mulus tanpa henti meskipun jaringan sedang lambat.
Handling Interrupts: Ketika perangkat keras (seperti keyboard, mouse, atau disk) membutuhkan perhatian dari CPU, mereka akan mengirimkan sinyal interrupt. Karena interrupt bisa datang secara bersamaan, sistem operasi akan menempatkannya dalam Interrupt Queue untuk ditangani satu per satu sesuai prioritas dan urutan kedatangannya.
Antrean Pesan (Message Queue) dalam Aplikasi Terdistribusi: Dalam arsitektur mikroservis atau aplikasi terdistribusi, layanan satu dan lainnya tidak selalu terhubung langsung. Message Queue (seperti RabbitMQ, Apache Kafka) bertindak sebagai perantara yang andal. Layanan pengirim (producer) akan menaruh pesan ke dalam antrean, dan layanan penerima (consumer) akan mengambil pesan tersebut ketika sudah siap. Ini memungkinkan sistem tetap resilien meskipun satu layanan sedang down.
Algoritma Breadth-First Search (BFS): Dalam ilmu graf dan pohon, algoritma BFS digunakan untuk menjelajahi semua node secara menyeluruh. Algoritma ini secara natural menggunakan struktur ini. Ia mulai dari node akar, mengunjunginya, lalu memasukkan semua tetangganya ke dalam antrean. Selanjutnya, algoritma akan mengambil node dari depan antrean, mengunjunginya, dan memasukkan tetangganya yang belum dikunjungi ke belakang antrean. Proses ini berulang hingga semua node terjangkau.
Simulasi dan Pemodelan Dunia Nyata: Antrean sangat cocok untuk memodelkan sistem layanan seperti call center, jaringan tol, atau antrean di bandara. Simulasi ini membantu analis untuk menganalisis kemacetan, mengoptimalkan jumlah sumber daya (seperti teller atau agen), dan meningkatkan efisiensi sistem secara keseluruhan.

Jenis-Jenis Queue

Seiring berkembangnya kebutuhan, tidak hanya terpaku pada bentuk linear sederhana. Berikut adalah jenis-jenis queue yang dikategorikan berdasarkan cara implementasi dan perilakunya.

A. Berdasarkan Implementasinya

Linear Queue (Antrean Linear Sederhana) Ini adalah bentuk paling dasar dari queue. Elemen-elemen disusun dalam sebuah barisan linear, dengan front dan rear yang bergerak seiring operasi enqueue dan dequeue. Masalah utama dengan linear queue sederhana (terutama dalam implementasi array statis) adalah "kebocoran memori". Saat kita melakukan dequeue, posisi front akan bergeser ke kanan. Posisi di sebelah kiri front yang sudah dikosongkan tidak dapat digunakan lagi, seolah-olah memori tersebut terbuang. Hal ini membuat antrean seolah-olah penuh meskipun sebenarnya ada slot kosong di depannya.
Circular Queue (Antrean Melingkar) Circular Queue adalah solusi sempurna untuk masalah pada linear queue. Bayangkan array-nya disambung ujung-ujungnya membentuk sebuah lingkaran. Ketika rear mencapai indeks terakhir array, pada operasi enqueue berikutnya, rear akan "melompat" kembali ke indeks 0 (jika slotnya kosong). Begitu pula dengan front.
- Cara Kerja:
  - Inisialisasi: front = rear = -1
  - enqueue: rear = (rear + 1) % size (modulo digunakan untuk perputaran)
  - dequeue: front = (front + 1) % size
- Kondisi Antrean Penuh: (rear + 1) % size == front
- Kondisi Antrean Kosong: front == -1 atau front == rear Circular Queue jauh lebih efisien dalam penggunaan memori dan banyak digunakan dalam sistem real-time.
Priority Queue (Antrean Berprioritas) Meski disebut "queue", prinsipnya sedikit menyimpang dari FIFO. Dalam Priority Queue, setiap elemen memiliki nilai prioritas yang melekat. Elemen dengan prioritas tertinggi (bisa nilai terbesar atau terkecil, tergantung implementasi) akan dikeluarkan terlebih dahulu, terlepas dari kapan ia dimasukkan. Jika dua elemen memiliki prioritas yang sama, barulah prinsip FIFO diterapkan.
- Contoh Penerapan:
  - Task Scheduler dalam sistem operasi yang memberi prioritas lebih tinggi untuk proses sistem kritis.
  - Sistem gawat darurat rumah sakit, dimana pasien dengan kondisi kritis dilayani terlebih dahulu.
  - Algoritma Dijkstra untuk mencari jalur terpendek.
- Implementasi: Biasanya diimplementasikan menggunakan struktur data Heap (Min-Heap atau Max-Heap) karena efisiensinya dalam menambah dan menghapus elemen.
Double-Ended Queue (Deque - "Deck") Deque memberikan fleksibilitas yang lebih besar. Elemen dapat ditambahkan (enqueue) atau dihapus (dequeue) dari kedua ujung, baik dari front maupun rear. Ini seperti kombinasi antara stack dan queue.
- Jenis Deque:
  - Input-Restricted Deque: Penambahan hanya boleh dari satu ujung (biasanya rear), tetapi penghapusan bisa dari kedua ujung.
  - Output-Restricted Deque: Penghapusan hanya boleh dari satu ujung (biasanya front), tetapi penambahan bisa dari kedua ujung.
- Contoh Penerapan:
  - Algoritma undo-redo dalam aplikasi teks. Operasi terbaru bisa di-undo (diambil dari satu ujung), dan jika tidak ada operasi baru, bisa di-redo (diambil dari ujung lainnya).
  - Menghapus cache yang paling lama (front) dan paling baru (rear).

Keuntungan dan Keterbatasan Queue

Seperti semua alat, queue memiliki kelebihan dan kekurangan yang perlu dipertimbangkan.

Keuntungan:

Keteraturan dan Keadilan: Prinsip FIFO menjamin bahwa permintaan atau data yang datang pertama akan diproses pertama, yang merupakan model yang adil dan mudah diprediksi.
Decoupling Sistem: Seperti pada Message Queue, produsen dan konsumen data tidak perlu berjalan pada waktu yang sama atau saling mengetahui satu sama lain. Ini meningkatkan scalability dan reliability sistem.
Pengelolaan Aliran Data: Sangat efektif untuk situasi dimana laju produksi data dan konsumsi data tidak seimbang, bertindak sebagai buffer yang menstabilkan sistem.
Efisiensi Operasi Dasar: Operasi enqueue dan dequeue pada implementasi yang ideal (menggunakan linked list atau circular array) memiliki kompleksitas waktu O(1), artinya sangat cepat.

Keterbatasan:

Akses Terbatas: Queue tidak dirancang untuk mengakses data di tengah-tengah. Mencari sebuah elemen tertentu membutuhkan proses dequeue satu per satu hingga elemen tersebut ditemukan, yang sangat tidak efisien (O(n)).
Konsumsi Memori: Queue membutuhkan alokasi memori yang sudah ditentukan (untuk array) atau overhead untuk pointer (untuk linked list). Pada bounded queue (ukuran tetap), bisa terjadi overflow.
Tidak Selalu Cocok: Untuk skenario yang membutuhkan pemrosesan berdasarkan prioritas atau yang membutuhkan akses ke data terbaru (seperti riwayat browser), Stack atau Priority Queue adalah pilihan yang lebih baik.

Implementasi dan Contoh Penggunaan dalam Kode

Mari kita lihat bagaimana implementasi dalam kode. Kita akan menggunakan Python untuk contohnya karena sintaksnya yang mudah dipahami.

1. Implementasi Linear Queue Menggunakan List (Sederhana)

class LinearQueue:
    def __init__(self):
        self.items = []

    def is_empty(self):
        return len(self.items) == 0

    def enqueue(self, item):
        # Menambahkan item ke belakang (rear) antrean
        self.items.append(item)
        print(f"'{item}' telah ditambahkan ke antrean.")

    def dequeue(self):
        if self.is_empty():
            return "Antrean kosong, tidak bisa menghapus."
        # Menghapus dan mengembalikan item dari depan (front) antrean
        removed_item = self.items.pop(0)
        print(f"'{removed_item}' telah dikeluarkan dari antrean.")
        return removed_item

    def peek(self):
        if self.is_empty():
            return "Antrean kosong."
        return f"Elemen berikutnya: {self.items[0]}"

    def size(self):
        return len(self.items)

    def display(self):
        if self.is_empty():
            print("Antrean kosong.")
        else:
            print("Antrean saat ini:", self.items)

# Contoh Simulasi: Antrean Cetak Dokumen
print("=== SIMULASI ANTREAN CETAK DOKUMEN ===")
print_queue = LinearQueue()

print_queue.enqueue("Laporan_Keuangan.pdf")
print_queue.enqueue("Skripsi_Bab1.doc")
print_queue.enqueue("Foto_Keluarga.jpg")

print_queue.display()
print(print_queue.peek())

print_queue.dequeue()
print_queue.display()

print_queue.enqueue("Presentasi.pptx")
print_queue.display()

Keluaran:

=== SIMULASI ANTREAN CETAK DOKUMEN ===
'Laporan_Keuangan.pdf' telah ditambahkan ke antrean.
'Skripsi_Bab1.doc' telah ditambahkan ke antrean.
'Foto_Keluarga.jpg' telah ditambahkan ke antrean.
Antrean saat ini: ['Laporan_Keuangan.pdf', 'Skripsi_Bab1.doc', 'Foto_Keluarga.jpg']
Elemen berikutnya: Laporan_Keuangan.pdf
'Laporan_Keuangan.pdf' telah dikeluarkan dari antrean.
Antrean saat ini: ['Skripsi_Bab1.doc', 'Foto_Keluarga.jpg']
'Presentasi.pptx' telah ditambahkan ke antrean.
Antrean saat ini: ['Skripsi_Bab1.doc', 'Foto_Keluarga.jpg', 'Presentasi.pptx']

2. Implementasi Circular Queue Menggunakan List

class CircularQueue:
    def __init__(self, capacity):
        self.capacity = capacity
        self.queue = [None] * capacity
        self.front = -1
        self.rear = -1

    def is_empty(self):
        return self.front == -1

    def is_full(self):
        return (self.rear + 1) % self.capacity == self.front

    def enqueue(self, item):
        if self.is_full():
            print("Antrean penuh! Tidak bisa menambahkan", item)
            return False
        elif self.is_empty():
            self.front = 0
            self.rear = 0
        else:
            self.rear = (self.rear + 1) % self.capacity

        self.queue[self.rear] = item
        print(f"'{item}' telah ditambahkan ke antrean (Front: {self.front}, Rear: {self.rear}).")
        return True

    def dequeue(self):
        if self.is_empty():
            print("Antrean kosong!")
            return None
        item = self.queue[self.front]
        # Jika hanya剩 satu elemen
        if self.front == self.rear:
            self.front = -1
            self.rear = -1
        else:
            self.front = (self.front + 1) % self.capacity
        print(f"'{item}' telah dikeluarkan dari antrean (Front: {self.front}, Rear: {self.rear}).")
        return item

    def display(self):
        if self.is_empty():
            print("Antrean kosong.")
        else:
            print("Antrean saat ini:", end=" ")
            i = self.front
            while True:
                print(self.queue[i], end=" ")
                if i == self.rear:
                    break
                i = (i + 1) % self.capacity
            print()

# Contoh Simulasi: Buffer Data dengan Ukuran Terbatas
print("\n=== SIMULASI CIRCULAR QUEUE BUFFER ===")
buffer = CircularQueue(3) # Buffer hanya muat 3 elemen

buffer.enqueue("Data_Packet_1")
buffer.enqueue("Data_Packet_2")
buffer.enqueue("Data_Packet_3")
buffer.enqueue("Data_Packet_4") # Akan ditolak karena penuh

buffer.display()

buffer.dequeue()
buffer.enqueue("Data_Packet_4") # Sekarang bisa masuk
buffer.display()

buffer.dequeue()
buffer.dequeue()
buffer.dequeue() # Sekarang kosong
buffer.dequeue() # Akan menampilkan "Antrean kosong!"

Keluaran:

=== SIMULASI CIRCULAR QUEUE BUFFER ===
'Data_Packet_1' telah ditambahkan ke antrean (Front: 0, Rear: 0).
'Data_Packet_2' telah ditambahkan ke antrean (Front: 0, Rear: 1).
'Data_Packet_3' telah ditambahkan ke antrean (Front: 0, Rear: 2).
Antrean penuh! Tidak bisa menambahkan Data_Packet_4
Antrean saat ini: Data_Packet_1 Data_Packet_2 Data_Packet_3
'Data_Packet_1' telah dikeluarkan dari antrean (Front: 1, Rear: 2).
'Data_Packet_4' telah ditambahkan ke antrean (Front: 1, Rear: 0).
Antrean saat ini: Data_Packet_2 Data_Packet_3 Data_Packet_4
'Data_Packet_2' telah dikeluarkan dari antrean (Front: 2, Rear: 0).
'Data_Packet_3' telah dikeluarkan dari antrean (Front: 0, Rear: 0).
'Data_Packet_4' telah dikeluarkan dari antrean (Front: -1, Rear: -1).
Antrean kosong!

Dari pembahasan yang panjang dan mendalam ini, dapat kita simpulkan bahwa pemahaman tentang Struktur Data Queue bukanlah sekadar teori akademis belaka, melainkan sebuah pengetahuan praktis yang langsung dapat diaplikasikan untuk menyelesaikan masalah dunia nyata. Konsep FIFO yang menjadi jiwanya menjadikannya alat yang ampuh untuk menciptakan keteraturan, keadilan, dan efisiensi dalam sistem komputasi. Mulai dari mengatur tugas prosesor, menjadi buffer dalam streaming, hingga menjadi tulang punggung algoritma graf seperti BFS, perannya tidak bisa dipandang sebelah mata. Dengan mempelajari berbagai jenisnya—mulai dari Linear dan Circular Queue yang efisien, Priority Queue yang cerdas, hingga Deque yang fleksibel—kita memiliki lebih banyak alat dan perspektif untuk memilih solusi yang paling tepat bagi setiap permasalahan yang kita hadapi. Meski memiliki keterbatasan dalam hal pencarian, kelebihan-kelebihan utamanya dalam mengelola aliran data membuatnya tetap menjadi pilihan yang tak tergantikan.

Memahami Struktur Data Queue hanyalah satu langkah kecil dalam perjalanan panjang menjadi seorang Software Engineer yang kompeten. Masih banyak konsep fundamental dan teknologi kekinian lainnya yang perlu kamu kuasai, seperti algoritma, database, framework back-end dan front-end, hingga deployment aplikasi.

Jika kamu serius ingin mentransformasi hobimu dalam coding menjadi karir yang menjanjikan, atau bahkan menciptakan aplikasi bisnismu sendiri, kamu membutuhkan roadmap yang terstruktur.

Codepolitan menyediakan Kelas Fullstack Web Developer yang dirancang khusus untuk membawamu dari nol hingga siap berkarya. Kelas online ini akan memandu kamu langkah demi langkah untuk menguasai semua skill yang dibutuhkan industri, seperti:

Fundamental Pemrograman (HTML, CSS, JavaScript, dan termasuk Struktur Data & Algoritma).
Pengembangan Back-end (Node.js, Python, PHP, atau lainnya).
Pengembangan Front-end (React, Vue.js, atau lainnya).
Manajemen Database (SQL & NoSQL).
Version Control (Git).

Dengan mengikuti kelas ini, kamu tidak hanya sekadar belajar teori, tetapi juga akan mengerjakan project-project nyata yang akan memperkaya portofoliomu. Raih peluang karir dengan gaji tinggi di perusahaan ternama atau wujudkan ide bisnis onlinemu sendiri.

Referensi