Checking if a Matrix is a Diagonal Matrix in Java

In this blog post, we will explore how to check if a given matrix is a diagonal matrix using Java. This problem is a common one in matrix manipulations and helps in understanding both matrix traversal and conditional checks in a structured format.

What is a Diagonal Matrix?

A matrix is called a diagonal matrix if all its non-diagonal elements are zero. In simpler terms, only the elements on the main diagonal (from the top-left corner to the bottom-right corner) can have non-zero values, while all other elements must be zero.

For example:

Diagonal Matrix:

1 0 0
0 5 0
0 0 9

Non-Diagonal Matrix:

1 2 0
0 5 3
4 0 9

The second matrix is not a diagonal matrix because the element at position (1, 2) is 2, and at (2, 3) it is 3, both of which should be 0 for it to be considered diagonal.

Approach to the Solution

To check if a matrix is a diagonal matrix:

1. Traverse the entire matrix.
2. For each element, check if it is a diagonal element.
   • If the element is on the main diagonal, it can be non-zero.
   • If the element is not on the main diagonal, it must be zero.
3. If any non-diagonal element is non-zero, the matrix is not a diagonal matrix.

Java Implementation

Below is a simple Java program to check whether a given matrix is a diagonal matrix or not:

public class DiagonalMatrixChecker {

    // Function to check if the matrix is a diagonal matrix
    public static boolean isDiagonalMatrix(int[][] matrix) {
        int rows = matrix.length;
        int cols = matrix[0].length;

        // Check if the matrix is square
        if (rows != cols) {
            return false;
        }

        // Traverse through the matrix
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                // For non-diagonal elements, check if they are zero
                if (i != j && matrix[i][j] != 0) {
                    return false;
                }
            }
        }

        // If all non-diagonal elements are zero, return true
        return true;
    }

    // Main function to test the diagonal matrix checker
    public static void main(String[] args) {
        // Example of a diagonal matrix
        int[][] diagonalMatrix = {
            {1, 0, 0},
            {0, 5, 0},
            {0, 0, 9}
        };

        // Example of a non-diagonal matrix
        int[][] nonDiagonalMatrix = {
            {1, 2, 0},
            {0, 5, 3},
            {4, 0, 9}
        };

        System.out.println("Is diagonalMatrix a diagonal matrix? " + isDiagonalMatrix(diagonalMatrix));
        System.out.println("Is nonDiagonalMatrix a diagonal matrix? " + isDiagonalMatrix(nonDiagonalMatrix));
    }
}

Explanation

1. Check for Square Matrix: Before checking for diagonal elements, we must ensure the matrix is square. A matrix is square if the number of rows is equal to the number of columns. If not, it cannot be a diagonal matrix.

   
   if (rows != cols) {
       return false;
   }
       

2. Traverse the Matrix: We use a nested loop to traverse each element in the matrix. If the element is a non-diagonal element (i != j), we check if it is zero. If any non-diagonal element is non-zero, the matrix is immediately considered not diagonal.

   
   for (int i = 0; i < rows; i++) {
       for (int j = 0; j < cols; j++) {
           if (i != j && matrix[i][j] != 0) {
               return false;
           }
       }
   }
       

3. Return the Result: If no violations are found (i.e., all non-diagonal elements are zero), the matrix is declared diagonal.

   
   return true;
       

Output

When you run the program, the output will be:

Is diagonalMatrix a diagonal matrix? true
Is nonDiagonalMatrix a diagonal matrix? false

Time Complexity

The time complexity of this approach is O(n²), where n is the number of rows (or columns) of the matrix. This is because we need to traverse each element of the matrix once.

Conclusion

Checking if a matrix is a diagonal matrix is a simple problem that can be efficiently solved by iterating through the matrix and applying a few conditional checks. It is a great way to practice nested loops and matrix manipulation in Java.

This pattern of matrix traversal is foundational and can be extended to solve other types of matrix-related problems, such as checking for identity matrices, sparse matrices, or upper/lower triangular matrices.

Happy coding!