BFS Code in C++

What is BFS?

Breadth-First Search (BFS) is an algorithm for traversing or searching a graph. It starts at a given vertex and explores all the neighboring vertices before moving on to the next level of vertices. BFS is useful for finding the shortest path between two vertices in a graph or for finding the connected components of a graph. It is also used for topological sorting, a linear ordering of the vertices in a directed acyclic graph (DAG) such that for every edge UV from vertex u to vertex v, u comes before v in the ordering.

In this tutorial, we will learn how to implement BFS in C++. We will start by understanding the concept of BFS and its time complexity. Then, we will see how to represent a graph in C++ using an adjacency list and how to traverse the graph using the BFS algorithm.

Concept of BFS

BFS is an algorithm for traversing or searching a graph. It starts at a given vertex and explores all the neighboring vertices before moving on to the next level of vertices. The algorithm maintains a queue of vertices to be visited, starting with the source vertex. At each step, it removes a vertex from the queue and adds its unvisited neighbors to the queue. This process continues until no more vertices are in the queue to be visited.

The BFS algorithm has a time complexity of O(V+E), where V is the number of vertices and E is the number of edges in the graph. This makes it more suitable for dense graphs, where the number of edges is close to the number of vertices.

Representing a Graph in C++

There are several ways to represent a graph in C++. One common representation is to use an adjacency list, which is a list of all the vertices that are adjacent to a given vertex. For example, consider the following graph with 5 vertices:

We can represent this graph using an adjacency list as follows:

vector<vector<int>> adj_list = {
    {1, 3},  // vertex 0 has neighbors 1 and 3
    {0, 4},  // vertex 1 has neighbors 0 and 4
    {1, 5},  // vertex 2 has neighbors 1 and 5
    {0, 4},  // vertex 3 has neighbors 0 and 4
    {1, 3, 5},  // vertex 4 has neighbors 1, 3, and 5
    {2, 4}  // vertex 5 has neighbors 2 and 4
};

Here, adj_list[i] is a vector containing the neighbors of vertex i.

Implementing BFS in C++

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
// This function performs a BFS search on a graph represented as an adjacency list.
// The graph is assumed to be undirected.
//
// Parameters:
// - adj_list: a vector of vectors representing the adjacency list of the graph
// - start: the index of the starting vertex
// - target: the index of the target vertex (optional)
//
// Returns:
// - a vector of integers representing the BFS traversal order of the graph,
//   starting from the start vertex
// - an empty vector if the target vertex is not found (when the target is specified)
vector<int> bfs(const vector<vector<int>>& adj_list, int start, int target = -1)
{
    int n = adj_list.size();
    vector<bool> visited(n, false);  // a boolean array to track visited vertices
    vector<int> order;  // a vector to store the BFS traversal order

    queue<int> q;  // a queue to hold the vertices to be visited
    q.push(start);  // add the starting vertex to the queue
    visited[start] = true;  // mark the starting vertex as visited
    while (!q.empty())
    {
        int u = q.front();  // get the next vertex in the queue
        q.pop();  // remove the vertex from the queue

        order.push_back(u);  // add the vertex to the traversal order

        // add all the unvisited neighbors of u to the queue
        for (int v : adj_list[u])
        {
            if (!visited[v])
            {
                q.push(v);
                visited[v] = true;
            }
        }
    }
    if (target != -1 && !visited[target])
    {
        // the target vertex was not found, return an empty vector
        return {};
    }
    return order;
}
int main()
{
    // create an adjacency list for a graph with 5 vertices
    vector<vector<int>> adj_list = {
        {1, 2},  // vertex 0 has neighbors 1 and 2
        {0, 3, 4},  // vertex 1 has neighbors 0, 3, and 4
        {0, 4},  // vertex 2 has neighbors 0 and 4
        {1, 4},  // vertex 3 has neighbors 1 and 4
        {1, 2, 3}  // vertex 4 has neighbors 1, 2, and 3
    };
    // perform a BFS search starting from vertex 0
    vector<int> order = bfs(adj_list, 0);
    // print the traversal order
    cout << "BFS traversal order: ";
    for (int i : order)
    {
        cout << i << " ";
    }
    cout << endl;

    return 0;
}

Output:

Explanation:

In this code, we first define the bfs() function, which takes an adjacency list adj_list, a starting vertex start, and an optional target vertex target. The bfs() function initializes a boolean array visited to track the visited vertices and a vector order to store the BFS traversal order. It also creates a queue q to hold the vertices to be visited.

The function then adds the starting vertex to the queue and marks it as visited. It then enters a loop that continues until the queue is empty. Each iteration of the loop removes the next vertex from the queue and adds it to the traversal order. It then adds all its unvisited neighbors to the queue and marks them as visited.

Finally, if a target vertex is specified and it is not found, the function returns an empty vector. Otherwise, it returns the traversal order.

In the main() function, we create an adjacency list for a graph with 5 vertices. We then perform a BFS search starting from vertex 0 and store the traversal order in the order vector. Finally, we print the traversal order to the console.

Next TopicCreate Linked List In C++

← prev next →