Stack dan Queue

// Demo Stack dan Queue: implementasi dengan ArrayDeque dari standard library.

// === Stack: LIFO (Last In First Out) ===
// Push via addLast, Pop via removeLast
class Stack<T> {
    private val deque = ArrayDeque<T>()

    fun push(item: T) {
        deque.addLast(item)
    }

    fun pop(): T? = if (deque.isEmpty()) null else deque.removeLast()

    fun peek(): T? = deque.lastOrNull()

    fun isEmpty(): Boolean = deque.isEmpty()

    fun size(): Int = deque.size

    fun toList(): List<T> = deque.toList()
}

// === Queue: FIFO (First In First Out) ===
// Enqueue via addLast, Dequeue via removeFirst
class Queue<T> {
    private val deque = ArrayDeque<T>()

    fun enqueue(item: T) {
        deque.addLast(item)
    }

    fun dequeue(): T? = if (deque.isEmpty()) null else deque.removeFirst()

    fun peek(): T? = deque.firstOrNull()

    fun isEmpty(): Boolean = deque.isEmpty()

    fun size(): Int = deque.size

    fun toList(): List<T> = deque.toList()
}

// === Aplikasi Stack: cek bracket seimbang ===
fun bracketSeimbang(ekspresi: String): Boolean {
    val stack = Stack<Char>()
    val pasangan = mapOf(')' to '(', '}' to '{', ']' to '[')
    for (ch in ekspresi) {
        when (ch) {
            '(', '{', '[' -> stack.push(ch)
            ')', '}', ']' -> {
                val top = stack.pop() ?: return false
                if (pasangan[ch] != top) return false
            }
        }
    }
    return stack.isEmpty()
}

// === Aplikasi Queue: simulasi antrian loket ===
data class Pelanggan(val nama: String, val waktuLayanan: Int)

fun simulasiAntrian(pelanggan: List<Pelanggan>): List<String> {
    val queue = Queue<Pelanggan>()
    pelanggan.forEach { queue.enqueue(it) }

    val log = mutableListOf<String>()
    var totalTunggu = 0
    while (!queue.isEmpty()) {
        val p = queue.dequeue()!!
        log.add("Melayani ${p.nama} (waktu layanan ${p.waktuLayanan}s, tunggu ${totalTunggu}s)")
        totalTunggu += p.waktuLayanan
    }
    log.add("Total waktu layanan: ${totalTunggu}s")
    return log
}

fun main() {
    println("=== Demo Stack dan Queue ===")

    println("--- Stack (LIFO) ---")
    val stack = Stack<Int>()
    stack.push(10)
    stack.push(20)
    stack.push(30)
    println("Setelah push 10, 20, 30: ${stack.toList()}")
    println("Peek (atas): ${stack.peek()}")
    println("Pop: ${stack.pop()}")
    println("Pop: ${stack.pop()}")
    println("Sisa: ${stack.toList()}")

    println()
    println("--- Queue (FIFO) ---")
    val queue = Queue<String>()
    queue.enqueue("Budi")
    queue.enqueue("Siti")
    queue.enqueue("Dewi")
    println("Setelah enqueue Budi, Siti, Dewi: ${queue.toList()}")
    println("Peek (depan): ${queue.peek()}")
    println("Dequeue: ${queue.dequeue()}")
    println("Dequeue: ${queue.dequeue()}")
    println("Sisa: ${queue.toList()}")

    println()
    println("--- Aplikasi: cek bracket ---")
    val ekspresi = listOf("(a + b) * [c - {d / e}]", "((())", "([]})", "()", "")
    for (e in ekspresi) {
        println("\"$e\" -> ${if (bracketSeimbang(e)) "seimbang" else "tidak seimbang"}")
    }

    println()
    println("--- Aplikasi: simulasi antrian loket ---")
    val pelanggan = listOf(
        Pelanggan("Budi", 5),
        Pelanggan("Siti", 3),
        Pelanggan("Dewi", 7),
        Pelanggan("Andi", 2)
    )
    simulasiAntrian(pelanggan).forEach { println(it) }
}

=== Demo Stack dan Queue ===
--- Stack (LIFO) ---
Setelah push 10, 20, 30: [10, 20, 30]
Peek (atas): 30
Pop: 30
Pop: 20
Sisa: [10]

--- Queue (FIFO) ---
Setelah enqueue Budi, Siti, Dewi: [Budi, Siti, Dewi]
Peek (depan): Budi
Dequeue: Budi
Dequeue: Siti
Sisa: [Dewi]

--- Aplikasi: cek bracket ---
"(a + b) * [c - {d / e}]" -> seimbang
"((())" -> tidak seimbang
"([]})" -> tidak seimbang
"()" -> seimbang
"" -> seimbang

--- Aplikasi: simulasi antrian loket ---
Melayani Budi (waktu layanan 5s, tunggu 0s)
Melayani Siti (waktu layanan 3s, tunggu 5s)
Melayani Dewi (waktu layanan 7s, tunggu 8s)
Melayani Andi (waktu layanan 2s, tunggu 15s)
Total waktu layanan: 17s