Queue dan Stack: Struktur Data untuk Sistem Nyata di Otomotif dan Algoritma JavaScript

Pernah nggak, kamu lagi nunggu di bengkel motor atau mobil yang rame banget? Antrian kendaraan yang masuk bikin kita paham betul soal bagaimana sistem antrian itu bekerja. Nah, di dunia pemrograman, khususnya saat membuat algoritma sistem antrian proses, ada dua struktur data yang sering dipakai: **Queue** dan **Stack**. Kali ini kita bakal kupas tuntas dua struktur ini dengan JavaScript plus contoh kasus antrian proses yang mirip seperti antrean di garasi.

Antrian Proses: Dari Garasi ke Proses Komputer

Bayangin kamu lagi servis motor di bengkel, yang masuk duluan harus selesai duluan juga, biar adil dan nggak bikin macet. Ini mirip banget sama konsep **antrian proses** di komputer. Proses-proses yang datang harus diproses sesuai urutan, supaya sistem tetap lancar dan nggak ‘macet’. Di dunia komputasi, model antrian ini disebut FIFO (First In, First Out).

Sebaliknya, ada juga situasi yang kayak saat kamu mengerjakan modifikasi, yang terakhir kamu siapin, duluan kamu pakai. Itu model yang beda namanya LIFO (Last In, First Out). Dua prinsip ini yang jadi dasar struktur data **Queue** dan **Stack**.

Queue dan Stack: Apa Bedanya?

Kalau Queue itu kayak antrian motor di bengkel, yang datang dulu, di proses dulu — prinsip FIFO. Data masuk di belakang, keluar di depan.

Sedangkan Stack itu seperti tumpukan ban cadangan dalam garasi. Ban yang terakhir ditumpuk, harus diambil duluan buat dipakai—prinsip LIFO.

Penjelasan singkat:

– **Queue (Antrian):**
Operasi utama pengambilan data adalah dari depan, penambahan data dari belakang.

– **Stack (Tumpukan):**
Operasi utama pengambilan dan penambahan data dilakukan di satu tempat yang sama, yaitu puncak tumpukan.

Sekarang kita coba implementasi langsung di JavaScript agar penjelasan makin nyentuh.

Contoh Kode JavaScript: Implementasi FIFO dan LIFO dalam Antrian Proses

1. **Queue Sederhana:**

// Queue dengan array: implementasi FIFO
class Queue {
  constructor() {
    this.items = [];
  }
  
  enqueue(element) {
    this.items.push(element); // tambah di belakang
  }
  
  dequeue() {
    if(this.isEmpty()) return "Queue kosong";
    return this.items.shift(); // ambil dari depan
  }
  
  isEmpty() {
    return this.items.length === 0;
  }
  
  peek() {
    if(this.isEmpty()) return "Queue kosong";
    return this.items[0];
  }
  
  print() {
    console.log(this.items.toString());
  }
}

// Contoh penggunaan:
const antrianProses = new Queue();
antrianProses.enqueue('Proses 1');
antrianProses.enqueue('Proses 2');
antrianProses.enqueue('Proses 3');
antrianProses.print(); // Proses 1,Proses 2,Proses 3

console.log('Mengambil:', antrianProses.dequeue()); // Proses 1
antrianProses.print(); // Proses 2,Proses 3

2. **Stack Sederhana:**

// Stack dengan array: implementasi LIFO
class Stack {
  constructor() {
    this.items = [];
  }
  
  push(element) {
    this.items.push(element); // tambah di puncak tumpukan
  }
  
  pop() {
    if(this.isEmpty()) return "Stack kosong";
    return this.items.pop(); // ambil dari puncak tumpukan
  }
  
  isEmpty() {
    return this.items.length === 0;
  }
  
  peek() {
    if(this.isEmpty()) return "Stack kosong";
    return this.items[this.items.length - 1];
  }
  
  print() {
    console.log(this.items.toString());
  }
}

// Contoh penggunaan:
const tumpukanModifikasi = new Stack();
tumpukanModifikasi.push('Ban Cadangan');
tumpukanModifikasi.push('Filter Udara');
tumpukanModifikasi.push('Oli Mesin');
tumpukanModifikasi.print(); // Ban Cadangan,Filter Udara,Oli Mesin

console.log('Mengambil:', tumpukanModifikasi.pop()); // Oli Mesin
tumpukanModifikasi.print(); // Ban Cadangan,Filter Udara

3. **Variasi: Memproses Antrian Prioritas Sederhana**

Misalnya di bengkel kamu mau prioritas proses servis berdasarkan tipe motor, kita bisa modifikasi queue sederhana jadi prioritas seperti ini:

// Priority Queue sederhana berdasarkan tipe motor (misal: sport > matic > bebek)
class PriorityQueue {
  constructor() {
    this.items = [];
  }
  
  enqueue(element, priority) {
    // element: string nama proses, priority: angka prioritas (semakin kecil, prioritas besar)
    const queueElement = { element, priority };
    let added = false;
    
    for (let i = 0; i < this.items.length; i++) {
      if (queueElement.priority < this.items[i].priority) {
        this.items.splice(i, 0, queueElement);
        added = true;
        break;
      }
    }
    
    if (!added) {
      this.items.push(queueElement);
    }
  }
  
  dequeue() {
    if(this.isEmpty()) return "Queue kosong";
    return this.items.shift().element;
  }
  
  isEmpty() {
    return this.items.length === 0;
  }
  
  print() {
    console.log(this.items.map(i => `${i.element}[${i.priority}]`).toString());
  }
}

// Contoh penggunaan:
const queuePrioritas = new PriorityQueue();
queuePrioritas.enqueue('Servis Motor Bebek', 3);
queuePrioritas.enqueue('Servis Motor Sport', 1);
queuePrioritas.enqueue('Servis Motor Matic', 2);
queuePrioritas.print(); // Servis Motor Sport[1],Servis Motor Matic[2],Servis Motor Bebek[3]

console.log('Memproses:', queuePrioritas.dequeue()); // Servis Motor Sport
queuePrioritas.print(); // Servis Motor Matic[2],Servis Motor Bebek[3]

Masa Depan: Dari Garasi ke Algoritma

Di tahun 2025, sistem otomotif semakin terkoneksi dengan teknologi digital — mulai dari IoT kendaraan sampai sistem manajemen servis berbasis cloud. Struktur data seperti queue dan stack menjadi tulang punggung dalam pipeline pemrosesan data maupun pengaturan antrian servis di POS bengkel canggih.

Bayangkan, semua proses dari permintaan servis, diagnosis masalah, hingga penggantian suku cadang berjalan otomatis sesuai urutan antrian yang diproses menggunakan algoritma yang kita bahas. Jadi, pemahaman mengenai queue dan stack ini bukan cuma soal pemrograman, tapi juga kunci untuk menciptakan ekosistem otomotif digital yang efisien dan terorganisir.

Selamat mencoba, bawa algoritma dari garasi ke dalam kode, supaya prosesmu makin rapi dan terstruktur!