# Which Data Structure Is Used in Breadth First Search?

//

Larry Thompson

Breadth First Search (BFS) is a popular graph traversal algorithm that explores all the vertices of a graph in breadth-first order, i.e., it visits all the vertices at the same level before moving to the next level. BFS is widely used in various applications, such as finding the shortest path between two vertices, analyzing social networks, and solving puzzles.

To implement BFS efficiently, we need a data structure that supports efficient insertion and deletion of elements from both ends. The data structure that perfectly suits this requirement is a queue. A queue follows the First-In-First-Out (FIFO) principle, which means that the element inserted first is removed first.

In BFS, we start by inserting the source vertex into the queue. Then, while there are still elements in the queue, we dequeue an element and visit its adjacent vertices.

If a vertex has not been visited before, we enqueue it into the queue. This process continues until all vertices have been visited or until our desired goal has been achieved.

Let’s take a closer look at how a queue is used in BFS.

## Queue Implementation for Breadth First Search

To implement BFS using a queue data structure, we can use various programming languages like C++, Java, Python, etc. Here’s an example using Python:

“`python
# Create an empty queue
queue = []

# Insert the source vertex into the queue
queue.append(source_vertex)

# Mark the source vertex as visited
visited[source_vertex] = True

# Perform BFS until the queue becomes empty
while len(queue) > 0:
# Dequeue an element from the front of the queue
current_vertex = queue.pop(0)

# Process current_vertex (e.g., print or perform some operation)

# Visit all adjacent vertices of current_vertex
for neighbor in graph[current_vertex]:
if not visited[neighbor]:
# Mark the neighbor as visited
visited[neighbor] = True

# Enqueue the neighbor into the queue
queue.append(neighbor)
“`

In this example, we start by creating an empty queue using a list in Python. We insert the source vertex into the queue and mark it as visited.

Then, while there are still elements in the queue, we dequeue an element from the front of the queue and process it. We visit all its adjacent vertices and enqueue them into the queue if they haven’t been visited before.

This process continues until there are no more elements left in the queue, indicating that all vertices have been visited.

## Benefits of Using a Queue for BFS

Using a queue data structure for BFS provides several benefits:

• Efficient insertion and deletion: A queue allows efficient insertion and deletion of elements from both ends, making it ideal for BFS.
• Breadth-first exploration: By exploring vertices at each level before moving to the next level, BFS guarantees that we find the shortest path (if it exists) from the source vertex to any other vertex in an unweighted graph.
• Visiting all vertices: BFS ensures that all vertices of a graph are visited, which is useful for various applications such as graph traversal and connectivity analysis.

## Alternative Data Structures

While a queue is commonly used in BFS due to its efficiency and suitability for breadth-first exploration, alternative data structures can also be used depending on specific requirements.

For example, if we need to find a path between two vertices with certain constraints (e., minimum weight), we can use a priority queue instead of a regular queue. A priority queue ensures that elements with higher priorities (e., lower weights) are dequeued first.

Additionally, in certain scenarios, other data structures such as stacks or lists can be used to implement BFS. However, these alternatives may not provide the same benefits as a queue and may result in less efficient implementations.

## Conclusion

In conclusion, the data structure that is commonly used in Breadth First Search (BFS) is a queue. A queue allows efficient insertion and deletion of elements from both ends, making it ideal for exploring all vertices in breadth-first order. By using a queue, BFS guarantees that we visit all vertices at each level before moving to the next level, ensuring efficient graph traversal and connectivity analysis.

Remember to make use of this powerful algorithm and its associated data structure to solve various graph-related problems efficiently!