Skip to content
Related Articles

Related Articles

Print matrix elements using DFS traversal

Improve Article
Save Article
Like Article
  • Difficulty Level : Easy
  • Last Updated : 03 Feb, 2022

Given a matrix grid[][] with dimension M × N of integers, the task is to print the matrix elements using DFS traversal.

Examples:

Input: mat[][] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}}
Output: 1 2 3 4 8 12 16 15 11 7 6 10 14 13 9 5
Explanation: The matrix elements in the order of their Depth First Search traversal are 1 2 3 4 8 12 16 15 11 7 6 10 14 13 9 5.

Input: mat[][] = {{0, 1, 9, 4}, {1, 2, 3, 4}, {0, 0, -1, -1}, {-1, -1, 0, 1}}
Output: 0 1 9 4 4 -1 1 0 -1 3 2 0 -1 -1 0 1

Recursive Approach: The idea is to use a Recursive depth-first search for traversing the matrix and printing its elements. Follow the steps below to solve the problem:

  • Initialize a 2D boolean vector, say vis[][], to keep track of already visited and unvisited indices.
  • Define a function, say isValid(i, j), to check if the position (i, j) is valid or not i.e (i, j) should be inside the matrix and not visited.
  • Define a recursive function DFS(i, j):
    • On each call, mark the current position (i, j) visited and print the element at that position.
    • Make the recursive call for all the adjacent sides, i.e DFS(i + 1, j), DFS(i, j + 1), DFS(i – 1, j) and DFS(i, j – 1) if respective positions are valid i.e., not visited and are within the matrix.
  • Finally, call the function DFS(0, 0) to start the DFS Traversal to print the matrix.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Direction vectors
int dRow[] = { -1, 0, 1, 0 };
int dCol[] = { 0, 1, 0, -1 };
 
// Function to check if current
// position is valid or not
bool isValid(vector<vector<bool> >& vis,
             int row, int col,
             int COL, int ROW)
{
    // Check if the cell is out of bounds
    if (row < 0 || col < 0 || col > COL - 1
        || row > ROW - 1)
        return false;
 
    // Check if the cell is visited or not
    if (vis[row][col] == true)
        return false;
 
    return true;
}
 
// Utility function to print matrix
// elements using DFS Traversal
void DFSUtil(int row, int col,
             vector<vector<int> > grid,
             vector<vector<bool> >& vis,
             int M, int N)
{
    // Mark the current cell visited
    vis[row][col] = true;
 
    // Print the element at the cell
    cout << grid[row][col] << " ";
 
    // Traverse all four adjacent
    // cells of the current element
    for (int i = 0; i < 4; i++) {
 
        int x = row + dRow[i];
        int y = col + dCol[i];
 
        // Check if x and y is
        // valid index or not
        if (isValid(vis, x, y, M, N))
            DFSUtil(x, y, grid, vis, M, N);
    }
}
 
// Function to print the matrix elements
void DFS(int row, int col,
         vector<vector<int> > grid,
         int M, int N)
{
    // Initialize a visiting matrix
    vector<vector<bool> > vis(
        M + 1, vector<bool>(N + 1, false));
 
    // Function call to print matrix
    // elements by DFS traversal
    DFSUtil(0, 0, grid, vis, M, N);
}
 
// Driver Code
int main()
{
    // Given matrix
    vector<vector<int> > grid{ { 1, 2, 3, 4 },
                               { 5, 6, 7, 8 },
                               { 9, 10, 11, 12 },
                               { 13, 14, 15, 16 } };
 
    // Row of the matrix
    int M = grid.size();
 
    // Column of the matrix
    int N = grid[0].size();
 
    DFS(0, 0, grid, M, N);
 
    return 0;
}

Java




// Java program to implement
// the above approach
import java.util.*;
class GFG
{
// Direction vectors
static int dRow[] = { -1, 0, 1, 0 };
static int dCol[] = { 0, 1, 0, -1 };
 
// Function to check if current
// position is valid or not
static boolean isValid(boolean[][] vis,
             int row, int col,
             int COL, int ROW)
{
    // Check if the cell is out of bounds
    if (row < 0 || col < 0 || col > COL - 1
        || row > ROW - 1)
        return false;
 
    // Check if the cell is visited or not
    if (vis[row][col] == true)
        return false;
 
    return true;
}
 
// Utility function to print matrix
// elements using DFS Traversal
static void DFSUtil(int row, int col,
            int[][] grid,
            boolean[][] vis,
            int M, int N)
{
   
    // Mark the current cell visited
    vis[row][col] = true;
 
    // Print the element at the cell
    System.out.print(grid[row][col] + " ");
 
    // Traverse all four adjacent
    // cells of the current element
    for (int i = 0; i < 4; i++) {
 
        int x = row + dRow[i];
        int y = col + dCol[i];
 
        // Check if x and y is
        // valid index or not
        if (isValid(vis, x, y, M, N))
            DFSUtil(x, y, grid, vis, M, N);
    }
}
// Function to print the matrix elements
static void DFS(int row, int col,
        int[][] grid,
         int M, int N)
{
    // Initialize a visiting matrix
    boolean[][] vis = new boolean[M + 1][N + 1];
    for(int i = 0; i < M + 1; i++)
    {
        for(int j = 0; j < N + 1; j++)
        {
            vis[i][j] = false;
        }
    }
 
    // Function call to print matrix
    // elements by DFS traversal
    DFSUtil(0, 0, grid, vis, M, N);
}
 
// Driver Code
public static void main(String args[])
{
    // Given matrix
    int[][] grid = { { 1, 2, 3, 4 },
                    { 5, 6, 7, 8 },
                    { 9, 10, 11, 12 },
                    { 13, 14, 15, 16 } };
 
    // Row of the matrix
    int M = grid.length;
 
    // Column of the matrix
    int N = grid[0].length;
 
    DFS(0, 0, grid, M, N);
}
}
 
// This code is contributed by susmitakundugoaldanga.

Python3




# Python3 program for the above approach
 
# Direction vectors
dRow = [-1, 0, 1, 0]
dCol = [0, 1, 0, -1]
 
# Function to check if current
# position is valid or not
def isValid(row, col, COL, ROW):
    global vis
     
    # Check if the cell is out of bounds
    if (row < 0 or col < 0 or col > COL - 1 or row > ROW - 1):
        return False
 
    # Check if the cell is visited or not
    if (vis[row][col] == True):
        return False
    return True
 
# Utility function to print matrix
# elements using DFS Traversal
def DFSUtil(row, col,grid, M, N):
    global vis
 
    # Mark the current cell visited
    vis[row][col] = True
 
    # Print element at the cell
    print(grid[row][col], end = " ")
 
    # Traverse all four adjacent
    # cells of the current element
    for i in range(4):
 
        x = row + dRow[i]
        y = col + dCol[i]
 
        # Check if x and y is
        # valid index or not
        if (isValid(x, y, M, N)):
            DFSUtil(x, y, grid, M, N)
 
# Function to print matrix elementsdef
def DFS(row, col,grid, M, N):
    global vis
    # Initialize a visiting matrix
 
    # Function call to print matrix
    # elements by DFS traversal
    DFSUtil(0, 0, grid, M, N)
 
# Driver Code
if __name__ == '__main__':
     
    # Given matrix
    grid = [ [ 1, 2, 3, 4 ],
           [ 5, 6, 7, 8 ],
           [ 9, 10, 11, 12 ],
           [ 13, 14, 15, 16 ] ]
 
    # Row of the matrix
    M = len(grid)
 
    # Column of the matrix
    N = len(grid[0])
    vis = [[False for i in range(M)] for i in range(N)]
    DFS(0, 0, grid, M, N)
 
    # This code is contributed by mohit kumar 29.

C#




// C# program to implement
// the above approach
using System;
public class GFG
{
   
// Direction vectors
static int []dRow = { -1, 0, 1, 0 };
static int []dCol = { 0, 1, 0, -1 };
 
// Function to check if current
// position is valid or not
static bool isValid(bool[,] vis,
             int row, int col,
             int COL, int ROW)
{
   
    // Check if the cell is out of bounds
    if (row < 0 || col < 0 || col > COL - 1
        || row > ROW - 1)
        return false;
 
    // Check if the cell is visited or not
    if (vis[row,col] == true)
        return false;
 
    return true;
}
 
// Utility function to print matrix
// elements using DFS Traversal
static void DFSUtil(int row, int col,
            int[,] grid,
            bool[,] vis,
            int M, int N)
{
   
    // Mark the current cell visited
    vis[row,col] = true;
 
    // Print the element at the cell
    Console.Write(grid[row,col] + " ");
 
    // Traverse all four adjacent
    // cells of the current element
    for (int i = 0; i < 4; i++) {
 
        int x = row + dRow[i];
        int y = col + dCol[i];
 
        // Check if x and y is
        // valid index or not
        if (isValid(vis, x, y, M, N))
            DFSUtil(x, y, grid, vis, M, N);
    }
}
   
// Function to print the matrix elements
static void DFS(int row, int col,
        int[,] grid,
         int M, int N)
{
   
    // Initialize a visiting matrix
    bool[,] vis = new bool[M + 1,N + 1];
    for(int i = 0; i < M + 1; i++)
    {
        for(int j = 0; j < N + 1; j++)
        {
            vis[i,j] = false;
        }
    }
 
    // Function call to print matrix
    // elements by DFS traversal
    DFSUtil(0, 0, grid, vis, M, N);
}
 
// Driver Code
public static void Main(String []args)
{
   
    // Given matrix
    int[,] grid = { { 1, 2, 3, 4 },
                    { 5, 6, 7, 8 },
                    { 9, 10, 11, 12 },
                    { 13, 14, 15, 16 } };
 
    // Row of the matrix
    int M = grid.GetLength(0);
 
    // Column of the matrix
    int N = grid.GetLength(1);
    DFS(0, 0, grid, M, N);
}
}
 
// This code is contributed by 29AjayKumar

Javascript




<script>
// javascript program of the above approach
 
// Direction vectors
let dRow = [ -1, 0, 1, 0 ];
let dCol = [ 0, 1, 0, -1 ];
 
// Function to check if current
// position is valid or not
function isValid(vis, row, col,
             COL, ROW)
{
    // Check if the cell is out of bounds
    if (row < 0 || col < 0 || col > COL - 1
        || row > ROW - 1)
        return false;
 
    // Check if the cell is visited or not
    if (vis[row][col] == true)
        return false;
 
    return true;
}
 
// Utility function to print matrix
// elements using DFS Traversal
function DFSUtil(row, col, grid,
            vis, M, N)
{
   
    // Mark the current cell visited
    vis[row][col] = true;
 
    // Print the element at the cell
   document.write(grid[row][col] + " ");
 
    // Traverse all four adjacent
    // cells of the current element
    for (let i = 0; i < 4; i++) {
 
        let x = row + dRow[i];
        let y = col + dCol[i];
 
        // Check if x and y is
        // valid index or not
        if (isValid(vis, x, y, M, N))
            DFSUtil(x, y, grid, vis, M, N);
    }
}
// Function to print the matrix elements
function DFS(row, col, grid, M, N)
{
    // Initialize a visiting matrix
    let vis = new Array(M + 1);
     
    // Loop to create 2D array using 1D array
    for (var i = 0; i < vis.length; i++) {
        vis[i] = new Array(2);
    }
 
    for(let i = 0; i < M + 1; i++)
    {
        for(let j = 0; j < N + 1; j++)
        {
            vis[i][j] = false;
        }
    }
 
    // Function call to print matrix
    // elements by DFS traversal
    DFSUtil(0, 0, grid, vis, M, N);
}
 
    // Driver Code
     
    // Given matrix
    let grid = [[ 1, 2, 3, 4 ],
                    [ 5, 6, 7, 8 ],
                    [ 9, 10, 11, 12 ],
                    [ 13, 14, 15, 16 ]];
 
    // Row of the matrix
    let M = grid.length;
 
    // Column of the matrix
    let N = grid[0].length;
 
    DFS(0, 0, grid, M, N);
 
</script>
Output
1 2 3 4 8 12 16 15 11 7 6 10 14 13 9 5 

Time Complexity: O(N*M)
Auxiliary Space: O(N*M) 

Iterative Approach: The idea is to traverse the matrix using iterative depth-first search and print the matrix elements. Follow the steps below to solve the problem:

  • Define a function, say isValid(i, j), to check if the position (i, j) is valid or not, i.e (i, j) lies inside the matrix and not visited.
  • Initialize a 2d boolean vector, say vis[][], for keeping track of a position say (i, j) whether it has been already visited or not.
  • Initialize a stack<pair<int, int>> say S to implement the DFS traversal.
  • First push the first cell (0, 0) in the stack S marking the cell visited.
  • Iterate while stack S is not empty:
    • In each iteration, mark the top element of stack say (i, j) visited and print the element at that position and remove the top element from the stack S.
    • Push the adjacent cells i.e (i + 1, j), (i, j + 1), (i – 1, j) and (i, j – 1) into the stack if respective positions are valid i.e., not visited and are within the matrix.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Direction vectors
int dRow[] = { -1, 0, 1, 0 };
int dCol[] = { 0, 1, 0, -1 };
 
// Function to check if curruent
// position is valid or not
bool isValid(vector<vector<bool> >& vis,
             int row, int col,
             int COL, int ROW)
{
    // Check if the cell is out
    // of bounds
    if (row < 0 || col < 0 || col > COL - 1
        || row > ROW - 1)
        return false;
 
    // Check if the cell is visited
    if (vis[row][col] == true)
        return false;
 
    return true;
}
 
// Function to print the matrix elements
void DFS_iterative(vector<vector<int> > grid,
                   int M, int N)
{
 
    // Stores if a position in the
    // matrix been visited or not
    vector<vector<bool> > vis(
        M + 5, vector<bool>(N + 5, false));
 
    // Initialize stack to implement DFS
    stack<pair<int, int> > st;
 
    // Push the first position of grid[][]
    // in the stack
    st.push({ 0, 0 });
 
    // Mark the cell (0, 0) visited
    vis[0][0] = true;
 
    while (!st.empty()) {
 
        // Stores top element of stack
        pair<int, int> p = st.top();
 
        // Delete the top() element
        // of stack
        st.pop();
 
        int row = p.first;
        int col = p.second;
 
        // Print element at the cell
        cout << grid[row][col] << " ";
 
        // Traverse in all four adjacent
        // sides of current positions
        for (int i = 0; i < 4; i++) {
 
            int x = row + dRow[i];
            int y = col + dCol[i];
 
            // Check if x and y is valid
            // position and then push
            // the position of current
            // cell in the stack
            if (isValid(vis, x, y, M, N)) {
 
                // Push the current cell
                st.push({ x, y });
 
                // Mark current cell visited
                vis[x][y] = true;
            }
        }
    }
}
 
// Driver Code
int main()
{
    // Given matrix
    vector<vector<int> > grid{ { 1, 2, 3, 4 },
                               { 5, 6, 7, 8 },
                               { 9, 10, 11, 12 },
                               { 13, 14, 15, 16 } };
 
    // Row of the matrix
    int M = grid.size();
 
    // Column of the matrix
    int N = grid[0].size();
 
    DFS_iterative(grid, M, N);
 
    return 0;
}

Java




// Java program for the above approach
import java.util.*;
public class Main
{
    public static class Pair {
        int Item1, Item2;
        public Pair(int Item1, int Item2) {
            this.Item1 = Item1;
            this.Item2 = Item2;
        }
    }
         
    // Direction vectors
    static int[] dRow = { -1, 0, 1, 0 };
    static int[] dCol = { 0, 1, 0, -1 };
       
    static Vector<Vector<Boolean>> vis;
   
    // Function to check if curruent
    // position is valid or not
    static boolean isValid(int row, int col, int COL, int ROW)
    {
        
        // Check if the cell is out
        // of bounds
        if (row < 0 || col < 0 || col > COL - 1 || row > ROW - 1)
            return false;
   
        // Check if the cell is visited
        if (vis.get(row).get(col) == true)
            return false;
   
        return true;
    }
   
    // Function to print the matrix elements
    static void DFS_iterative(int[][] grid, int M, int N)
    {
   
        // Stores if a position in the
        // matrix been visited or not
        vis = new Vector<Vector<Boolean>>();
        for(int i = 0; i < M + 5; i++)
        {
            vis.add(new Vector<Boolean>());
            for(int j = 0; j < N + 5; j++)
            {
                vis.get(i).add(false);
            }
        }
   
        // Initialize stack to implement DFS
        Vector<Pair> st = new Vector<Pair>();
   
        // Push the first position of grid[][]
        // in the stack
        st.add(new Pair(0, 0));
   
        // Mark the cell (0, 0) visited
        vis.get(0).set(0, true);
   
        while (st.size() > 0) {
   
            // Stores top element of stack
            Pair p = st.get(st.size() - 1);
   
            // Delete the top() element
            // of stack
            st.remove(st.size() - 1);
   
            int row = p.Item1;
            int col = p.Item2;
   
            // Print element at the cell
            System.out.print(grid[row][col] + " ");
   
            // Traverse in all four adjacent
            // sides of current positions
            for (int i = 0; i < 4; i++) {
   
                int x = row + dRow[i];
                int y = col + dCol[i];
   
                // Check if x and y is valid
                // position and then push
                // the position of current
                // cell in the stack
                if (isValid(x, y, M, N)) {
   
                    // Push the current cell
                    st.add(new Pair(x, y));
   
                    // Mark current cell visited
                    vis.get(x).set(y, true);
                }
            }
        }
    }
     
    public static void main(String[] args)
    {
       
        // Given matrix
        int[][] grid = { { 1, 2, 3, 4 },
                       { 5, 6, 7, 8 },
                       { 9, 10, 11, 12 },
                       { 13, 14, 15, 16 } };
       
        // Row of the matrix
        int M = 4;
       
        // Column of the matrix
        int N = 4;
       
        DFS_iterative(grid, M, N);
    }
}
 
// This code is contributed by suresh07.

Python3




# Python3 program for the above approach
 
# Direction vectors
dRow = [ -1, 0, 1, 0 ]
dCol = [ 0, 1, 0, -1 ]
  
vis = []
 
# Function to check if curruent
# position is valid or not
def isValid(row, col, COL, ROW):
    global vis
     
    # Check if the cell is out
    # of bounds
    if (row < 0 or col < 0 or col > COL - 1 or row > ROW - 1):
        return False
 
    # Check if the cell is visited
    if (vis[row][col] == True):
        return False
 
    return True
 
# Function to print the matrix elements
def DFS_iterative(grid, M, N):
    global vis
    # Stores if a position in the
    # matrix been visited or not
    vis = []
    for i in range(M+5):
        vis.append([])
        for j in range(N + 5):
            vis[i].append(False)
 
    # Initialize stack to implement DFS
    st = []
 
    # Push the first position of grid[][]
    # in the stack
    st.append([ 0, 0 ])
 
    # Mark the cell (0, 0) visited
    vis[0][0] = True
 
    while (len(st) > 0):
        # Stores top element of stack
        p = st[-1]
 
        # Delete the top() element
        # of stack
        st.pop()
 
        row = p[0]
        col = p[1]
 
        # Print element at the cell
        print(grid[row][col], "", end = "")
 
        # Traverse in all four adjacent
        # sides of current positions
        for i in range(4):
            x = row + dRow[i]
            y = col + dCol[i]
 
            # Check if x and y is valid
            # position and then push
            # the position of current
            # cell in the stack
            if (isValid(x, y, M, N)):
                # Push the current cell
                st.append([ x, y ])
 
                # Mark current cell visited
                vis[x][y] = True
 
# Given matrix
grid = [ [ 1, 2, 3, 4 ],
        [ 5, 6, 7, 8 ],
        [ 9, 10, 11, 12 ],
        [ 13, 14, 15, 16 ] ]
 
# Row of the matrix
M = len(grid)
 
# Column of the matrix
N = len(grid[0])
 
DFS_iterative(grid, M, N)
 
# This code is contributed by mukesh07.

C#




// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG {
     
    // Direction vectors
    static int[] dRow = { -1, 0, 1, 0 };
    static int[] dCol = { 0, 1, 0, -1 };
      
    static List<List<bool>> vis;
  
    // Function to check if curruent
    // position is valid or not
    static bool isValid(int row, int col, int COL, int ROW)
    {
       
        // Check if the cell is out
        // of bounds
        if (row < 0 || col < 0 || col > COL - 1 || row > ROW - 1)
            return false;
  
        // Check if the cell is visited
        if (vis[row][col] == true)
            return false;
  
        return true;
    }
  
    // Function to print the matrix elements
    static void DFS_iterative(int[,] grid, int M, int N)
    {
  
        // Stores if a position in the
        // matrix been visited or not
        vis = new List<List<bool>>();
        for(int i = 0; i < M + 5; i++)
        {
            vis.Add(new List<bool>());
            for(int j = 0; j < N + 5; j++)
            {
                vis[i].Add(false);
            }
        }
  
        // Initialize stack to implement DFS
        List<Tuple<int,int>> st = new List<Tuple<int,int>>();
  
        // Push the first position of grid[][]
        // in the stack
        st.Add(new Tuple<int,int>(0, 0));
  
        // Mark the cell (0, 0) visited
        vis[0][0] = true;
  
        while (st.Count > 0) {
  
            // Stores top element of stack
            Tuple<int,int> p = st[st.Count - 1];
  
            // Delete the top() element
            // of stack
            st.RemoveAt(st.Count - 1);
  
            int row = p.Item1;
            int col = p.Item2;
  
            // Print element at the cell
            Console.Write(grid[row,col] + " ");
  
            // Traverse in all four adjacent
            // sides of current positions
            for (int i = 0; i < 4; i++) {
  
                int x = row + dRow[i];
                int y = col + dCol[i];
  
                // Check if x and y is valid
                // position and then push
                // the position of current
                // cell in the stack
                if (isValid(x, y, M, N)) {
  
                    // Push the current cell
                    st.Add(new Tuple<int,int>(x, y));
  
                    // Mark current cell visited
                    vis[x][y] = true;
                }
            }
        }
    }
     
  static void Main()
  {
     
    // Given matrix
    int[,] grid = { { 1, 2, 3, 4 },
                   { 5, 6, 7, 8 },
                   { 9, 10, 11, 12 },
                   { 13, 14, 15, 16 } };
  
    // Row of the matrix
    int M = 4;
  
    // Column of the matrix
    int N = 4;
  
    DFS_iterative(grid, M, N);
  }
}
 
// This code is contributed by divyesh072019.

Javascript




<script>
    // Javascript program for the above approach
     
    // Direction vectors
    let dRow = [ -1, 0, 1, 0 ];
    let dCol = [ 0, 1, 0, -1 ];
     
    let vis;
 
    // Function to check if curruent
    // position is valid or not
    function isValid(row, col,
                 COL, ROW)
    {
        // Check if the cell is out
        // of bounds
        if (row < 0 || col < 0 || col > COL - 1
            || row > ROW - 1)
            return false;
 
        // Check if the cell is visited
        if (vis[row][col] == true)
            return false;
 
        return true;
    }
 
    // Function to print the matrix elements
    function DFS_iterative(grid, M, N)
    {
 
        // Stores if a position in the
        // matrix been visited or not
        vis = [];
        for(let i = 0; i < M + 5; i++)
        {
            vis.push([]);
            for(let j = 0; j < N + 5; j++)
            {
                vis[i].push(false);
            }
        }
 
        // Initialize stack to implement DFS
        let st = [];
 
        // Push the first position of grid[][]
        // in the stack
        st.push([ 0, 0 ]);
 
        // Mark the cell (0, 0) visited
        vis[0][0] = true;
 
        while (st.length > 0) {
 
            // Stores top element of stack
            let p = st[st.length - 1];
 
            // Delete the top() element
            // of stack
            st.pop();
 
            let row = p[0];
            let col = p[1];
 
            // Print element at the cell
            document.write(grid[row][col] + " ");
 
            // Traverse in all four adjacent
            // sides of current positions
            for (let i = 0; i < 4; i++) {
 
                let x = row + dRow[i];
                let y = col + dCol[i];
 
                // Check if x and y is valid
                // position and then push
                // the position of current
                // cell in the stack
                if (isValid(x, y, M, N)) {
 
                    // Push the current cell
                    st.push([ x, y ]);
 
                    // Mark current cell visited
                    vis[x][y] = true;
                }
            }
        }
    }
     
    // Given matrix
    let grid = [ [ 1, 2, 3, 4 ],
                [ 5, 6, 7, 8 ],
                [ 9, 10, 11, 12 ],
                [ 13, 14, 15, 16 ] ];
  
    // Row of the matrix
    let M = grid.length;
  
    // Column of the matrix
    let N = grid[0].length;
  
    DFS_iterative(grid, M, N);
 
// This code is contributed by decode2207.
</script>
Output: 
1 5 9 13 14 15 16 12 8 7 3 4 11 10 6 2

 

Time Complexity: O(N*M)
Auxiliary Space: O(N*M)

 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!