Breadth-First Search Breadth-first search is one of the simplest algorithms for searching a graph.

Given a graph and a distinguished source vertex, breadth-first search explores the edges of the graph to find every vertex reachable from source. It computes the distance (fewest number of edges) from source to all reachable vertices and produces a breadth-first tree with source vertex as root, which contains all such reachable vertices. It works on both directed and undirected graphs. This algorithm uses a first-in, first-out Queue Q to manage the vertices. Algorithm: Input Format: Graph is directed and unweighted. First two integers must be number of vertices and edges which must be followed by pairs of vertices which has an edge between them. maxVertices represents maximum number of vertices that can be present in the graph. vertices represent number of vertices and edges represent number of edges in the graph. graph[i][j] represent the weight of edge joining i and j. size[maxVertices] is initialed to{0}, represents the size of every vertex i.e. the number of edges corresponding to the vertex. visited[maxVertices]={0} represents the vertex that have been visited. Initialize the graph. For presentVertex = 0 to vertices if visited[presentVertex] is 0, i.e. if the vertex has not been visited then call Bfs function. presentVertex represents the vertex that is being tackled. Bfs function is called to get the shortest path. Bfs function: This function takes the graph obtained (graph[ ][ maxVertices]), pointer to the array size and visited, and the presentValue as arguments. visited[presentVertex] = 1 as the vertex has now been visited. Iterate through all the vertices connected to the presentVertex and perform bfs on those vertices if they are not visited before. Create a queue Q using createQueue function and enqueue the presentVertex using Enqueue function. Until the Q is not empty i.e. Q->size 0 Store the front element of Q using Front function in presentVertex Print the vertex that is being visited now, which is presentVertex Remove the element from the front of Q using Dequeue function For iter=0 to size[presentVertex] 1 If (!visited[graph[presentVertex][iter]]) visited[graph[presentVertex][iter]] = 1 Enqueue(Q,graph[presentVertex][iter])

Iter + 1 This for loop visits every vertex that is adjacent to the presentVertex and has not been visited yet. These vertices are then inserted in the Q using Enqueue function and their visited status is updated to 1. Queue has five properties - capacity stands for the maximum number of elements Queue can hold, Size stands for the current size of the Queue, elements is the array of elements, front is the index of first element (the index at which we remove the element) and rear is the index of last element (the index at which we insert the element). Functions on Queue 1. createQueue function takes argument the maximum number of elements the Queue can hold, creates a Queue according to it and returns a pointer to the Queue. It initializes Q>size to 0, Q->capacity to maxElements, Q->front to 0 and Q->rear to -1. 2. enqueue function - This function takes the pointer to the top of the queue Q and the item (element) to be inserted as arguments. Check for the emptiness of queue a. If Q->size is equal to Q->capacity, we cannot push an element into Q as there is no space for it. b. Else, enqueue an element at the end of Q, increase its size by one. Increase the value of Q->rear to Q->rear + 1. As we fill the queue in circular fashion, if Q->rear is equal to Q->capacity make Q->rear = 0. Now, Insert the element in its rear side Q->elements[Q->rear] = element 3. dequeue function - This function takes the pointer to the top of the stack S as an argument. a. If Q->size is equal to zero, then it is empty. So, we cannot dequeue. b. Else, remove an element which is equivalent to incrementing index of front by one. Decrease the size by 1. As we fill elements in circular fashion, if Q->front is equal to Q->capacity make Q->front=0. 4. front function This function takes the pointer to the top of the queue Q as an argument and returns the front element of the queue Q. It first checks if the queue is empty (Q->size is equal to zero). If its not it returns the element which is at the front of the queue. Q->elements[Q->front] Analysis: Initializing takes O(V) time The queue operations take time of O(V) as enqueuing and dequeuing takes O(1) time. In scanning the adjacency list at most O(E) time is spent. Thus, the total running time of BFS is O(V + E). Example:

Current vertex being visited Where, x is the vertex number.

Vertex previously visited

Initially only the source (root) is present. 1 2 front 0 Q= 0 rear 3 4

First-Pass Source (0) vertex is the present vertex being visited, it is then dequeued. Adjacency list of the source (0) node is scanned and since vertex 1 has not been visited add it in the queue, mark it visited.

2 front 1 rear

Q=

Second-Pass Vertex 1 is the present vertex being visited, it is then dequeued. Adjacency list of the vertex 1 is scanned and since vertices 2 and 3 have not been visited add them in the queue, mark them visited.

2 front 3 2 rear

Q=

Third-Pass - Vertex 3 is the present vertex being visited, it is then dequeued. Adjacency list of the vertex 3 is scanned and since vertex 4 has not been visited add it in the queue, mark it visited. Vertex 0 has already been visited.

2 front 2 4 rear

Q=

Fourth-Pass - Vertex 2 is the present vertex being visited, it is then dequeued. Adjacency list of the vertex 2 is scanned and since every adjacent vertex has already been visited nothing is enqueued in the queue.

2 front 4 rear

Q=

Fifth-Pass - Vertex 4 is the present vertex being visited, it is then dequeued. Adjacency list of the vertex 4 is scanned and since every adjacent vertex has already been visited nothing is enqueued in the queue. Thus, Queue becomes empty indicating every vertex has been visited.

Q is empty

The order in which nodes are "visited" as a result of Bfs() is: 0 1 1 edge away 3 2 4 3 edges away

2 edges away