Find smallest and largest element from square matrix diagonals

Given a square matrix of order n*n, find the smallest and largest elements from both diagonals of the given matrix.
Examples:

Input : matrix = {
            {1, 2, 3, 4, -10},
            {5, 6, 7, 8, 6},
            {1, 2, 11, 3, 4},
            {5, 6, 70, 5, 8},
            {4, 9, 7, 1, 5}};
Output :
Principal Diagonal Smallest Element:  1
Principal Diagonal Greatest Element :11
Secondary Diagonal Smallest Element: -10
Secondary Diagonal Greatest Element: 11

The idea behind solving this problem is, First check traverse matrix and reach all diagonals element(for principle diagonal i == j and secondary diagonal i+j = size_of_matrix-1) and compare diagonal element with min and max variable and take new min and max values. and same thing for secondary diagonals.

Here is implementation of above approach:
Example 1: With O(n^2) Complexity:

C++



filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP program to find smallest and 
// largest elements of both diagonals
#include<bits/stdc++.h>
using namespace std;
  
// Function to find smallest and largest element 
// from principal and secondary diagonal
void diagonalsMinMax(int mat[5][5])
{
    // take length of matrix
    int n = sizeof(*mat) / 4;
    if (n == 0)
        return;
  
    // declare and initialize variables 
    // with appropriate value
    int principalMin = mat[0][0], 
        principalMax = mat[0][0];
    int secondaryMin = mat[n - 1][0], 
        secondaryMax = mat[n - 1][0];
  
    for (int i = 1; i < n; i++) 
    {
        for (int j = 1; j < n; j++) 
        {
  
            // Condition for principal
            // diagonal
            if (i == j)
            {
  
                // take new smallest value
                if (mat[i][j] < principalMin) 
                {
                    principalMin = mat[i][j];
                }
  
                // take new largest value
                if (mat[i][j] > principalMax)
                {
                    principalMax = mat[i][j];
                }
            }
  
            // Condition for secondary
            // diagonal
            if ((i + j) == (n - 1)) 
            {
  
                // take new smallest value
                if (mat[i][j] < secondaryMin) 
                {
                    secondaryMin = mat[i][j];
                }
  
                // take new largest value
                if (mat[i][j] > secondaryMax)
                {
                    secondaryMax = mat[i][j];
                }
            }
        }
    }
  
    cout << ("Principal Diagonal Smallest Element: ")
        << principalMin << endl;
    cout << ("Principal Diagonal Greatest Element : "
        << principalMax << endl;
  
    cout << ("Secondary Diagonal Smallest Element: "
        << secondaryMin << endl;
    cout << ("Secondary Diagonal Greatest Element: "
        << secondaryMax << endl;
}
  
// Driver code
int main()
{
    // Declare and initialize 5X5 matrix
    int matrix[5][5] = {{ 1, 2, 3, 4, -10 },
                        { 5, 6, 7, 8, 6 },
                        { 1, 2, 11, 3, 4 },
                        { 5, 6, 70, 5, 8 },
                        { 4, 9, 7, 1, -5 }};
    diagonalsMinMax(matrix);
}
  
// This code is contribuuted by
// Shashank_Sharma

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to find
// smallest and largest elements of both diagonals
  
public class GFG {
    // Function to find smallest and largest element from
    // principal and secondary diagonal
    static void diagonalsMinMax(int[][] mat)
    {
        // take length of matrix
        int n = mat.length;
        if (n == 0)
           return;
  
        // declare and initialize variables with appropriate value
        int principalMin = mat[0][0], principalMax = mat[0][0];
        int secondaryMin = mat[n-1][0], secondaryMax = mat[n-1][0];
  
        for (int i = 1; i < n; i++) {
            for (int j = 1; j < n; j++) {
  
                // Condition for principal
                // diagonal
                if (i == j) {
  
                    // take new smallest value
                    if (mat[i][j] < principalMin) {
                        principalMin = mat[i][j];
                    }
  
                    // take new largest value
                    if (mat[i][j] > principalMax) {
                        principalMax = mat[i][j];
                    }
                }
  
                // Condition for secondary
                // diagonal
                if ((i + j) == (n - 1)) {
  
                    // take new smallest value
                    if (mat[i][j] < secondaryMin) {
                        secondaryMin = mat[i][j];
                    }
  
                    // take new largest value
                    if (mat[i][j] > secondaryMax) {
                        secondaryMax = mat[i][j];
                    }
                }
            }
        }
  
        System.out.println("Principal Diagonal Smallest Element:  "
                           + principalMin);
        System.out.println("Principal Diagonal Greatest Element : "
                           + principalMax);
  
        System.out.println("Secondary Diagonal Smallest Element: "
                           + secondaryMin);
        System.out.println("Secondary Diagonal Greatest Element: "
                           + secondaryMax);
    }
  
    // Driver code
    static public void main(String[] args)
    {
  
        // Declare and initialize 5X5 matrix
        int[][] matrix = {
            { 1, 2, 3, 4, -10 },
            { 5, 6, 7, 8, 6 },
            { 1, 2, 11, 3, 4 },
            { 5, 6, 70, 5, 8 },
            { 4, 9, 7, 1, -5 }
        };
  
        diagonalsMinMax(matrix);
    }
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to find smallest and 
# largest elements of both diagonals
  
# Function to find smallest and largest element 
# from principal and secondary diagonal
def diagonalsMinMax(mat):
  
    # take length of matrix
    n = len(mat)
    if (n == 0):
        return
  
    # declare and initialize variables 
    # with appropriate value
    principalMin = mat[0][0]
    principalMax = mat[0][0]
    secondaryMin = mat[n - 1][0
    secondaryMax = mat[n - 1][0]
  
    for i in range(1, n): 
      
        for j in range(1, n): 
          
            # Condition for principal
            # diagonal
            if (i == j):
              
                # take new smallest value
                if (mat[i][j] < principalMin):
                  
                    principalMin = mat[i][j]
                  
                # take new largest value
                if (mat[i][j] > principalMax):
                  
                    principalMax = mat[i][j]
                  
            # Condition for secondary
            # diagonal
            if ((i + j) == (n - 1)): 
              
                # take new smallest value
                if (mat[i][j] < secondaryMin):
                  
                    secondaryMin = mat[i][j]
                  
                # take new largest value
                if (mat[i][j] > secondaryMax):
                  
                    secondaryMax = mat[i][j]
                  
    print("Principal Diagonal Smallest Element: "
                                     principalMin)
    print("Principal Diagonal Greatest Element : "
                                      principalMax)
  
    print("Secondary Diagonal Smallest Element: "
                                     secondaryMin)
    print("Secondary Diagonal Greatest Element: ",
                                     secondaryMax)
  
# Driver code
  
# Declare and initialize 5X5 matrix
matrix = [[ 1, 2, 3, 4, -10 ],
          [ 5, 6, 7, 8, 6 ],
          [ 1, 2, 11, 3, 4 ],
          [ 5, 6, 70, 5, 8 ],
          [ 4, 9, 7, 1, -5 ]]
diagonalsMinMax(matrix)
  
# This code is contributed by Mohit kumar 29

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to find smallest and largest
//  elements of both diagonals
using System;
  
public class GFG { 
    // Function to find smallest and largest element from 
    // principal and secondary diagonal 
    static void diagonalsMinMax(int[,] mat) 
    
        // take length of square matrix 
        int n = mat.GetLength(0); 
        if (n == 0) 
        return
  
        // declare and initialize variables with appropriate value 
        int principalMin = mat[0,0], principalMax = mat[0,0]; 
        int secondaryMin = mat[n-1,0], secondaryMax = mat[n-1,0]; 
  
        for (int i = 1; i < n; i++) { 
            for (int j = 1; j < n; j++) { 
  
                // Condition for principal 
                // diagonal 
                if (i == j) { 
  
                    // take new smallest value 
                    if (mat[i,j] < principalMin) { 
                        principalMin = mat[i,j]; 
                    
  
                    // take new largest value 
                    if (mat[i,j] > principalMax) { 
                        principalMax = mat[i,j]; 
                    
                
  
                // Condition for secondary 
                // diagonal 
                if ((i + j) == (n - 1)) { 
  
                    // take new smallest value 
                    if (mat[i,j] < secondaryMin) { 
                        secondaryMin = mat[i,j]; 
                    
  
                    // take new largest value 
                    if (mat[i,j] > secondaryMax) { 
                        secondaryMax = mat[i,j]; 
                    
                
            
        
  
        Console.WriteLine("Principal Diagonal Smallest Element: "
                        + principalMin); 
        Console.WriteLine("Principal Diagonal Greatest Element : "
                        + principalMax); 
  
        Console.WriteLine("Secondary Diagonal Smallest Element: "
                        + secondaryMin); 
        Console.WriteLine("Secondary Diagonal Greatest Element: "
                        + secondaryMax); 
    
  
    // Driver code 
    static void Main() 
    
  
        // Declare and initialize 5X5 matrix 
        int[,] matrix = { 
            { 1, 2, 3, 4, -10 }, 
            { 5, 6, 7, 8, 6 }, 
            { 1, 2, 11, 3, 4 }, 
            { 5, 6, 70, 5, 8 }, 
            { 4, 9, 7, 1, -5 } 
        }; 
  
        diagonalsMinMax(matrix); 
    
    // This code is contributed by Ryuga

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP program to find smallest and 
// largest elements of both diagonals
  
// Function to find smallest and largest element 
// from principal and secondary diagonal
function diagonalsMinMax($mat)
{
    // take length of $matrix
    $n = count($mat);
    if ($n == 0)
        return;
  
    // declare and initialize variables 
    // with appropriate value
    $principalMin = $mat[0][0];
    $principalMax = $mat[0][0];
    $secondaryMin = $mat[$n - 1][0]; 
    $secondaryMax = $mat[$n - 1][0];
  
    for ($i = 1; $i < $n; $i++) 
    {
        for ($j = 1; $j < $n; $j++) 
        {
  
            // Condition for principal
            // diagonal
            if ($i == $j)
            {
  
                // take new smallest value
                if ($mat[$i][$j] < $principalMin
                {
                    $principalMin = $mat[$i][$j];
                }
  
                // take new largest value
                if ($mat[$i][$j] > $principalMax)
                {
                    $principalMax = $mat[$i][$j];
                }
            }
  
            // Condition for secondary
            // diagonal
            if (($i + $j) == ($n - 1)) 
            {
  
                // take new smallest value
                if ($mat[$i][$j] < $secondaryMin
                {
                    $secondaryMin = $mat[$i][$j];
                }
  
                // take new largest value
                if ($mat[$i][$j] > $secondaryMax)
                {
                    $secondaryMax = $mat[$i][$j];
                }
            }
        }
    }
  
    echo "Principal Diagonal Smallest Element: ",
                             $principalMin, "\n";
    echo "Principal Diagonal Greatest Element : ",
                              $principalMax, "\n";
  
    echo "Secondary Diagonal Smallest Element: ",
                             $secondaryMin, "\n";
    echo "Secondary Diagonal Greatest Element: "
                             $secondaryMax, "\n";
}
  
// Driver code
  
// Declare and initialize 5X5 matrix
$matrix = array(array ( 1, 2, 3, 4, -10 ),
                array ( 5, 6, 7, 8, 6 ),
                array ( 1, 2, 11, 3, 4 ),
                array ( 5, 6, 70, 5, 8 ),
                array ( 4, 9, 7, 1, -5 ));
diagonalsMinMax($matrix);
  
// This code is contributed by
// ihritik
?>

chevron_right


Output:

Principal Diagonal Smallest Element:  -5
Principal Diagonal Greatest Element : 11
Secondary Diagonal Smallest Element: 4
Secondary Diagonal Greatest Element: 11

Example 2: With O(n) Complexity:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to find
// smallest and largest elements of both diagonals
#include<bits/stdc++.h>
using namespace std;
  
const int n = 5;
  
// Function to find smallest and largest element 
// from principal and secondary diagonal
void diagonalsMinMax(int mat [n][n])
{
    // take length of matrix
    if (n == 0)
        return;
  
    // declare and initialize variables
    // with appropriate value
    int principalMin = mat[0][0], 
        principalMax = mat[0][0];
    int secondaryMin = mat[n - 1][0],
        secondaryMax = mat[n - 1][0];
  
    for (int i = 0; i < n; i++) 
    {
  
        // Condition for principal
        // diagonal mat[i][i]
  
        // take new smallest value
        if (mat[i][i] < principalMin) 
        {
            principalMin = mat[i][i];
        }
          
        // take new largest value
        if (mat[i][i] > principalMax) 
        {
            principalMax = mat[i][i];
        }
  
        // Condition for secondary
        // diagonal is mat[n-1-i][i]
        // take new smallest value
        if (mat[n - 1 - i][i] < secondaryMin) 
        {
            secondaryMin = mat[n - 1 - i][i];
        }
          
        // take new largest value
        if (mat[n - 1 - i][i] > secondaryMax) 
        {
            secondaryMax = mat[n - 1 - i][i];
        }
    }
    cout << "Principal Diagonal Smallest Element: "
         << principalMin << "\n";
    cout << "Principal Diagonal Greatest Element : "
         << principalMax << "\n";
  
    cout << "Secondary Diagonal Smallest Element: "
         << secondaryMin << "\n";
    cout << "Secondary Diagonal Greatest Element: "
         << secondaryMax;
}
  
// Driver code
int main()
{
  
    // Declare and initialize 5X5 matrix
    int matrix [n][n] = {{ 1, 2, 3, 4, -10 },
                         { 5, 6, 7, 8, 6 },
                         { 1, 2, 11, 3, 4 },
                         { 5, 6, 70, 5, 8 },
                         { 4, 9, 7, 1, -5 }};
  
    diagonalsMinMax(matrix);
}
  
// This code is contributed by ihritik

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to find
// smallest and largest elements of both diagonals
  
public class GFG {
  
    // Function to find smallest and largest element from
    // principal and secondary diagonal
    static void diagonalsMinMax(int[][] mat)
    {
        // take length of matrix
        int n = mat.length;
        if (n == 0)
           return;
  
        // declare and initialism variables with appropriate value
        int principalMin = mat[0][0], principalMax = mat[0][0];
        int secondaryMin = mat[n-1][0], secondaryMax = mat[n-1][0];
  
        for (int i = 0; i < n; i++) {
  
            // Condition for principal
            // diagonal mat[i][i]
  
            // take new smallest value
            if (mat[i][i] < principalMin) {
                principalMin = mat[i][i];
            }
            // take new largest value
            if (mat[i][i] > principalMax) {
                principalMax = mat[i][i];
            }
  
            // Condition for secondary
            // diagonal is mat[n-1-i][i]
            // take new smallest value
            if (mat[n - 1 - i][i] < secondaryMin) {
                secondaryMin = mat[n - 1 - i][i];
            }
            // take new largest value
            if (mat[n - 1 - i][i] > secondaryMax) {
                secondaryMax = mat[n - 1 - i][i];
            }
        }
        System.out.println("Principal Diagonal Smallest Element:  "
                           + principalMin);
        System.out.println("Principal Diagonal Greatest Element : "
                           + principalMax);
  
        System.out.println("Secondary Diagonal Smallest Element: "
                           + secondaryMin);
        System.out.println("Secondary Diagonal Greatest Element: "
                           + secondaryMax);
    }
  
    // Driver code
    static public void main(String[] args)
    {
  
        // Declare and initialize 5X5 matrix
        int[][] matrix = {
            { 1, 2, 3, 4, -10 },
            { 5, 6, 7, 8, 6 },
            { 1, 2, 11, 3, 4 },
            { 5, 6, 70, 5, 8 },
            { 4, 9, 7, 1, -5 }
        };
  
        diagonalsMinMax(matrix);
    }
}

chevron_right


Python

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to find smallest and 
# largest elements of both diagonals
  
n = 5
  
# Function to find smallest and largest element
# from principal and secondary diagonal
def diagonalsMinMax(mat):
      
    # take length of matrix
    if (n == 0):
        return
  
    # declare and initialize variables
    # with appropriate value
    principalMin = mat[0][0]
    principalMax = mat[0][0]
    secondaryMin = mat[n - 1][0]
    secondaryMax = mat[n - 1][0]
  
    for i in range(n):
  
        # Condition for principal
        # diagonal mat[i][i]
  
        # take new smallest value
        if (mat[i][i] < principalMin):
            principalMin = mat[i][i]
  
        # take new largest value
        if (mat[i][i] > principalMax):
            principalMax = mat[i][i]
  
        # Condition for secondary
        # diagonal is mat[n-1-i][i]
        # take new smallest value
        if (mat[n - 1 - i][i] < secondaryMin):
            secondaryMin = mat[n - 1 - i][i]
  
        # take new largest value
        if (mat[n - 1 - i][i] > secondaryMax):
            secondaryMax = mat[n - 1 - i][i]
  
    print("Principal Diagonal Smallest Element: ",principalMin)
    print("Principal Diagonal Greatest Element : ",principalMax)
  
    print("Secondary Diagonal Smallest Element: ",secondaryMin)
    print("Secondary Diagonal Greatest Element: ",secondaryMax)
  
# Driver code
  
# Declare and initialize 5X5 matrix
matrix= [[ 1, 2, 3, 4, -10 ],
        [ 5, 6, 7, 8, 6 ],
        [ 1, 2, 11, 3, 4 ],
        [ 5, 6, 70, 5, 8 ],
        [ 4, 9, 7, 1, -5 ]]
  
diagonalsMinMax(matrix)
  
# This code is contributed by mohit kumar 29

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to find smallest and largest 
// elements of both diagonals 
using System; 
  
public class GFG { 
    // Function to find smallest and largest element from 
    // principal and secondary diagonal 
    static void diagonalsMinMax(int[,] mat) 
    
        // take length of square matrix 
        int n = mat.GetLength(0); 
        if (n == 0) 
        return
  
        // declare and initialize variables with appropriate value 
        int principalMin = mat[0,0], principalMax = mat[0,0]; 
        int secondaryMin = mat[n-1,0], secondaryMax = mat[n-1,0]; 
  
        for (int i = 0; i < n; i++) { 
    
            // Condition for principal 
            // diagonal mat[i][i] 
    
            // take new smallest value 
            if (mat[i,i] < principalMin) { 
                principalMin = mat[i,i]; 
            
            // take new largest value 
            if (mat[i,i] > principalMax) { 
                principalMax = mat[i,i]; 
            
    
            // Condition for secondary 
            // diagonal is mat[n-1-i][i] 
            // take new smallest value 
            if (mat[n - 1 - i,i] < secondaryMin) { 
                secondaryMin = mat[n - 1 - i,i]; 
            
            // take new largest value 
            if (mat[n - 1 - i,i] > secondaryMax) { 
                secondaryMax = mat[n - 1 - i,i]; 
            
          
        
  
        Console.WriteLine("Principal Diagonal Smallest Element: "
                        + principalMin); 
        Console.WriteLine("Principal Diagonal Greatest Element : "
                        + principalMax); 
  
        Console.WriteLine("Secondary Diagonal Smallest Element: "
                        + secondaryMin); 
        Console.WriteLine("Secondary Diagonal Greatest Element: "
                        + secondaryMax); 
    
  
    // Driver code 
    public static void Main() 
    
  
        // Declare and initialize 5X5 matrix 
        int[,] matrix = { 
            { 1, 2, 3, 4, -10 }, 
            { 5, 6, 7, 8, 6 }, 
            { 1, 2, 11, 3, 4 }, 
            { 5, 6, 70, 5, 8 }, 
            { 4, 9, 7, 1, -5 } 
        }; 
  
        diagonalsMinMax(matrix); 
    
  
/*This code is contributed by 29AjayKumar*/

chevron_right


Output:

Principal Diagonal Smallest Element:  -5
Principal Diagonal Greatest Element : 11
Secondary Diagonal Smallest Element: -10
Secondary Diagonal Greatest Element: 11



My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.