Halo-halo teman-teman semuanya kembali lagi diblok saya. Perkenalkan nama saya Cahyo Adi Nugroho mahasiswa teknologi informasi Universitas Tidar. Disini saya akan menjelaskan laporan praktikum struktur data tentang queue (antrean). Pada praktikum ini saya akan menjelaskan apa itu queue, operasi apa saja yang ada pada queue, dan cara penerapan queue.

Queue

Queue (antrean) adalah salah satu jenis struktur data linier, disebut linier karena elemen-elemen di dalamnya disusun secara berurutan, di mana setiap elemen terhubung dengan elemen sebelum dan sesudahnya. Queue biasa disebut dengan antean karena kumpulan data ini menganut prinsip FIFO (First in First out) yaitu elemen yang pertama masuk akan menjadi elemen yang pertama keluar sama seperti konsep antrean pada kehidupan nyata.

Operasi pada Queue

Operasi pada Queue digunakan untuk menambahkan, menghapus, dan mengambil atau menampilkan elemen pada Queue. Berikut jenis-jenis operasi pada queue.

  • Enqueu, Operasi Enqueue digunakan untuk menambahkan sebuah item ke dalam queue.
  • Dequeu, Operasi ini digunakan untuk menghapus satu item dari antrian. Item-item tersebut dihapus dalam urutan yang sama seperti saat mereka dimasukkan.
  • Front, perintah ini digunakan untuk mengambil atau menampilkan data paling depan.
  • Rear, perintah rear adalah kebalikan dari perintah front yaitu digunakan untuk mengambil atau menampilkan elemen paling belakang.
None
konsep queue (antrean)

Penerapan Queue

Queue dapat diterapkan dalam bahasa pemrogaman Python menggunakan beberapa metode yaitu sebagai berikut:

  1. List

Penerapan queue pada bahasa pemrogaman python dapat diterapkan menggunakan struktur data bawaannya yaitu list. untuk menambahkan data pada list dipyhton kita menggunakan perintah append() dan pop() masih sama seperti stack. Penerapan queue menggunakan list tergolong lambat karena untuk menyisipkan atau menghapus elemen di awal, semua elemen lainnya harus digeser satu per satu, yang membutuhkan waktu O(n), sehingga kecepatan pengoperasian mengguankan cara ini dipengaruhi jumlah elemennya.

print("--==Penerapan Queue menggunakan list==--")
print('======================================================')
queue = []

# Fungsi append() untuk enqueue (menambah) elemen ke dalam queue
queue.append('a')
queue.append('i')
queue.append('u')
queue.append('e')
queue.append('o')

print('Initial queue')
print(queue)

# Fungsi pop(0) untuk dequeue (menghapus) elemen dari queue dalam urutan FIFO
print('\nElements dequeued from queue:')
print(queue.pop(0))
print(queue.pop(0))
print(queue.pop(0))

print('\nQueue after removing elements')
print(queue)
None
output

[+] Penjelesan : membuat list kosong bernama queue 'queue[]' untuk menampung data. menambahkan elemen menggunakan append() yaitu, ('a', 'i', 'u', 'e', 'o'). pop(0) digunakan untuk mengambil elemen pada indeks ke 0 dimana indeks ke 0 adalah indeks pada elemen pertama sehingga data yang pertama masuk akan menjadi data yang pertama diambil (FIFO). hasil akhirnya adalah ('e', 'o') karena diambil 3 elemen.

2. Collections.deque

Queue juga dapat diterapkan menggunakan kelas deque dari kelas collections. Cara ini dinilai jauh lebih cepat dari pada menggunakan list, dimana untuk melakukan operasi append() dan pop() dapat dilakukan dalam waktu O(1).

print("--==Penerapan Queue menggunakan Collections.deque==--")
print('======================================================')
from collections import deque

queue = deque()

# Fungsi append() untuk Enqueue (menambah) elemen ke dalam queue
queue.append('a')
queue.append('i')
queue.append('u')
queue.append('e')
queue.append('o')

print('Initial queue:')
print(queue)

# Fungsi popleft() untuk dequeue (menghapus) elemen dari depan
print("\nElements dequeued from the queue")
print(queue.popleft())
print(queue.popleft())
print(queue.popleft())

print("\nQueue after removing elements")
print(queue)
None
output

[+] Penjelasan : mengimpor kelas deque dari modul collections lalu membuat objek antrean baru yaitu 'queue = deque()'. append() digunakan untuk menambahkan elemen pada queue dimana elemen yang ditambahkan adalah ('a', 'i', 'u', 'e', 'o'). popleft() digunakan untuk mengambil elemen paling kiri, dimana 3 elemen yang diambil adalah 3 elemen yang pertama masuk yaitu ('a', 'i', 'u') sehingga elemen yang tersisa pada queue hanya ('e', 'o').

3. queue.LifoQueue

Penerapan queue menggunakan cara ini hampir sama dengan cara sebelumnya yaitu collections.queue, dimana kecepatan yang dilakukan adalah O(1). cara ini merupakan struktur data bawaan dalam bahasa python untuk menerapkan struktur data antrean. queue.lifoQueue dilengkapi dengan beberapa fitur seperti batas jumlah elemen dalam queue, melihat jumlah elemen, mengecek apakah queue kosong, mengecek apakah queue penuh, dll. Berikut adalah jenis perintah yang bisa digunakan dalam queue.Lifo.Queue :

  • maxsize — Menunjukkan jumlah maksimum item yang diizinkan dalam antrian.
  • empty() — Mengembalikan nilai True jika antrian kosong, dan False sebaliknya.
  • full() — Mengembalikan nilai True jika antrian sudah mencapai batas maksimum (maxsize). Jika antrian diinisialisasi dengan maxsize=0 (default), maka fungsi full() tidak akan pernah mengembalikan nilai True.
  • get() — Menghapus dan mengembalikan sebuah item dari antrian. Jika antrian kosong, proses akan menunggu hingga ada item yang tersedia.
  • get_nowait() — Mengembalikan sebuah item jika langsung tersedia, jika tidak, maka akan menimbulkan error (QueueEmpty).
  • put(item) — Memasukkan sebuah item ke dalam antrian. Jika antrian sudah penuh, proses akan menunggu hingga ada slot kosong tersedia sebelum menambahkan item baru.
  • put_nowait(item) — Memasukkan sebuah item ke dalam antrian tanpa memblokir. Jika tidak ada slot kosong yang langsung tersedia, akan menimbulkan error (QueueFull).
  • qsize() — Mengembalikan jumlah item yang saat ini ada dalam antrian.
print("--==Penerapan Queue menggunakan queue.LifoQueue==--")
print('======================================================')
from queue import Queue

# Menginisialisasi queue dengan kapasitas maksimal 5
qu = Queue(maxsize=5)

# qsize() menunjukkan jumlah elemen dalam queue (saat ini masih 0)
print(qu.qsize())

# Fungsi put() untuk enqueue (menambah) elemen ke dalam queue
qu.put('a')
qu.put('i')
qu.put('u')
qu.put('e')
qu.put('o')

print("Full: ", qu.full())
print("Size: ", qu.qsize())

# Fungsi get() untuk dequeue (menghapus/mengambil) elemen dari queue
print("\nElements dequeued from the queue")
print(qu.get())
print(qu.get())
print(qu.get())

print("\nEmpty: ", qu.empty())
print("Full: ", qu.full())
None
output

[+] Penjelasan : mengimpor kelas queue dari modul queue lalu membuat objek antrean bernama 'qu' dengan parameter 'Queue(maxsize=5)' yang artinya antrean ini memilki batas elemen yaitu mencapai 5. menambahkan sejumlah fungsi seperti 'qu.qsize()' untuk mengetahui jumlah elemen pada antrean, 'qu.full()' menghasilkan nilai True ketika antrean sudah mencapai batas maxsize, dan 'qu.empty' akan menghasilkan nilai True jika antrean kosong. put() digunkan untuk menambahkan elemen, dimana elemen yang ditambahkan adalah ('a', 'i', 'u', 'e', 'o'). mengambil elemen yang paling kiri menggunakan get() sehingga menerapkan konsep FIFO.

4. Single Linked list

Queue juga dapat diterapkan menggunakan cara linked list. Cara ini menggunakan bagaimana konsep linked list bekerja yaitu menggunakan konsep dataval dan nextval.

print("--==Penerapan Queue menggunakan Single Linked List==--")
print('======================================================\n')
class Queue:
    def __init__(self):
        self.queue = list()

    def addtoqu(self, dataval):
        # Metode Insert untuk menambah elemen di posisi awal (indeks 0)
        if dataval not in self.queue:
            self.queue.insert(0, dataval)
            return True
        return False

    # Metode Pop untuk menghapus elemen dari posisi paling akhir
    def removefromq(self):
        if len(self.queue) > 0:
            return self.queue.pop()
        return ("No elements in Queue!")

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


TheQueue = Queue()
print(TheQueue.addtoqu("Jan"))
print(TheQueue.addtoqu("Feb"))
print(TheQueue.addtoqu("March"))
print(TheQueue.addtoqu("April"))

print(TheQueue.size())

print(TheQueue.removefromq())
print(TheQueue.removefromq())

print(TheQueue.size())
None
output

[+] Penjelasan : membuat cetakan baru bernama class 'class Queue:' lalu mebuat insialisais objek awal dengan 'deef __init__self();' dan membuat list kosong bernama self.queue. Berbeda dengan contoh sebelumnya yang menggunakan append() (tambah di belakang), 'self.queue.insert(0, dataval)' kode ini memasukkan data baru ke indeks paling depan (0). Jadi, data lama akan terdorong ke kanan.

'self.deque.pop()' akan mengambil data paling belakang. Kenapa data yang diambil adalah data paling belakang? Karena data baru selalu dimasukkan ke indeks 0, maka data yang paling lama berada di posisi paling akhir list. 'pop()' tanpa indeks akan mengambil elemen terakhir tersebut. Inilah yang menjaga prinsip FIFO. 'self.size()' digunakan untuk menampilkan panjang atau jumlah elemen pada antrean.

Kesimpulan

Queue adalah adalah salah satu jenis data linier yang menggunakan konsep FIFO (first in first out) atau sekumpulan data yang dimana penambahan elemennya terajdi pada satu ujung atau disebut ekor. Penghapusan elemen queue dilakukan pada ujung yang lain yaitu kepala. Dengan menerapkan konsep ini maka data yang pertama kali masuk akan menjadi data yang pertama kali keluar. Operasi yang digunakan untuk menambahkan item pada queue adalah enqueu sedangkan operasi untuk menghapus elemen adalah deque. Dalam bahasa pemrogaman Python, Queue dapat diterapkan menggunakan beberapa cara yaitu list, Collections.queue, queue.lifoQueue, dan linked list.