# 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:

 `// CPP program to find smallest and  ` `// largest elements of both diagonals ` `#include ` `using` `namespace` `std; ` ` `  `// Function to find smallest and largest element  ` `// from principal and secondary diagonal ` `void` `diagonalsMinMax(``int` `mat) ` `{ ` `    ``// take length of matrix ` `    ``int` `n = ``sizeof``(*mat) / 4; ` `    ``if` `(n == 0) ` `        ``return``; ` ` `  `    ``// declare and initialize variables  ` `    ``// with appropriate value ` `    ``int` `principalMin = mat,  ` `        ``principalMax = mat; ` `    ``int` `secondaryMin = mat[n - 1],  ` `        ``secondaryMax = mat[n - 1]; ` ` `  `    ``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 = {{ 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 `

 `// 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); ` `    ``} ` `} `

 `# 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 `

 `// 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 ` `}  `

 ` ``\$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 ` `?> `

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++ program to find ` `// smallest and largest elements of both diagonals ` `#include ` `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,  ` `        ``principalMax = mat; ` `    ``int` `secondaryMin = mat[n - 1], ` `        ``secondaryMax = mat[n - 1]; ` ` `  `    ``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 `

 `// 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); ` `    ``} ` `} `

 `# 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 `

 `// 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*/`

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

Strategy Path planning and Destination matters in success No need to worry about in between temporary failures

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.

Practice Tags :