Java Academy · Pelajaran

Operasi Deque: Stack dan Queue

Gunakan LinkedList sebagai Deque untuk menerapkan perilaku stack (push/pop) dan queue (offer/poll).

Operasi Deque: Stack dan Queue adalah pelajaran Java Academy gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Java Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Java Academy mencakup 4 pelajaran total.

Antrean Dua Ujung: Antrean dengan Dua Sisi

Antrean dua ujung memungkinkan penyisipan dan penghapusan pada kedua ujung. Interface Deque dari Java diimplementasikan oleh LinkedList dan ArrayDeque.

import java.util.Deque;
import java.util.ArrayDeque;

Deque<String> deque = new ArrayDeque<>();
deque.addFirst("A"); // front
deque.addLast("B");  // back
deque.addFirst("Z"); // new front

System.out.println(deque); // [Z, A, B]

ArrayDeque dibandingkan LinkedList sebagai Antrean Dua Ujung

ArrayDeque umumnya lebih disarankan daripada LinkedList sebagai antrean dua ujung:

Tidak ada overhead simpul untuk setiap elemen
Lokalitas cache lebih baik
Sedikit lebih cepat untuk operasi tumpukan/antrean

Pilih LinkedList hanya ketika Anda juga memerlukan interface List.

Operasi Tumpukan dengan Antrean Dua Ujung

Gunakan push (addFirst) dan pop (removeFirst) untuk menyimulasikan tumpukan LIFO. Hindari kelas Stack lama — kelas tersebut tersinkronisasi dan sudah usang.

Deque<Integer> stack = new ArrayDeque<>();
stack.push(1);
stack.push(2);
stack.push(3);

System.out.println(stack.pop());  // 3
System.out.println(stack.peek()); // 2 (no removal)
System.out.println(stack.pop());  // 2

Operasi Antrean dengan Antrean Dua Ujung

Gunakan offer (addLast) dan poll (removeFirst) untuk menyimulasikan antrean FIFO. offer mengembalikan false saat gagal; add melempar pengecualian.

Deque<String> queue = new ArrayDeque<>();
queue.offer("task1");
queue.offer("task2");
queue.offer("task3");

System.out.println(queue.poll());  // task1
System.out.println(queue.poll());  // task2
System.out.println(queue.size());  // 1

Tabel Referensi Metode Antrean Dua Ujung

Antrean dua ujung menyediakan dua kelompok metode — satu melempar pengecualian, satu lagi mengembalikan nilai khusus:

addFirst/addLast dibandingkan offerFirst/offerLast
removeFirst/removeLast dibandingkan pollFirst/pollLast
getFirst/getLast dibandingkan peekFirst/peekLast

Utamakan kelompok offer/poll/peek untuk menghindari pengecualian pada antrean dua ujung yang kosong.

Contoh Nyata: Membatalkan dan Mengulangi dengan Dua Tumpukan

Kasus penggunaan Deque klasik: riwayat pembatalan adalah sebuah tumpukan. Pengulangan menggunakan tumpukan lainnya.

Deque<String> undo = new ArrayDeque<>();
Deque<String> redo = new ArrayDeque<>();

undo.push("type 'Hello'");
undo.push("type ' World'");

String action = undo.pop();
System.out.println("Undone: " + action); // type ' World'
redo.push(action);

System.out.println("Redo top: " + redo.peek()); // type ' World'

Pemeriksaan Palindrom dengan Antrean Dua Ujung

Antrean dua ujung membuat pemeriksaan palindrom menjadi elegan — bandingkan karakter dari kedua ujung secara bersamaan.

Deque<Character> deque = new ArrayDeque<>();
for (char c : "racecar".toCharArray()) deque.add(c);

boolean isPalindrome = true;
while (deque.size() > 1) {
    if (!deque.pollFirst().equals(deque.pollLast())) {
        isPalindrome = false;
        break;
    }
}
System.out.println(isPalindrome); // true

BFS dengan Antrean

Breadth-First Search menggunakan antrean. ArrayDeque adalah pilihan standar untuk BFS dalam pemrograman kompetitif dan penelusuran graf.

import java.util.*;

// BFS on a simple adjacency list
Map<Integer,List<Integer>> graph = Map.of(
    1, List.of(2,3),
    2, List.of(4),
    3, List.of(4),
    4, List.of()
);
Deque<Integer> queue = new ArrayDeque<>();
Set<Integer> visited = new HashSet<>();
queue.offer(1);
while (!queue.isEmpty()) {
    int node = queue.poll();
    if (visited.add(node)) {
        System.out.print(node + " ");
        queue.addAll(graph.get(node));
    }
}

DFS dengan Tumpukan

Depth-First Search menggunakan tumpukan. Sekali lagi, utamakan ArrayDeque daripada kelas Stack lama.

Deque<Integer> stack = new ArrayDeque<>();
Set<Integer> visited = new HashSet<>();
stack.push(1);
while (!stack.isEmpty()) {
    int node = stack.pop();
    if (visited.add(node)) {
        System.out.print(node + " ");
        // push neighbors (will be processed in reverse order)
        List<Integer> neighbors = List.of(2, 3); // simplified
        for (int n : neighbors) if (!visited.contains(n)) stack.push(n);
    }
}

Antrean Dua Ujung Berbatas dengan Pemeriksaan Ukuran

ArrayDeque bertambah secara dinamis, tetapi Anda dapat menetapkan kapasitas secara manual untuk menyimulasikan penyangga berbatas:

Deque<Integer> buffer = new ArrayDeque<>();
int MAX = 3;

for (int i = 1; i <= 5; i++) {
    if (buffer.size() >= MAX) {
        buffer.pollFirst(); // drop oldest
    }
    buffer.offerLast(i);
}
System.out.println(buffer); // [3, 4, 5]

Catatan Kinerja

ArrayDeque menggunakan larik melingkar yang ukurannya menjadi dua kali lipat saat penuh. Biaya diamortisasi semua operasinya adalah O(1). Kinerjanya melampaui LinkedList dalam sebagian besar tolok ukur karena efisiensi cache. Jangan pernah melakukan sinkronisasi secara manual — gunakan ConcurrentLinkedDeque atau antrean pemblokiran untuk konkurensi.

Pemeriksaan Singkat

Kelas apa yang sebaiknya Anda pilih daripada Stack lama untuk operasi LIFO?

Ringkasan: Operasi Antrean Dua Ujung

Poin-poin utama:

Antrean dua ujung memungkinkan penyisipan/penghapusan O(1) pada kedua ujung
ArrayDeque lebih disarankan daripada LinkedList untuk penggunaan murni sebagai tumpukan/antrean
push/pop → tumpukan LIFO; offer/poll → antrean FIFO
Penggunaan klasik: pembatalan/pengulangan, BFS/DFS, jendela geser, pemeriksaan palindrom
Hindari kelas Stack dan Queue lama

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Operasi Deque: Stack dan Queue” gratis?

Ya — teks lengkap “Operasi Deque: Stack dan Queue” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Java Academy, upgrade ke CoddyKit PRO. Kursus Java Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Operasi Deque: Stack dan Queue”?

Gunakan LinkedList sebagai Deque untuk menerapkan perilaku stack (push/pop) dan queue (offer/poll). Kamu berlatih Java Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Java Academy?

Tidak diperlukan pengalaman sebelumnya. Java Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Operasi Deque: Stack dan Queue” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Java Academy ini?

Ya. Setiap pelajaran Java Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Java Academy