Como calcular o determinante de uma matriz usando o Teorema de Laplace em Java

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package estudos;

public class Estudos {
  public static void main(String[] args){
    // vamos definir a ordem da matriz
    int ordem = 3; // 3 linhas e 3 colunas
    
    // e agora criamos a matriz. Podemos definir os elementos
    // diretamente ou pedir para o usuário informar os valores
    int matriz[][] = {{1, 3, 0}, {0, 2, 5}, {2, 4, 4}};
 
    // mostramos a matriz completa
    System.out.println("A matriz é:\n");
    
    for (int i = 0; i < ordem; i++) {
      for (int j = 0; j < ordem; j++){
        System.out.printf("%5d", matriz[i][j]);
      }
      System.out.print("\n");
    }
    
    // vamos calcular o determinante usando o Teorema de Laplace
    int determinante = calcularDeterminante(matriz, ordem);
    
    // e mostramos o resultado
    System.out.println("\nO determinante da matriz é: " + determinante);  
  } 
 
  // função recursiva que encontra e retorna o determinante de uma
  // matriz de qualquer ordem
  public static int calcularDeterminante(int matriz[][], int ordem){
    int determinante = 0; // para guardar e retornar o determinante
    // matriz de cofatores
    int cofatores[][] = new int[ordem][ordem];
    // para guardar o sinal de multiplicação
    int sinal = 1;
    
    // caso base da recursividade:
    // se a matriz possuir apenas um elemento, retorna ele
    if (ordem == 1){
      return matriz[0][0];
    }
 
    // vamos percorrer cada um dos elementos da primeira linha    
    for (int f = 0; f < ordem; f++) {
      // vamos obter o cofator de matriz[0][f]
      calcularCofator(matriz, cofatores, 0, f, ordem);
      determinante = determinante + (sinal * matriz[0][f]
        * calcularDeterminante(cofatores, ordem - 1));
 
      // alterna o sinal
      sinal = -sinal;
    }
 
    // retorna o determinante
    return determinante;
  } 
  
  // função para retornar o cofator de mat[p][q] em temp[][]
  // ordem é a ordem atual da matriz mat[][]
  public static void calcularCofator(int mat[][], int temp[][],
    int p, int q, int ordem){
    // nos parâmetros, p indica linha e q indica coluna
    
    // variáveis auxiliares
    int i = 0, j = 0;
 
    // percorre cada um dos elementos da matriz recebida
    for (int linha = 0; linha < ordem; linha++) {
      // percorre as colunas
      for (int coluna = 0; coluna < ordem; coluna++) {
        // copia para a matriz temporária apenas os
        // elementos que não se encaixam na linha
        // e coluna informadas
        if (linha != p && coluna != q) {
          temp[i][j++] = mat[linha][coluna];
          // preenchemos a linha. Hora de aumentar
          // o índice da linha e resetar o índice
          // da coluna
          if (j == ordem - 1) {
            j = 0;
            i++;
          }
        }
      }
    }
  }
}

A matriz é:

    1    3    0
    0    2    5
    2    4    4

O determinante da matriz é: 18