Introduction to Matrix or Grid Data Structure – Two Dimensional Array

Matrix or Grid is a two-dimensional array mostly used in mathematical and scientific calculations. It is also considered as an array of arrays, where array at each index has the same size. In this article, we will cover all the basics of Matrix, the Operations on Matrix, its implementation, advantages, disadvantages which will help you solve all the problems based on Matrix Data Structure.

What is a Matrix Data Structure?

Matrix Data Structure is a two-dimensional array that consists of rows and columns. It is an arrangement of elements in horizontal or vertical lines of entries. It is also considered as an array of arrays, where array at each index has the same size.

Representation of Matrix Data Structure:

As you can see from the above image, the elements are organized in rows and columns. As shown in the above image the cell x[0][0] is the first element of the first row and first column. The value in the first square bracket represents the row number and the value inside the second square bracket represents the column number. (i.e, x[row][column]).

Declaration of Matrix Data Structure :

Declaration of a Matrix or two-dimensional array is very much similar to that of a one-dimensional array, given as follows.

#include <iostream>
using namespace std;

int main()
{
    // Defining number of rows and columns in matrix
    int number_of_rows = 3, number_of_columns = 3;
    // Array Declaration
    int arr[number_of_rows][number_of_columns];
    return 0;
}

#include <stdio.h>

int main() {

    // Defining number of rows and columns in matrix
    int number_of_rows = 3, number_of_columns = 3;
    // Array Declaration
    int arr[number_of_rows][number_of_columns];
  
    return 0;
}

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        // Defining number of rows and columns in matrix
        int number_of_rows = 3, number_of_columns = 3;
        // Array Declaration
        int[][] arr
            = new int[number_of_rows][number_of_columns];
    }
}

# Defining number of rows and columns in matrix
number_of_rows = 3
number_of_columns = 3
# Declaring a matrix of size 3 X 3, and initializing it with value zero
rows, cols = (3, 3)
arr = [[0]*cols]*rows
print(arr)

using System;

public class GFG {

    static public void Main()
    {
          // Defining number of rows and columns in matrix
        int number_of_rows = 3, number_of_columns = 3;
          // Array Declaration
        int[, ] arr
            = new int[number_of_rows, number_of_columns];
    }
}

// Defining number of rows and columns in matrix
number_of_rows = 3,
number_of_columns = 3;

// Declare a 2D array using array constructor
let arr = new Array(3); 

// Python declaration
for (let i = 0; i < arr.length; i++) {
    arr[i] = new Array(3); // Each row has 3 columns
}

Initializing Matrix Data Structure:

In initialization, we assign some initial value to all the cells of the matrix. Below is the implementation to initialize a matrix in different languages:

#include <iostream>
using namespace std;

int main() {
      // Initializing a 2-D array with values
    int arr[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    return 0;
}

#include <stdio.h>

int main() {

    // Initializing a 2-D array with values
    int arr[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    return 0;
}

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        // Initializing a 2-D array with values
        int arr[][]
            = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
    }
}

# Initializing a 2-D array with values
arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];

using System;

public class GFG {

    static public void Main()
    {
        int[, ] arr = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
    }
}

// Initializing a 2-D array with values
let arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];

Operations on Matrix Data Structure:

We can perform a variety of operations on the Matrix Data Structure. Some of the most common operations are:

• Access elements of Matrix
• Traversal of a Matrix
• Searching in a Matrix
• Sorting a Matrix

1. Access elements of Matrix Data Structure:

Like one-dimensional arrays, matrices can be accessed randomly by using their indices to access the individual elements. A cell has two indices, one for its row number, and the other for its column number. We can use arr[i][j] to access the element which is at the ith row and jth column of the matrix.

#include <iostream>
using namespace std;

int main()
{
    // Initializing a 2-D array with values
    int arr[3][3]
        = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };

    // Accessing elements of 2-D array
    cout << "First element of first row: " << arr[0][0]
         << "\n";
    cout << "Third element of second row: " << arr[1][2]
         << "\n";
    cout << "Second element of third row: " << arr[2][1]
         << "\n";
    return 0;
}

#include <stdio.h>

int main()
{
    // Initializing a 2-D array with values
    int arr[3][3]
        = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };

    // Accessing elements of 2-D array
    printf("First element of first row: %d\n", arr[0][0]);
    printf("Third element of second row: %d\n", arr[1][2]);
    printf("Second element of third row: %d\n", arr[2][1]);
    return 0;
}

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {

        // Initializing a 2-D array with values
        int[][] arr
            = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };

        // Accessing elements of 2-D array
        System.out.println("First element of first row: "
                           + arr[0][0]);
        System.out.println("Third element of second row: "
                           + arr[1][2]);
        System.out.println("Second element of third row: "
                           + arr[2][1]);
    }
}

# Initializing a 2-D array with values
arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# Accessing elements of 2-D array
print("First element of first row:", arr[0][0])
print("Third element of second row:", arr[1][2])
print("Second element of third row:", arr[2][1])

using System;

public class GFG {

    static public void Main()
    {

        // Initializing a 2-D array with values
        int[, ] arr
            = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };

        // Accessing elements of 2-D array
        Console.WriteLine("First element of first row: "
                          + arr[0, 0]);
        Console.WriteLine("Third element of second row: "
                          + arr[1, 2]);
        Console.WriteLine("Second element of third row: "
                          + arr[2, 1]);
    }
}

// Initializing a 2-D array with values
let arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];

// Accessing elements of 2-D array
console.log("First element of first row: " + arr[0][0]);
console.log("Third element of second row: " + arr[1][2]);
console.log("Second element of third row: " + arr[2][1]);

2. Traversal of a Matrix Data Structure:

We can traverse all the elements of a matrix or two-dimensional array by using two for-loops.

#include <bits/stdc++.h>
using namespace std;

int main()
{

    int arr[3][4] = { { 1, 2, 3, 4 },
                      { 5, 6, 7, 8 },
                      { 9, 10, 11, 12 } };
    // Traversing over all the rows
    for (int i = 0; i < 3; i++) {
        // Traversing over all the columns of each row
        for (int j = 0; j < 4; j++) {
            cout << arr[i][j] << " ";
        }
        cout << endl;
    }
    return 0;
}

#include <stdio.h>

int main()
{

    int arr[3][4] = { { 1, 2, 3, 4 },
                      { 5, 6, 7, 8 },
                      { 9, 10, 11, 12 } };
    // Traversing over all the rows
    for (int i = 0; i < 3; i++) {
        // Traversing over all the columns of each row
        for (int j = 0; j < 4; j++) {
            printf("%d ", arr[i][j]);
        }
        printf("\n");
    }
    return 0;
}

/*package whatever //do not write package name here */
import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        int[][] arr = { { 1, 2, 3, 4 },
                        { 5, 6, 7, 8 },
                        { 9, 10, 11, 12 } };
        // Traversing over all the rows
        for (int i = 0; i < 3; i++) {
            // Traversing over all the columns of each row
            for (int j = 0; j < 4; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}

// This code is contributed by lokesh

arr = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]

# Traversing over all the rows
for i in range(0, 3):
    # Traversing over all the columns of each row
    for j in range(0, 4):
        print(arr[i][j], end=" ")
    print("")

using System;

public class GFG {

    static public void Main()
    {
        int[, ] arr = new int[3, 4] { { 1, 2, 3, 4 },
                                      { 5, 6, 7, 8 },
                                      { 9, 10, 11, 12 } };
        // Traversing over all the rows
        for (int i = 0; i < 3; i++) {
            // Traversing over all the columns of each row
            for (int j = 0; j < 4; j++) {
                Console.Write(arr[i, j]);
                Console.Write(" ");
            }
            Console.WriteLine(" ");
        }
    }
}

// This code is contributed by akashish__

// JS code for above approach
let arr = [[1, 2, 3, 4],
           [5, 6, 7, 8],
           [9, 10, 11, 12]];
           
// Traversing over all the rows
for (let i = 0; i < 3; i++) {
let s="";
    // Traversing over all the columns of each row
    for (let j = 0; j < 4; j++) {
        s+=(arr[i][j]+" ");
    }
    console.log(s);
}

// This code is contributed by ishankhandelwals.

1 2 3 4 
5 6 7 8 
9 10 11 12 

3. Searching in a Matrix Data Structure:

We can search an element in a matrix by traversing all the elements of the matrix.

Below is the implementation to search an element in a matrix:

#include <bits/stdc++.h>
using namespace std;

bool searchInMatrix(vector<vector<int> >& arr, int x)
{
    int m = arr.size(), n = arr[0].size();

    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (arr[i][j] == x)
                return true;
        }
    }
    return false;
}

// Driver program to test above
int main()
{
    int x = 8;
    vector<vector<int> > arr
        = { { 0, 6, 8, 9, 11 },
            { 20, 22, 28, 29, 31 },
            { 36, 38, 50, 61, 63 },
            { 64, 66, 100, 122, 128 } };

    if (searchInMatrix(arr, x))
        cout << "YES" << endl;
    else
        cout << "NO" << endl;

    return 0;
}

// Java code for the above approach

import java.io.*;

class GFG {

  static boolean searchInMatrix(int[][] arr, int x)
  {
    int m = arr.length, n = arr[0].length;

    for (int i = 0; i < m; i++) {
      for (int j = 0; j < n; j++) {
        if (arr[i][j] == x)
          return true;
      }
    }
    return false;
  }

  public static void main(String[] args)
  {
    int x = 8;
    int[][] arr = { { 0, 6, 8, 9, 11 },
                   { 20, 22, 28, 29, 31 },
                   { 36, 38, 50, 61, 63 },
                   { 64, 66, 100, 122, 128 } };

    if (searchInMatrix(arr, x)) {
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}

// This code is contributed by lokeshmvs21.

# Python code for above approach
def searchInMatrix(arr, x):
    # m=4,n=5
    for i in range(0, 4):
        for j in range(0, 5):
            if(arr[i][j] == x):
                return 1
    return

x = 8
arr = [[0, 6, 8, 9, 11],
       [20, 22, 28, 29, 31],
       [36, 38, 50, 61, 63],
       [64, 66, 100, 122, 128]]
if(searchInMatrix(arr, x)):
    print("YES")
else:
    print("NO")

    # This code is contributed by ishankhandelwals.

// C# code for the above approach

using System;

public class GFG {
    static bool searchInMatrix(int[,] arr, int x) {
        int m = arr.GetLength(0), n = arr.GetLength(1);

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (arr[i, j] == x)
                    return true;
            }
        }
        return false;
    }

    public static void Main(string[] args) {
        int x = 8;
        int[,] arr = { { 0, 6, 8, 9, 11 },
            { 20, 22, 28, 29, 31 },
            { 36, 38, 50, 61, 63 },
            { 64, 66, 100, 122, 128 }
        };

        if (searchInMatrix(arr, x)) {
            Console.WriteLine("YES");
        } else {
            Console.WriteLine("NO");
        }
    }
}

 <script>
        // JavaScript code for the above approach



        function searchInMatrix(arr, x) {
            let m = arr.length, n = arr[0].length;

            for (let i = 0; i < m; i++) {
                for (let j = 0; j < n; j++) {
                    if (arr[i][j] == x)
                        return true;
                }
            }
            return false;
        }

        // Driver program to test above

        let x = 8;
        let arr
            = [[0, 6, 8, 9, 11],
            [20, 22, 28, 29, 31],
            [36, 38, 50, 61, 63],
            [64, 66, 100, 122, 128]];

        if (searchInMatrix(arr, x))
            document.write("YES" + "<br>");
        else
            document.write("NO" + "<br>");


 // This code is contributed by Potta Lokesh

    </script>

YES

4. Sorting Matrix Data Structure:

We can sort a matrix in two-ways:

• Sort the matrix row-wise
• Sort the matrix column-wise

Applications of Matrix Data Structure:

• In Algorithms: Matrix are frequently used in problems based on Dynamic Programming Algorithm to store the answer to already computed states.
• Image processing: Images can be represented as a matrix of pixels, where each pixel corresponds to an element in the matrix. This helps in preforming different operations on images.
• Robotics: In robotics, matrices are used to represent the position and orientation of robots and their end-effectors. They are used to calculate the kinematics and dynamics of robot arms, and to plan their trajectories.
• Transportation and logistics: Matrices are used in transportation and logistics to represent transportation networks and to solve optimization problems such as the transportation problem and the assignment problem.
• Finance: Matrices are used in finance to represent portfolios of assets, to calculate the risk and return of investments, and to perform operations such as asset allocation and optimization.
• Linear Algebra: Matrices are widely used in linear algebra, a branch of mathematics that deals with linear equations, vector spaces, and linear transformations. Matrices are used to represent linear equations and to solve systems of linear equations.

Advantages of Matrix Data Structure:

• It helps in 2D Visualization.
• It stores multiple elements of the same type using the same name.
• It enables access to items at random.
• Any form of data with a fixed size can be stored.
• It is easy to implement.

Disadvantages of Matrix Data Structure:

• Space inefficient when we need to store very few elements in the matrix.
• The matrix size should be needed beforehand.
• Insertion and deletion operations are costly if shifting occurs.
• Resizing a matrix is time-consuming.

More Practice problems on Matrix Data Structure:

Related Article:

• Learn Data Structures and Algorithms | DSA Tutorial
• Why Data Structures and Algorithms Are Important to Learn?
• The Ultimate Beginner’s Guide For DSA
• Introduction to Data Structures
• What is Algorithm | Introduction to Algorithms
• Problems on Matrix Data Structure