Breadth First Searching

1. Pengertian BFS
Breadth-first search adalah algoritma yang melakukan pencarian secara melebar yang
mengunjungi simpul secara preorder yaitu mengunjungi suatu simpul kemudian mengunjungi
semua simpul yang bertetangga dengan simpul tersebut terlebih dahulu. Selanjutnya, simpul
yang belum dikunjungi dan bertetangga dengan simpulsimpul yang tadi dikunjungi , demikian
seterusnya. Jika graf berbentuk pohon berakar, maka semua simpul pada aras d dikunjungi lebih
dahulu sebelum simpul-simpul pad aras d+1.
Algoritma ini memerlukan sebuah antrian q untuk menyimpan simpul yang telah
dikunjungi. Simpulsimpul ini diperlukan sebagai acuan untuk mengunjungi simpul-simpul yang
bertetanggaan dengannya. Tiap simpul yang telah dikunjungu masuk ke dalam antrian hanya satu
kali. Algoritma ini juga membutuhkan table Boolean untuk menyimpan simpul yang te lah
dikunjungi sehingga tidak ada simpul yang dikunjungi lebih dari satu kali.

2. Cara Kerja BFS

Dalam algoritma BFS, simpul anak yang telah dikunjungi disimpan dalam suatu antrian.
Antrian ini digunakan untuk mengacu simpul-simpul yang bertetangga dengannya yang akan
dikunjungi kemudian sesuai urutan pengantrian. Untuk memperjelas cara kerja algoritma BFS
beserta antrian yang digunakannya, berikut langkah-langkah algoritma BFS:
1. Masukkan simpul ujung (akar) ke dalam antrian
2. Ambil simpul dari awal antrian, lalu cek apakah simpul merupakan solusi
3. Jika simpul merupakan solusi, pencarian selesai dan hasil dikembalikan.
4. Jika simpul bukan solusi, masukkan seluruh simpul yang bertetangga dengan simpul
tersebut (simpul anak) ke dalam antrian
5. Jika antrian kosong dan setiap simpul sudah dicek, pencarian selesai dan mengembalikan
hasil solusi tidak ditemukan
6. Ulangi pencarian dari langkah kedua
3. Graph
 4. Program BFS
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*
/
package javaapplication24;
Merupakan paket yang dituju
/**
* @author USER
*/
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
public class BreadthFirstSearchExample

Public digunakan untuk menyatakan bahwa kelas/method/attribute tersebut dapat diakses

oleh kelas lain dimanapun. Public digunakan apabila kita menginginkan semua variable dalam
Class tersebut dapat di akses dari Class manapun.
{
private Queue<Node> queue;
static ArrayList<Node> nodes=new ArrayList<Node>();
static class Node
{
int data;
boolean visited;
Data memiliki tipe data integer yang merupakan tipe data bernilai angka
Node(int data)
{
this.data=data;
} }
public BreadthFirstSearchExample()
{
queue = new LinkedList<Node>();
}

// find neighbors of node using adjacency matrix

// if adjacency_matrix[i][j]==1, then nodes at index i and index j are connected
public ArrayList<Node> findNeighbours(int adjacency_matrix[][],Node x)

{
int nodeIndex=-1;

ArrayList<Node> neighbours=new ArrayList<Node>();

for (int i = 0; i < nodes.size(); i++) {
if(nodes.get(i).equals(x))
{
nodeIndex=i;
break;
}
}

if(nodeIndex!=-1)
{
for (int j = 0; j < adjacency_matrix[nodeIndex].length; j++) {
if(adjacency_matrix[nodeIndex][j]==1)
{
neighbours.add(nodes.get(j));
}
}
}
return neighbours;
}

public void bfs(int adjacency_matrix[][], Node node)

{
queue.add(node);
node.visited=true;
while (!queue.isEmpty())
{

Node element=queue.remove();
System.out.print(element.data + "\t");
ArrayList<Node> neighbours=findNeighbours(adjacency_matrix,element);
for (int i = 0; i < neighbours.size(); i++) {
Node n=neighbours.get(i);
if(n!=null && !n.visited)
{
queue.add(n);
n.visited=true;

}
}

}
}

public static void main(String arg[])

{

Node node40 =new Node(40);

 Node node10 =new Node(10);
Node node20 =new Node(20);
Node node30 =new Node(30);
Node node60 =new Node(60);
Node node50 =new Node(50);
Node node70 =new Node(70);

nodes.add(node40);
nodes.add(node10);
nodes.add(node20);
nodes.add(node30);
nodes.add(node60);
nodes.add(node50);
nodes.add(node70);
int adjacency_matrix[][] = {
{0,1,1,0,0,0,0}, // Node 1: 40
{0,0,0,1,0,0,0}, // Node 2 :10
{0,1,0,1,1,1,0}, // Node 3: 20
{0,0,0,0,1,0,0}, // Node 4: 30
{0,0,0,0,0,0,1}, // Node 5: 60
{0,0,0,0,0,0,1}, // Node 6: 50
{0,0,0,0,0,0,0}, // Node 7: 70
};
System.out.println("The BFS traversal of the graph is ");
BreadthFirstSearchExample bfsExample = new BreadthFirstSearchExample();
bfsExample.bfs(adjacency_matrix, node40);

}
}