Matrix or Grid Data Structure

What is Matrix Data Structure?

Matrix, also referred to as a grid, is a special two-dimensional array in which elements are arranged in rows and columns. We can also say it is an array nested within another array. Each element of the matrix can be identified by the row and column index.

Generally, matrix data structure is used to store and manipulate two-dimensional structures, such as graphs, maps, tables, etc. It can also be used to represent linear equations, transformations, rotations, and other mathematical concepts.

Matrix

Declaration and Initialization of a Matrix

To declare a matrix, we simply need to specify the data type and name of the matrix followed by two square brackets. These square brackets specify rows and columns of the matrix.

The process of declaration and initialization of the Matrix is very much similar in all the programming languages. Let's look at the syntax for creating a matrix in various programming languages − 

data_type array_name[rows][cols] = {elements separated by commas};

In Python programming language, specifying data type is not necessary −

array_name[rows][cols] = {elements separated by commas};

Need for Matrix

Matrices are very useful in various fields including mathematics, computer science, graphics, robotics and many more. Companies worldwide store information of their users in the form of matrix which helps in making recommendations and targeted marketing.

Whether it is our favourite movies or games, all are built with the help of matrix calculation. Many scientific innovations and research directly or indirectly require these calculations.

Matrix Representation

We can represent a Matrix data structure in the form of a table where each element is stored in a single cell. The figure below illustrates how a matrix is represented −

Matrix Representation

From the above illustration, we can conclude the following important points −

  • Index starts with 0.

  • A matrix of 5x3 dimension would have 15 elements.

  • We can access or locate any element with the help of its row and column indices.

Basic Operations on Matrix

We can manipulate a given matrix data structure by performing various operations on it, such as rotation, addition, multiplication and so on.

Following are the basic operations that can be performed on a given matrix −

  • Accessing − Accessing a particular row or column of the matrix.
  • Searching − Locating a particular element of the matrix.
  • Sorting − Arranging matrix elements in a specific order.
  • Insertion − Adds a row at the specified index.
  • Deletion − Deletes a row from the matrix.

Matrix - Access Operation

In the access operation, we print the elements of a particular row or column.

Algorithm

Following is an algorithm to access elements of a matrix −

1. Start
2. Declare and initialize a matrix.
3. Access the required row.
4. Print the result.
5. Stop

Example

Here, we see a practical implementation of access operation, where we try to print elements of a row −

C C++ Java Python 
#include <stdio.h>
int main() {
   // declaration and initialization of a 3x3 matrix
   int matrix[3][3] = {{1, 2, 1}, {4, 5, 4}, {7, 8, 7}}; 
   // accessing the second row
   int* rowScnd = matrix[1]; 
   // loop to print the result
   printf("Accessing a row: ");
   for (int i = 0; i < 3; i++) {
      printf("%d ", rowScnd[i]);
   }
}

#include <iostream>
using namespace std;
int main() {
   // declaration and initialization of a 3x3 matrix
   int matrix[3][3] = {{1, 2, 1}, {4, 5, 4}, {7, 8, 7}}; 
   // accessing the second row
   int* rowScnd = matrix[1]; 
   // loop to print the result
   cout<< "Accessing a row: ";
   for (int i = 0; i < 3; i++) { 
      cout << rowScnd[i] << " "; 
   }
   cout << endl; 
}

import java.util.Arrays;
public class Main {
   public static void main(String[] args) {
      // declaration and initialization of a 3x3 matrix
      int matrix[][] = {{1, 2, 1}, {4, 5, 4}, {7, 8, 7}}; 
      // accessing the second row
      int rowScnd[] = matrix[1]; 
      // printing the result
      System.out.println("Accessing a row: " + Arrays.toString(rowScnd)); 
   }
}

# declaration and initialization of a 3x3 matrix
matrix = [[1, 2, 1], [4, 5, 4], [7, 8, 7]] 
# accessing the second row
rowScnd = matrix[1] 
# printing the result
print("Accessing a row:" )
print(rowScnd)

Output

Accessing a row: 4 5 4

Matrix - Search Operation

To search for the specified element in a given matrix, we need to loop through each row and column and compare the element with the value we are looking for.

Algorithm

The following algorithm demonstrates how to search an element of a given matrix −

1. Start
2. Declare and initialize a matrix.
3. Define the target element.
4. Use a for loop to search elements in the row.
5. Define another for loop to search elements in the column.
6. If found return the indices, otherwise return [-1, -1].
7. Stop

Example

Let's see a practical example of search operation in various programming languages −

C C++ Java Python 
#include <stdio.h>
#include <stdlib.h>
// Function to search element
int* srchmatrix(int matrix[3][3], int target) {
    // array to hold the result
    static int indX[2];
    // Looping through each row
    for (int i = 0; i < 3; i++) {
        // Looping through each column
        for (int j = 0; j < 3; j++) {
            // Comparing the element with the targeted element
            if (matrix[i][j] == target) {
                // to return the row and column indices
                int* indX = malloc(2 * sizeof(int));
                indX[0] = i;
                indX[1] = j;
                return indX;
            }
        }
    }
    // return negative value if element not found
    indX[0] = -1;
    indX[1] = -1;
    return indX;
}
int main() {
    // declaration and initialization of a 3x3 matrix
    int matrix[3][3] = {{1, 2, 1}, {4, 5, 4}, {7, 8, 7}};
    // calling the function
    int* indX = srchmatrix(matrix, 5);
    // to print the result
    printf("The specified element is at index: [%d, %d]\n", indX[0], indX[1]);
        free(indX);  
    return 0;
}

#include <iostream>
using namespace std;
// Function to search element
int* srchmatrix(int matrix[3][3], int targtElem) {
   // array to hold the result
   static int indX[2];
   // Looping through each row
   for (int i = 0; i < 3; i++) {
      // Looping through each column
      for (int j = 0; j < 3; j++) {
         // Comparing the element with the targeted element
         if (matrix[i][j] == targtElem) {
            // to return the row and column indices
            indX[0] = i;
            indX[1] = j;
            return indX;
         }
      }
   }
   // return negative value if element not found
   indX[0] = -1;
   indX[1] = -1;
   return indX;
}
int main() {
   // declaration and initialization of a 3x3 matrix
   int matrix[3][3] = {{1, 2, 1}, {4, 5, 4}, {7, 8, 7}};
   // calling the function
   int* indX = srchmatrix(matrix, 5);
   // to print the result
   cout << "The specified element is at index: [" << indX[0] << ", " << indX[1] << "]" << endl;
   return 0;
}

public class Main {
   // method to search element
   public static int[] srchmatrix(int[][] matrix, int targtElem) {
      // Looping through each row
      for (int i = 0; i < matrix.length; i++) {
         // Looping through each column
         for (int j = 0; j < matrix[i].length; j++) {
            // Comparing the element with the desired element
            if (matrix[i][j] == targtElem) {
               // to return the row and column indices
               return new int[]{i, j};
            }
         }
      }
      // return negative value if element not found
      return new int[]{-1, -1};
   }
   public static void main(String[] args) {
      // declaration and initialization of a 3x3 matrix
      int[][] matrix = {{1, 2, 1}, {4, 5, 4}, {7, 8, 7}};
      // desired element we are looking for
      int targtElem = 5;
      // calling the method 
      int[] indX = srchmatrix(matrix, targtElem);
      // printing the result
      System.out.println("The specified element is at index: [" + indX[0] + ", " + indX[1] + "]");
   }
}


# declaration and initialization of a 3x3 matrix
matrix = [[1, 2, 1], [4, 5, 4], [7, 8, 7]] 
# method to search element
def searchMatrix(matrix, targtElem):
  # Looping through each row
  for i in range(len(matrix)):
    # Looping through each column
    for j in range(len(matrix[i])):
      # Comparing the element with the desired element
      if matrix[i][j] == targtElem:
        # to return the row and column indices
        return (i, j)
  # Return negative value if element not found
  return (-1, -1)
# desired element we are looking for
targtElem = 5
# calling the method 
indX = searchMatrix(matrix, targtElem)
# printing the result
print(f"The specified element is at index: {indX}")

Output

The specified element is at index: [1, 1]

Matrix - Sorting Operation

In the sort operation, we arrange the elements of the given matrix in a specified order, such as ascending or descending.

Algorithm

The algorithm to sort elements of a matrix in ascending order is as follows −

1. Start
2. Declare and initialize a matrix.
3. Compare and sort each element of the specified row.
4. Print the result.
5. Stop

Example

In the following example, we see a practical implementation of sorting operation −

C C++ Java Python 
#include <stdio.h>
// function to sort the array
void araySort(int mat[], int n) {
   for (int i = 0; i < n-1; i++) {     
      for (int j = 0; j < n-i-1; j++) {
         if (mat[j] > mat[j+1]) {
            // swapping mat[j] and mat[j+1]
            int temp = mat[j];
            mat[j] = mat[j+1];
            mat[j+1] = temp;
         }
      }
   }
}
int main() {
    // declaration and initialization of 3x4 matrix
    int matrix[3][4] = {{12, 10, 7, 36}, {20, 9, 8, 4}, {15, 73, 83, 13}};
    // Sorting the first row 
    araySort(matrix[0], 4);
    // Printing the result
    printf("The matrix after sorting first row: \n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }
    return 0;
}

#include <iostream>
#include <algorithm>
using namespace std;
int main() {
   // declaration and initialization of 3x4 matrix
   int matrix[3][4] = {{12, 10, 7, 36}, {20, 9, 8, 4}, {15, 73, 83, 13}};
   // Sorting the first row 
   sort(matrix[0], matrix[0] + 4);
   // Printing the result
   cout << "The matrix after sorting first row: " << endl;
   for (int i = 0; i < 3; i++) {
      for (int j = 0; j < 4; j++) {
         cout << matrix[i][j] << " ";
      }
      cout << endl;
   }
   return 0;
}

import java.util.Arrays;
public class Main {
   public static void main(String []args) {
      // declaration and initialization of 3x4 matrix
      int[][] matrix = {{12, 10, 7, 36}, {20, 9, 8, 4}, {15, 73, 83, 13}};
      // Sorting the first row 
      Arrays.sort(matrix[0]);
      // Printing the result
      System.out.println("The matrix after sorting first row: " );
      for (int i = 0; i < matrix.length; i++) {
         for (int j = 0; j < matrix[i].length; j++) {
            System.out.print(matrix[i][j] + " ");
         }
         System.out.println();
      }
   }
}

# declaration and initialization of 3x4 matrix
matrix = [[12, 10, 7, 36], [20, 9, 8, 4], [15, 73, 83, 13]]
# Sorting the first row 
matrix[0].sort()
# Printing the result
print("The matrix after sorting first row: ")
for row in matrix:
    print(' '.join(map(str, row)))

Output

The matrix after sorting first row: 
7 10 12 36 
20 9 8 4 
15 73 83 13

Matrix - Insertion Operation

In the insertion operation, we insert a row at the specified position of the matrix.

Algorithm

Following is an algorithm to insert a row into a given matrix at second position −

1. Start
2. Declare and initialize a matrix.
3. Define another matrix. 
4. Copy the first row of original matrix to new matrix.
5. Insert the required row at second index.
6. Copy the remaining rows.
7. Print the result.
8. Stop

Example

The below example practically illustrates the insertion operation in different programming languages −

C C++ Java Python 
#include <stdio.h>
int main() {
    // The original matrix
    int matrix[2][3] = {{19, 14, 21}, {22, 91, 81}};
    // Create a new matrix with an extra row
    int newmatrix[3][3];
    // Copy the first row of the original matrix to the new matrix
    for (int j = 0; j < 3; j++) {
        newmatrix[0][j] = matrix[0][j];
    }
    // Adding second row to the new matrix
    int newRow[3] = {53, 63, 73};
    for (int j = 0; j < 3; j++) {
        newmatrix[1][j] = newRow[j];
    }
    // Copying the remaining rows of the original matrix to the new matrix
    for (int i = 2; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            newmatrix[i][j] = matrix[i - 1][j];
        }
    }
    // Printing the new matrix
    printf("The new Matrix after adding a row: \n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            printf("%d ", newmatrix[i][j]);
        }
        printf("\n");
    }
    return 0;
}

#include <iostream>
#include <algorithm>
using namespace std;
int main() {
   // The original matrix
   int matrix[2][3] = {{19, 14, 21}, {22, 91, 81}};
   // Create a new matrix with an extra row
   int newmatrix[3][3];
   // Copy the first row of the original matrix to the new matrix
   copy(begin(matrix[0]), end(matrix[0]), begin(newmatrix[0]));
   // Adding second row to the new matrix
   int newRow[3] = {53, 63, 73};
   copy(begin(newRow), end(newRow), begin(newmatrix[1]));
   // Copying the remaining rows of the original matrix to the new matrix
   copy(begin(matrix[1]), end(matrix[1]), begin(newmatrix[2]));
   // Printing the new matrix
   cout << "The new Matrix after adding a row: " << endl;
   for (int i = 0; i < 3; i++) {
   for (int j = 0; j < 3; j++) {
      cout << newmatrix[i][j] << ' ';
   }
   cout << '\n';
   }
   return 0;
}

import java.util.Arrays;
public class Main {
   public static void main(String[] args) {
      // the original matrix
      int[][] matrix = {{19, 14, 21}, {22, 91, 81}};
      // Create a new matrix with an extra row
      int[][] newmatrix = new int[matrix.length + 1][matrix[0].length];
      // Copy the first row of the original matrix to the new matrix
      for (int j = 0; j < matrix[0].length; j++) {
         newmatrix[0][j] = matrix[0][j];
      }
      // adding second row to the new matrix
      int[] newRow = {53, 63, 73};
      for (int j = 0; j < newRow.length; j++) {
         newmatrix[1][j] = newRow[j];
      }
      // Copying the remaining rows of the original matrix to the new matrix
      for (int i = 2; i < newmatrix.length; i++) {
         for (int j = 0; j < matrix[0].length; j++) {
            newmatrix[i][j] = matrix[i - 1][j];
         }
      }
      // Printing the new matrix
      System.out.println("The new Matrix after adding a row: ");
      for (int i = 0; i < newmatrix.length; i++) {
         for (int j = 0; j < newmatrix[0].length; j++) {
            System.out.print(newmatrix[i][j] + " ");
         }
         System.out.println();
      }
   }
}

# The original matrix
matrix = [[19, 14, 21], [22, 91, 81]]
# Create a new matrix with an extra row
newmatrix = matrix.copy()
# Adding second row to the new matrix
newRow = [53, 63, 73]
newmatrix.insert(1, newRow)
# Printing the new matrix
print("The new Matrix after adding a row: ")
for row in newmatrix:
    print(' '.join(map(str, row)))

Output

The new Matrix after adding a row: 
19 14 21 
53 63 73 
22 91 81

Matrix - Deletion Operation

The deletion operation removes a particular row from the matrix.

Algorithm

Following is an algorithm to perform deletion operation on a given matrix −

1. Start
2. Declare and initialize a matrix.
3. Define another matrix. 
4. Copy all elements except the row to be deleted.
5. Print the new matrix.
6. Stop

Example

Here, we see a practical implementation of deletion operation −

C C++ Java Python 
#include <stdio.h>
// Function to delete a row from the matrix
void deleteRow(int mat[3][3], int rowIndex, int rows, int cols) {
    // Create a new matrix with one less row
    int newMat[2][3];
    // Copy the elements except the row to be deleted
    int newRow = 0;
    // Loop through the rows of original matrix
    for (int i = 0; i < rows; i++) {
        // Skip the row to be deleted
        if (i != rowIndex) {
            // Loop through the cols of original matrix
            for (int j = 0; j < cols; j++) {
                // Copy the element from mat to newMat
                newMat[newRow][j] = mat[i][j];
            }
            newRow++; // Increment the row index
        }
    }
    // Print the new matrix
    printf("The new Matrix after deleting a row: \n");
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%d ", newMat[i][j]);
        }
        printf("\n");
    }
}
int main() {
    // The original matrix
    int matrix[3][3] = {{19, 14, 21}, {53, 63, 73}, {22, 91, 81}};
    // Delete the first row
    deleteRow(matrix, 0, 3, 3);
    return 0;
}

#include <iostream>
using namespace std;
// Function to delete a row from the matrix
void deleteRow(int mat[3][3], int rowIndex, int rows, int cols) {
    // Create a new matrix with one less row
    int newMat[2][3];
    // Copy the elements except the row to be deleted
    int newRow = 0;
    // Loop through the rows of original matrix
    for (int i = 0; i < rows; i++) {
        // Skip the row to be deleted
        if (i != rowIndex) {
            // Loop through the cols of original matrix
            for (int j = 0; j < cols; j++) {
                // Copy the element from mat to newMat
                newMat[newRow][j] = mat[i][j];
            }
            newRow++; // Increment the row index
        }
    }
    // Print the new matrix
    cout << "The new Matrix after deleting a row: \n";
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < cols; j++) {
            cout << newMat[i][j] << ' ';
        }
        cout << '\n';
    }
}
int main() {
    // The original matrix
    int matrix[3][3] = {{19, 14, 21}, {53, 63, 73}, {22, 91, 81}};
    // Delete the first row
    deleteRow(matrix, 0, 3, 3);
    return 0;
}


import java.util.Arrays;
public class Main {
    // method to delete row
    public static int[][] deleteRow(int[][] mat, int rowIndex) {
        // get the number of rows and columns 
        int rows = mat.length;
        int cols = mat[0].length;
        // create a new matrix with one less row
        int[][] newMat = new int[rows - 1][cols];
        // copy the elements except the row to be deleted
        int newRow = 0; 
        // loop through the rows of original matrix
        for (int i = 0; i < rows; i++) { 
            // skip the row to be deleted
            if (i != rowIndex) { 
                // loop through the cols of original matrix
                for (int j = 0; j < cols; j++) { 
                    // copy the element from mat to newMat
                    newMat[newRow][j] = mat[i][j]; 
                }
                newRow++; // increment the row index
            }
        }
        // return the new matrix
        return newMat;
    }
    public static void main(String[] args) {
        // the original matrix
        int[][] matrix = {{19, 14, 21}, {53, 63, 73}, {22, 91, 81}};
        // delete the first row
        int[][] newmatrix = deleteRow(matrix, 0);
        // Printing the new matrix
        System.out.println("The new Matrix after deleting a row: ");
        for (int i = 0; i < newmatrix.length; i++) {
            for (int j = 0; j < newmatrix[0].length; j++) {
                System.out.print(newmatrix[i][j] + " ");
            }
            System.out.println();
        }
    }
}

# The original matrix
matrix = [[19, 14, 21], [53, 63, 73], [22, 91, 81]]
# Delete the first row
newmatrix = matrix[1:]
# Printing the new matrix
print("The new Matrix after deleting a row: ")
for row in newmatrix:
    print(' '.join(map(str, row)))

Output

The new Matrix after deleting a row: 
53 63 73 
22 91 81
Advertisements