Programa Java para calcular eficientemente las sumas de las diagonales de una array

Dada una array cuadrada 2D, encuentre la suma de los elementos en las diagonales Principal y Secundaria. Por ejemplo, considere la siguiente array de entrada de 4 X 4.
 

A00 A01 A02 A03
A10 A11 A12 A13
A20 A21 A22 A23
A30 A31 A32 A33

La diagonal primaria está formada por los elementos A00, A11, A22, A33. 
 

1. Condición para la Diagonal Principal: La condición fila-columna es fila = columna. 
   La diagonal secundaria está formada por los elementos A03, A12, A21, A30.
2. Condición para la diagonal secundaria: la condición fila-columna es fila = número de filas – columna -1.

Ejemplos: 
 

Input : 
4
1 2 3 4
4 3 2 1
7 8 9 6
6 5 4 3
Output :
Principal Diagonal: 16
Secondary Diagonal: 20

Input :
3
1 1 1
1 1 1
1 1 1
Output :
Principal Diagonal: 3
Secondary Diagonal: 3

Método 1 (O(n ^ 2) :

En este método, usamos dos bucles, es decir, un bucle para columnas y un bucle para filas y en el bucle interior verificamos la condición indicada anteriormente:
 

// A simple java program to find
// sum of diagonals
import java.io.*;
 
public class GFG {
 
    static void printDiagonalSums(int [][]mat,
                                         int n)
    {
        int principal = 0, secondary = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
     
                // Condition for principal
                // diagonal
                if (i == j)
                    principal += mat[i][j];
     
                // Condition for secondary
                // diagonal
                if ((i + j) == (n - 1))
                    secondary += mat[i][j];
            }
        }
     
        System.out.println("Principal Diagonal:"
                                    + principal);
                                     
        System.out.println("Secondary Diagonal:"
                                    + secondary);
    }
 
    // Driver code
    static public void main (String[] args)
    {
         
        int [][]a = { { 1, 2, 3, 4 },
                      { 5, 6, 7, 8 },
                      { 1, 2, 3, 4 },
                      { 5, 6, 7, 8 } };
                     
        printDiagonalSums(a, 4);
    }
}
 
// This code is contributed by vt_m.

Producción:  

Principal Diagonal:18
Secondary Diagonal:18

Complejidad de tiempo : O (N * N), ya que estamos usando bucles anidados para atravesar N * N veces.

Espacio auxiliar : O(1), ya que no estamos utilizando ningún espacio adicional.

Método 2 (O(n) :

En este método usamos un bucle, es decir, un bucle para calcular la suma de las diagonales principal y secundaria: 
 

// An efficient java program to find
// sum of diagonals
import java.io.*;
 
public class GFG {
 
    static void printDiagonalSums(int [][]mat,
                                        int n)
    {
        int principal = 0, secondary = 0;
        for (int i = 0; i < n; i++) {
            principal += mat[i][i];
            secondary += mat[i][n - i - 1];
        }
     
        System.out.println("Principal Diagonal:"
                                   + principal);
                                    
        System.out.println("Secondary Diagonal:"
                                   + secondary);
    }
     
    // Driver code
    static public void main (String[] args)
    {
        int [][]a = { { 1, 2, 3, 4 },
                      { 5, 6, 7, 8 },
                      { 1, 2, 3, 4 },
                      { 5, 6, 7, 8 } };
     
        printDiagonalSums(a, 4);
    }
}
 
// This code is contributed by vt_m.

Producción :  

Principal Diagonal:18
Secondary Diagonal:18

Complejidad de tiempo : O (N), ya que estamos usando un bucle para atravesar N veces.

Espacio auxiliar : O(1), ya que no estamos utilizando ningún espacio adicional.
Consulte el artículo completo sobre Calcular eficientemente las sumas de las diagonales de una array para obtener más detalles.