Introduction to Matrix or Grid Data Structure – Two Dimensional Array

Last Updated : 16 Apr, 2024

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.

C++ ```#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; } ``` C ```#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; } ``` Java ```/*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]; } } ``` Python3 ```# 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) ``` C# ```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]; } } ``` JavaScript ```// 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:

C++ ```#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; } ``` C ```#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; } ``` Java ```/*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 } }; } } ``` Python3 ```# Initializing a 2-D array with values arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]; ``` C# ```using System; public class GFG { static public void Main() { int[, ] arr = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } }; } } ``` JavaScript ```// 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.

C++ ```#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; } ``` C ```#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; } ``` Java ```/*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]); } } ``` Python3 ```# 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]) ``` C# ```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]); } } ``` JavaScript ```// 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.

C++ ```#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; } ``` C ```#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; } ``` Java ```/*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 ``` Python3 ```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("") ``` C# ```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__ ``` Javascript ```// 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. ```

Output
```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:

C++ ```#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 ```// 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. ``` Python3 ```# 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# ```// 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"); } } } ``` Javascript ``` <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> ```

Output
`YES`

4. Sorting Matrix Data Structure:

We can sort a matrix in two-ways:

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.

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

• 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.

Related Article:

Previous
Next