Mahasiswa mampu:

• Memahami konsep dasar dan prinsip FIFO pada Queue
• Membedakan mekanisme kerja Stack vs Queue
• Melakukan operasi Enqueue dan Dequeue secara manual
• Memahami dan mengatasi masalah Linear Queue dengan Circular Queue
• Mengimplementasikan Queue menggunakan array dalam C++

Queue adalah struktur data linear yang bekerja berdasarkan prinsip:

First In First Out

Elemen yang pertama kali masuk akan menjadi yang pertama kali keluar.

• Job Scheduling: OS mengatur antrean proses yang akan dieksekusi CPU.
• Print Spooling: Dokumen mengantre untuk dicetak printer.
• Breadth-First Search (BFS): Algoritma pencarian graf/tree.
• Buffering: Menampung data sementara sebelum diproses (streaming video/audio).

"Queue memastikan keadilan (fairness) dalam pemrosesan data."

Pikirkan sejenak sebelum ke slide berikutnya...

1. Masuk A, B, C → Queue: [A, B, C]
2. Keluar 1 (Dequeue) → A keluar. Queue: [B, C]
3. Keluar 2 (Dequeue) → B keluar. Queue: [C]

Setiap data baru masuk melalui ujung Rear.

Pointer Rear akan bertambah (maju).

Penghapusan data dilakukan pada ujung Front.

Pointer Front akan bertambah (maju).

Front menunjuk ke index elemen pertama.
Rear menunjuk ke index elemen terakhir.

Kita butuh tiga hal utama:

1. Array: Untuk menyimpan data.
2. Variabel Front: Menyimpan index depan.
3. Variabel Rear: Menyimpan index belakang.

#define MAX 5
int queue[MAX];
int front = -1;
int rear = -1;

Queue dikatakan KOSONG jika:

Atau pada Linear Queue, bisa juga saat front > rear.

// Global
int queue[MAX];
int front = -1, rear = -1;

// Prototipe Fungsi
void enqueue(int data);
void dequeue();
bool isFull();
bool isEmpty();
void display();

1. Jika rear == MAX - 1, cetak "Overflow"
2. Jika front == -1, set front = 0
3. Naikkan rear (rear++)
4. queue[rear] = data

Awal: front = -1, rear = -1

void enqueue(int data) {
    if (rear == MAX - 1) {
        cout << "Queue Penuh!";
    } else {
        if (front == -1) front = 0;
        rear++;
        queue[rear] = data;
    }
}

• rear == MAX - 1: Mengecek apakah index terakhir sudah tercapai.
• if (front == -1) front = 0;: Menghidupkan pointer front hanya pada elemen pertama.
• rear++: Mempersiapkan slot kosong berikutnya.

1. Jika front == -1, cetak "Underflow"
2. Ambil data queue[front]
3. Naikkan front (front++)
4. Jika front > rear, set front = rear = -1

Queue: [5, 10, 15], front=0, rear=2

void dequeue() {
    if (front == -1) {
        cout << "Queue Kosong!";
    } else {
        cout << "Keluar: " << queue[front];
        front++;
        if (front > rear) {
            front = rear = -1;
        }
    }
}

• front++: Kita hanya memajukan pointer. Data lama tetap di memori tapi tidak bisa diakses via queue.
• if (front > rear): Kondisi di mana semua elemen sudah diambil. Kita reset agar index bisa mulai dari 0 lagi nanti.

void display() {
    if (front == -1) return;
    for (int i = front; i <= rear; i++) {
        cout << queue[i] << " ";
    }
}

Rear = 4 (MAX-1) → Program menganggap PENUH!
Padahal index 0-3 kosong melompong.

• Pointer Rear hanya bertambah (maju).
• Kondisi penuh hanya mengecek rear == MAX - 1.
• Slot kosong di depan tidak bisa digunakan kembali secara otomatis.

Circular Queue (Antrean Melingkar)

Memungkinkan penggunaan kembali slot kosong di depan.

Varian Queue di mana elemen terakhir terhubung kembali ke elemen pertama.

0 → 1 → 2 → 3 → 4 → 0 (Lagi)

Rumus sakti Circular Queue:

Contoh (MAX = 5):

• (0 + 1) % 5 = 1
• (3 + 1) % 5 = 4
• (4 + 1) % 5 = 0 ← Balik!

Queue dikatakan PENUH jika:

Artinya, Rear sudah "mengejar" Front dari belakang.

Queue dikatakan KOSONG jika:

void enqueue(int data) {
    if ((rear + 1) % MAX == front) {
        cout << "Queue Penuh!";
    } else {
        if (front == -1) front = 0;
        rear = (rear + 1) % MAX; // MANTRA SAKTI
        queue[rear] = data;
    }
}

• (rear + 1) % MAX == front: Cek apakah slot berikutnya adalah Front. Jika iya, berarti sudah melingkar penuh.
• rear = (rear + 1) % MAX: Menggerakkan rear secara melingkar.

void dequeue() {
    if (front == -1) {
        cout << "Kosong!";
    } else {
        cout << "Keluar: " << queue[front];
        if (front == rear) { // Tinggal 1 data
            front = rear = -1;
        } else {
            front = (front + 1) % MAX; // MAJU MELINGKAR
        }
    }
}

• front == rear: Indikator elemen terakhir dalam queue.
• front = (front + 1) % MAX: Front juga bergerak melingkar mengikuti Rear.

Langkah demi langkah:

• Q: [1, 2, _], F:0, R:1
• Dequeue → Q: [_, 2, _], F:1, R:1
• Enqueue 3 → Q: [_, 2, 3], F:1, R:2
• Enqueue 4 → Index = (2+1)%3 = 0
• Hasil: Q: [4, 2, 3], F:1, R:0

OS menaruh semua dokumen cetak ke dalam Queue. Printer mengambil satu per satu dari Front. Jika koneksi printer putus, antrean tetap tersimpan rapi.

Setiap nasabah yang datang melakukan Enqueue. Setiap CS yang kosong melakukan Dequeue.

Mekanisme "Waiting Room" atau "Matchmaking Queue" memastikan pemain diproses sesuai urutan waktu tunggu.

Breadth-First Search (BFS)

Algoritma ini menggunakan Queue untuk menyimpan daftar node yang harus dikunjungi selanjutnya secara teratur.

Lakukan operasi berikut pada Queue kosong (MAX=5):

1. Enqueue(12), Enqueue(24), Enqueue(36)
2. Dequeue()
3. Enqueue(48)
4. Dequeue()

Berapakah nilai Front dan Rear sekarang?

enqueue(5);
enqueue(10);
dequeue();
enqueue(15);
display();

Apa output dari display()?

// Ada yang salah di sini:
void enqueue(int data) {
    rear++;
    queue[rear] = data;
}

Sebutkan 2 masalah pada potongan kode di atas!

Modifikasi kode Queue Anda agar bisa menyimpan Nama Pasien (string) di sebuah Klinik.

Gunakan konsep Circular Queue agar efisien!

• Lupa mengecek kondisi Penuh (Overflow) saat Enqueue.
• Lupa mengecek kondisi Kosong (Underflow) saat Dequeue.
• Salah rumus Modulo (terbalik atau lupa tanda kurung).
• Lupa mereset Front dan Rear ke -1 saat data terakhir habis.

Persiapkan diri untuk: Tree & Graph Traversal

Kita akan menggunakan Queue untuk algoritma Breadth-First Search (BFS) dan Level-Order pada Tree.

Queue: Be Fair, Be FIFO!

Jangan lupa kerjakan tugas praktikum di LMS.