Breadth-First Search (BFS) adalah algoritma penelusuran graf atau tree yang bekerja dengan cara menjelajah semua node pada level (kedalaman) yang sama terlebih dahulu, baru kemudian turun ke level berikutnya.

Singkatnya: BFS menelusuri graf secara melebar, bukan mendalam.

BFS menggunakan struktur data Queue (antrian) karena prinsipnya FIFO (First In First Out).

Langkah-langkahnya:

Mulai dari node sumber (misalnya A).

Masukkan node tersebut ke dalam queue.

Ambil node dari antrian → kunjungi.

Masukkan semua tetangga node (yang belum dikunjungi) ke dalam antrian.

Ulangi hingga antrian kosong. BFS – Menjelajah secara melintang (lebar)

Mulai dari node awal → kunjungi semua tetangga terdekat dulu.

Setelah semua tetangga tingkat pertama selesai, baru lanjut ke tingkat berikutnya.

Seperti menjelajah graf layer per layer.

1) Import & deklarasi awal

import java.util.*;

• Mengimpor kelas utilitas Java yang dipakai: Map, List, Queue, Set, HashMap, ArrayList, LinkedList, HashSet, dll.

2) Field kelas

private Map<String, List<String>> adj = new HashMap<>();
private Map<String, Integer> value = new HashMap<>();

• adj = adjacency list → menyimpan struktur graf. Kunci = nama node (mis. "a1"), nilai = daftar tetangga (neighbors).
• value = menyimpan nilai integer tiap node (mis. "a1" → 10). Kita akan mencari angka n pada nilai-nilai ini.

3) Konstruktor BFS_Search()

public BFS_Search() {
    // set nilai node
    value.put("a1", 10);
    ...
    value.put("a8", 21);

    // tambah hubungan / edge
    addEdge("a1", "a2");
    addEdge("a1", "a3");
    addEdge("a2", "a4");
    addEdge("a2", "a5");
    addEdge("a3", "a6");
    addEdge("a3", "a7");
    addEdge("a6", "a8");
}

• Di sini kita mengisi data graf: setiap node diberi nilai, lalu hubungan antar node ditentukan.
• Catatan: cara addEdge di program membuat arah (direction) dari a → b (bukan otomatis dua arah). Jadi ini adalah directed graph kecuali jika addEdge dibuat menambahkan kedua arah.

4) Method addEdge

private void addEdge(String a, String b) {
    adj.computeIfAbsent(a, k -> new ArrayList<>()).add(b);
    adj.computeIfAbsent(b, k -> new ArrayList<>()); // inisialisasi list agar key ada
}

• computeIfAbsent memastikan ada list untuk key tersebut.

• Menambahkan b ke daftar tetangga a.

• Baris kedua hanya memastikan b juga punya entry di adj (meskipun daftar tetangganya bisa kosong).

• Jika Anda ingin graf tak berarah, ubah menjadi:

  adj.computeIfAbsent(a, k -> new ArrayList<>()).add(b);
  adj.computeIfAbsent(b, k -> new ArrayList<>()).add(a);

5) Method utama BFS: bfsSearch

public List<String> bfsSearch(String start, int target) {
    Queue<String> queue = new LinkedList<>();
    Set<String> visited = new HashSet<>();
    Map<String, String> parent = new HashMap<>();

    queue.add(start);
    visited.add(start);
    parent.put(start, null);

    while (!queue.isEmpty()) {
        String node = queue.poll();

        if (value.get(node) == target) {
            return buildPath(parent, node);
        }

        for (String neighbor : adj.get(node)) {
            if (!visited.contains(neighbor)) {
                visited.add(neighbor);
                parent.put(neighbor, node);
                queue.add(neighbor);
            }
        }
    }

    return null;
}

Langkah rinci:

1. Inisialisasi:

   • queue menyimpan node yang akan dikunjungi (FIFO).
   • visited mencegah pengulangan kunjungan node yang sama.
   • parent menyimpan jejak (parent mapping) untuk membangun kembali jalur saat target ditemukan.

2. Masukkan node awal (start) ke queue dan tandai visited.

3. Loop utama: selama queue tidak kosong:

   • poll() ambil node paling depan (level paling dekat dari start).

   • Cek nilai node (value.get(node)) apakah sama target.

     • Jika sama → panggil buildPath(parent, node) untuk membentuk jalur dari start ke node itu dan kembalikan.

   • Telusuri tetangga: untuk setiap neighbor dari node:

     • Jika belum dikunjungi → tandai visited, catat parent (agar bisa membangun jalur), dan enqueue neighbor.

4. Jika selesai loop tanpa menemukan target → kembalikan null (tidak ditemukan).

6) Membangun jalur: buildPath

private List<String> buildPath(Map<String, String> parent, String node) {
    List<String> path = new ArrayList<>();
    while (node != null) {
        path.add(node);
        node = parent.get(node);
    }
    Collections.reverse(path);
    return path;
}

• Mulai dari node tujuan, iterasi ke belakang lewat parent hingga mencapai null (node awal).
• Hasilnya dibalik supaya urutan dari start → target.

7) main — input & menjalankan pencarian

public static void main(String[] args) {
    BFS_Search g = new BFS_Search();
    Scanner sc = new Scanner(System.in);

    System.out.print("Masukkan nilai yang dicari (n): ");
    int n = sc.nextInt();

    System.out.println("\n=== BFS Search (mulai dari a1) ===");
    List<String> path = g.bfsSearch("a1", n);

    if (path != null) {
        System.out.println("Nilai ditemukan pada node: " + path.get(path.size() - 1));
        System.out.println("Jalur BFS menuju node tersebut: " + path);
    } else {
        System.out.println("Nilai tidak ditemukan dalam graf.");
    }

    sc.close();
}

• Program membuat instance graf, meminta input n dari user, lalu memanggil bfsSearch dimulai dari "a1".
• Menampilkan hasil: node tempat nilai ditemukan dan jalurnya, atau pesan tidak ditemukan.
• Menutup Scanner dengan sc.close().

8) Contoh alur eksekusi (misal cari 21)

• Start = a1 (enqueue a1)
• Keluarkan a1 → cek nilai (10 ≠ 21) → enqueue tetangga a2, a3
• Keluarkan a2 → cek nilai (5 ≠ 21) → enqueue a4, a5
• Keluarkan a3 → cek nilai (17 ≠ 21) → enqueue a6, a7
• Keluarkan a4 → ... seterusnya
• Pada akhirnya saat a8 di-dequeue nilai = 21 → build path lewat parent → [a1, a3, a6, a8]

9) Kompleksitas

• Waktu: O(V + E) — setiap node dan setiap edge diproses maksimal sekali.
• Memori: O(V) untuk visited, parent, dan sebagian queue.

10) Potensi error & catatan praktis

• NullPointerException: jika adj.get(node) mengembalikan null. Program saat ini berusaha mencegahnya dengan computeIfAbsent pada addEdge, tapi pastikan start juga ada di adj. Jika ingin aman, ganti loop menjadi:

  List<String> neighbors = adj.getOrDefault(node, new ArrayList<>());
  for (String neighbor : neighbors) { ... }

• value.get(node): pastikan semua node di adj juga punya value (atau cek null sebelum dibandingkan).

• Graf berarah vs tak berarah: sesuaikan addEdge jika perlu hubungan dua arah.

• Multiple nodes with same value: program berhenti pada penemuan pertama (level terpendek dari start). Jika Anda ingin semua node yang memiliki nilai n, kumpulkan semua ketika ditemukan (jangan return langsung).

• File VS Code warning: sebelumnya Anda lihat peringatan “non-project file” — itu tidak menghalangi compile via terminal. Untuk fitur penuh di VS Code, buka folder proyek Java (lihat solusi sebelumnya).

11) Peningkatan yang bisa dilakukan

• Kembalikan juga urutan kunjungan (visited order) untuk debugging.
• Buat bfsSearch mengembalikan objek hasil yang memuat: found (boolean), path, visitedOrder.
• Tambahkan input graf dinamis (baca edges dan values dari file atau input user).
• Implementasi BFS untuk graf tak berarah (jika diperlukan).
• Menangani graf besar: gunakan array/indeks numeric untuk efisiensi jika node bernama a1..a8.

---