Related Articles

# Breadth First Traversal ( BFS ) on a 2D array

• Difficulty Level : Hard
• Last Updated : 31 May, 2021

Given a matrix of size M x N consisting of integers, the task is to print the matrix elements using Breadth-First Search traversal.

Examples:

Input: grid[][] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}}
Output: 1 2 5 3 6 9 4 7 10 13 8 11 14 12 15 16

Input: grid[][] = {{-1, 0, 0, 1}, {-1, -1, -2, -1}, {-1, -1, -1, -1}, {0, 0, 0, 0}}
Output: -1 0 -1 0 -1 -1 1 -2 -1 0 -1 -1 0 -1 0 0

Approach: Follow the steps below to solve the problem:

1. Initialize the direction vectors dRow[] = {-1, 0, 1, 0} and dCol[] = {0, 1, 0, -1} and a queue of pairs to store the indices of matrix cells.
2. Start BFS traversal from the first cell, i.e. (0, 0), and enqueue the index of this cell into the queue.
3. Initialize a boolean array to mark the visited cells of the matrix. Mark the cell (0, 0) as visited.
4. Declare a function isValid() to check if the cell coordinates are valid or not, i.e lies within the boundaries of the given Matrix and are unvisited or not.
5. Iterate while the queue is not empty and perform the following operations:
• Dequeue the cell present at the front of the queue and print it.
• Move to its adjacent cells that are not visited.
• Mark them visited and enqueue them into the queue.

Note: Direction vectors are used to traverse the adjacent cells of a given cell in a given order. For example (x, y) is a cell whose adjacent cells (x – 1, y), (x, y + 1), (x + 1, y), (x, y – 1) need to be traversed, then it can be done using the direction vectors (-1, 0), (0, 1), (1, 0), (0, -1) in the up, left, down and right order.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `#define ROW 4``#define COL 4` `// Direction vectors``int` `dRow[] = { -1, 0, 1, 0 };``int` `dCol[] = { 0, 1, 0, -1 };` `// Function to check if a cell``// is be visited or not``bool` `isValid(``bool` `vis[][COL],``             ``int` `row, ``int` `col)``{``    ``// If cell lies out of bounds``    ``if` `(row < 0 || col < 0``        ``|| row >= ROW || col >= COL)``        ``return` `false``;` `    ``// If cell is already visited``    ``if` `(vis[row][col])``        ``return` `false``;` `    ``// Otherwise``    ``return` `true``;``}` `// Function to perform the BFS traversal``void` `BFS(``int` `grid[][COL], ``bool` `vis[][COL],``         ``int` `row, ``int` `col)``{``    ``// Stores indices of the matrix cells``    ``queue > q;` `    ``// Mark the starting cell as visited``    ``// and push it into the queue``    ``q.push({ row, col });``    ``vis[row][col] = ``true``;` `    ``// Iterate while the queue``    ``// is not empty``    ``while` `(!q.empty()) {` `        ``pair<``int``, ``int``> cell = q.front();``        ``int` `x = cell.first;``        ``int` `y = cell.second;` `        ``cout << grid[x][y] << ``" "``;` `        ``q.pop();` `        ``// Go to the adjacent cells``        ``for` `(``int` `i = 0; i < 4; i++) {` `            ``int` `adjx = x + dRow[i];``            ``int` `adjy = y + dCol[i];` `            ``if` `(isValid(vis, adjx, adjy)) {``                ``q.push({ adjx, adjy });``                ``vis[adjx][adjy] = ``true``;``            ``}``        ``}``    ``}``}` `// Driver Code``int` `main()``{``    ``// Given input matrix``    ``int` `grid[ROW][COL] = { { 1, 2, 3, 4 },``                           ``{ 5, 6, 7, 8 },``                           ``{ 9, 10, 11, 12 },``                           ``{ 13, 14, 15, 16 } };` `    ``// Declare the visited array``    ``bool` `vis[ROW][COL];``    ``memset``(vis, ``false``, ``sizeof` `vis);` `    ``BFS(grid, vis, 0, 0);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{``    ` `static` `class` `pair``{``    ``int` `first, second;``    ` `    ``public` `pair(``int` `first, ``int` `second) ``    ``{``        ``this``.first = first;``        ``this``.second = second;``    ``}   ``}` `static` `final` `int` `ROW = ``4``;``static` `final` `int` `COL = ``4``;` `// Direction vectors``static` `int` `dRow[] = { -``1``, ``0``, ``1``, ``0` `};``static` `int` `dCol[] = { ``0``, ``1``, ``0``, -``1` `};` `// Function to check if a cell``// is be visited or not``static` `boolean` `isValid(``boolean` `vis[][],``                       ``int` `row, ``int` `col)``{``    ` `    ``// If cell lies out of bounds``    ``if` `(row < ``0` `|| col < ``0` `||``        ``row >= ROW || col >= COL)``        ``return` `false``;` `    ``// If cell is already visited``    ``if` `(vis[row][col])``        ``return` `false``;` `    ``// Otherwise``    ``return` `true``;``}` `// Function to perform the BFS traversal``static` `void` `BFS(``int` `grid[][], ``boolean` `vis[][],``                ``int` `row, ``int` `col)``{``    ` `    ``// Stores indices of the matrix cells``    ``Queue q = ``new` `LinkedList<>();` `    ``// Mark the starting cell as visited``    ``// and push it into the queue``    ``q.add(``new` `pair(row, col));``    ``vis[row][col] = ``true``;` `    ``// Iterate while the queue``    ``// is not empty``    ``while` `(!q.isEmpty())``    ``{``        ``pair cell = q.peek();``        ``int` `x = cell.first;``        ``int` `y = cell.second;` `        ``System.out.print(grid[x][y] + ``" "``);` `        ``q.remove();` `        ``// Go to the adjacent cells``        ``for``(``int` `i = ``0``; i < ``4``; i++)``        ``{``            ``int` `adjx = x + dRow[i];``            ``int` `adjy = y + dCol[i];` `            ``if` `(isValid(vis, adjx, adjy))``            ``{``                ``q.add(``new` `pair(adjx, adjy));``                ``vis[adjx][adjy] = ``true``;``            ``}``        ``}``    ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ` `    ``// Given input matrix``    ``int` `grid[][] = { { ``1``, ``2``, ``3``, ``4` `},``                     ``{ ``5``, ``6``, ``7``, ``8` `},``                     ``{ ``9``, ``10``, ``11``, ``12` `},``                     ``{ ``13``, ``14``, ``15``, ``16` `} };` `    ``// Declare the visited array``    ``boolean` `[][]vis = ``new` `boolean``[ROW][COL];` `    ``BFS(grid, vis, ``0``, ``0``);``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program for the above approach``from` `collections ``import` `deque as queue` `# Direction vectors``dRow ``=` `[ ``-``1``, ``0``, ``1``, ``0``]``dCol ``=` `[ ``0``, ``1``, ``0``, ``-``1``]` `# Function to check if a cell``# is be visited or not``def` `isValid(vis, row, col):``  ` `    ``# If cell lies out of bounds``    ``if` `(row < ``0` `or` `col < ``0` `or` `row >``=` `4` `or` `col >``=` `4``):``        ``return` `False` `    ``# If cell is already visited``    ``if` `(vis[row][col]):``        ``return` `False` `    ``# Otherwise``    ``return` `True` `# Function to perform the BFS traversal``def` `BFS(grid, vis, row, col):``  ` `    ``# Stores indices of the matrix cells``    ``q ``=` `queue()` `    ``# Mark the starting cell as visited``    ``# and push it into the queue``    ``q.append(( row, col ))``    ``vis[row][col] ``=` `True` `    ``# Iterate while the queue``    ``# is not empty``    ``while` `(``len``(q) > ``0``):``        ``cell ``=` `q.popleft()``        ``x ``=` `cell[``0``]``        ``y ``=` `cell[``1``]``        ``print``(grid[x][y], end ``=` `" "``)` `        ``#q.pop()` `        ``# Go to the adjacent cells``        ``for` `i ``in` `range``(``4``):``            ``adjx ``=` `x ``+` `dRow[i]``            ``adjy ``=` `y ``+` `dCol[i]``            ``if` `(isValid(vis, adjx, adjy)):``                ``q.append((adjx, adjy))``                ``vis[adjx][adjy] ``=` `True` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``  ` `    ``# Given input matrix``    ``grid``=` `[ [ ``1``, ``2``, ``3``, ``4` `],``           ``[ ``5``, ``6``, ``7``, ``8` `],``           ``[ ``9``, ``10``, ``11``, ``12` `],``           ``[ ``13``, ``14``, ``15``, ``16` `] ]` `    ``# Declare the visited array``    ``vis ``=` `[[ ``False` `for` `i ``in` `range``(``4``)] ``for` `i ``in` `range``(``4``)]``    ``# vis, False, sizeof vis)` `    ``BFS(grid, vis, ``0``, ``0``)` `# This code is contributed by mohit kumar 29.`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;``public` `class` `GFG``{` `  ``class` `pair``  ``{``    ``public` `int` `first, second;` `    ``public` `pair(``int` `first, ``int` `second) ``    ``{``      ``this``.first = first;``      ``this``.second = second;``    ``}   ``  ``}``  ``static` `readonly` `int` `ROW = 4;``  ``static` `readonly` `int` `COL = 4;` `  ``// Direction vectors``  ``static` `int` `[]dRow = { -1, 0, 1, 0 };``  ``static` `int` `[]dCol = { 0, 1, 0, -1 };` `  ``// Function to check if a cell``  ``// is be visited or not``  ``static` `bool` `isValid(``bool` `[,]vis,``                      ``int` `row, ``int` `col)``  ``{` `    ``// If cell lies out of bounds``    ``if` `(row < 0 || col < 0 ||``        ``row >= ROW || col >= COL)``      ``return` `false``;` `    ``// If cell is already visited``    ``if` `(vis[row,col])``      ``return` `false``;` `    ``// Otherwise``    ``return` `true``;``  ``}` `  ``// Function to perform the BFS traversal``  ``static` `void` `BFS(``int` `[,]grid, ``bool` `[,]vis,``                  ``int` `row, ``int` `col)``  ``{` `    ``// Stores indices of the matrix cells``    ``Queue q = ``new` `Queue();` `    ``// Mark the starting cell as visited``    ``// and push it into the queue``    ``q.Enqueue(``new` `pair(row, col));``    ``vis[row,col] = ``true``;` `    ``// Iterate while the queue``    ``// is not empty``    ``while` `(q.Count!=0)``    ``{``      ``pair cell = q.Peek();``      ``int` `x = cell.first;``      ``int` `y = cell.second;``      ``Console.Write(grid[x,y] + ``" "``);``      ``q.Dequeue();` `      ``// Go to the adjacent cells``      ``for``(``int` `i = 0; i < 4; i++)``      ``{``        ``int` `adjx = x + dRow[i];``        ``int` `adjy = y + dCol[i];``        ``if` `(isValid(vis, adjx, adjy))``        ``{``          ``q.Enqueue(``new` `pair(adjx, adjy));``          ``vis[adjx,adjy] = ``true``;``        ``}``      ``}``    ``}``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main(String[] args)``  ``{` `    ``// Given input matrix``    ``int` `[,]grid = { { 1, 2, 3, 4 },``                   ``{ 5, 6, 7, 8 },``                   ``{ 9, 10, 11, 12 },``                   ``{ 13, 14, 15, 16 } };` `    ``// Declare the visited array``    ``bool` `[,]vis = ``new` `bool``[ROW,COL];``    ``BFS(grid, vis, 0, 0);``  ``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``
Output:
`1 2 5 3 6 9 4 7 10 13 8 11 14 12 15 16`

Time Complexity: O(N * M)
Auxiliary Space: O(N * M) My Personal Notes arrow_drop_up