Determinante en C++, C y Java por el método de cofactores

Determinante en C++

Este es un tutorial donde explico cómo realizar un programa que permita calcular la determinante de cualquier matriz cuadrada utilizando el método de cofactores. 

En el tutorial se utiliza el lenguaje de programación C++ pero en esta entrada también se muestra en en los lenguajes C y Java.

determinante en c++

Funcionamiento del programa

Código fuente en C++

				
					#include <iostream>
#include <cmath>
#define MAX 10

using namespace std;

void mostrar_matriz(int matriz[][MAX], int orden);
int determinante(int matriz[][MAX], int orden);
int cofactor(int matriz[][MAX], int orden, int fila, int columna);

int main()
{
   int matriz[MAX][MAX];
   int orden;
   
   cout << "Ingresa el orden de la matriz (maximo " << MAX << "): ";
   cin >> orden;
   while (orden < 0 || orden > MAX) {
      cout << "\nEl orden de la matriz no puede ser mayor que " << MAX << endl;
      cout << "Ingrese nuevamente el orden de la matriz: ";
      cin >> orden;
   }
   
   cout << "\nIngrese los elementos de la matriz:\n\n";
   for (int i = 0; i < orden; i++) {
      for (int j = 0; j < orden; j++) {
         cin >> matriz[i][j];
      }
   }

   cout << "\nMostrando la matriz ingresada:\n";
   mostrar_matriz(matriz, orden);
   
   cout << "\nEl determinante es: " << determinante(matriz, orden) << endl;

   cin.get();
   cin.get();
   return 0;
}

void mostrar_matriz(int matriz[][MAX], int orden)
{
   cout << "Orden: " << orden << endl;
   for (int i = 0; i < orden; i++) {
      for (int j = 0; j < orden; j++) {
         cout << "\t" << matriz[i][j];
      }
      cout << "\n";
   }
}


int determinante(int matriz[][MAX], int orden)
{
   int det = 0.0;
   
   if (orden == 1) {
      det = matriz[0][0];
   } else {
      for (int j = 0; j < orden; j++) {
         det = det + matriz[0][j] * cofactor(matriz, orden, 0, j);
      }
   }
   
   return det;
}


int cofactor(int matriz[][MAX], int orden, int fila, int columna)
{
   int submatriz[MAX][MAX];
   int n = orden - 1;
   
   int x = 0;
   int y = 0;
   for (int i = 0; i < orden; i++) {
      for (int j = 0; j < orden; j++) {
         if (i != fila && j != columna) {
            submatriz[x][y] = matriz[i][j];
            y++;
            if (y >= n) {
               x++;
               y = 0;
            }
         }
      }
   }
   
   return pow(-1.0, fila + columna) * determinante(submatriz, n);
}
				
			

Código fuente en C

				
					#include <stdio.h>
#include <math.h>
#define MAX 20
 
void mostrar_matriz(int matriz[][MAX], int orden);
int determinante(int matriz[][MAX], int orden);
int cofactor(int matriz[][MAX], int orden, int fila, int columna);
 
int main()
{
   int matriz[MAX][MAX];
   int orden, i, j;
   
   printf("Ingresa el orden de la matriz (maximo %d): ", MAX);
   scanf("%d", &orden);
   while (orden < 0 || orden > MAX) {
   	printf("\nEl orden de la matriz no puede ser mayor que %d\n", MAX);
   	printf("Ingrese nuevamente el orden de la matriz: ");
      scanf("%d", &orden);
   }
   
   printf("\nIngrese los elementos de la matriz:\n\n");
   for (i = 0; i < orden; i++) {
      for (j = 0; j < orden; j++) {
         scanf("%d", &matriz[i][j]);
      }
   }
 
   printf("\nMostrando la matriz ingresada:\n");
   mostrar_matriz(matriz, orden);
   
   printf("\nEl determinante es: %d\n", determinante(matriz, orden));
 
   getchar();
   getchar();
   return 0;
}
 
void mostrar_matriz(int matriz[][MAX], int orden)
{
	int i, j;
	
	printf("Orden: %d\n", orden);
   for (i = 0; i < orden; i++) {
      for (j = 0; j < orden; j++) {
      	printf("\t%d", matriz[i][j]);
      }
      printf("\n");
   }
}
 
 
int determinante(int matriz[][MAX], int orden)
{
   int det = 0.0, j;
   
   if (orden == 1) {
      det = matriz[0][0];
   } else {
      for (j = 0; j < orden; j++) {
         det = det + matriz[0][j] * cofactor(matriz, orden, 0, j);
      }
   }
   
   return det;
}
 
 
int cofactor(int matriz[][MAX], int orden, int fila, int columna)
{
   int submatriz[MAX][MAX];
   int n = orden - 1;
   int i, j;
   
   int x = 0;
   int y = 0;
   for (i = 0; i < orden; i++) {
      for (j = 0; j < orden; j++) {
         if (i != fila && j != columna) {
            submatriz[x][y] = matriz[i][j];
            y++;
            if (y >= n) {
               x++;
               y = 0;
            }
         }
      }
   }
   
   return pow(-1.0, fila + columna) * determinante(submatriz, n);
}
				
			

Código fuente en Java

				
					import java.util.Scanner;
 
public class Determinante {
 
    public static final int MAX = 10;
    public static final Scanner entrada = new Scanner(System.in);
 
    public static void main(String[] args) {
 
        int matriz[][];
        int orden;
 
        System.out.print("Ingresa el orden de la matriz (máximo " + MAX + "): ");
        orden = entrada.nextInt();
        while (orden < 0 || orden > MAX) {
            System.out.printf("\nEl orden de la matriz no puede ser mayor que %d\n", MAX);
            System.out.printf("Ingrese nuevamente el orden de la matriz: ");
            orden = entrada.nextInt();
        }
 
        // Se instancia la matriz
        matriz = new int[orden][orden];
 
        // Lectura de elementos de la matriz
        System.out.printf("\nIngrese los elementos de la matriz:\n\n");
        leerMatriz(matriz);
 
        // Escritura de elementos de la matriz
        System.out.printf("\nMostrando la matriz ingresada:\n");
        mostrarMatriz(matriz);
 
        // Cálculo del determinante de la matriz
        System.out.printf("\nEl determinante es: %d\n", determinante(matriz));
    }
 
    public static void leerMatriz(int matriz[][]) {
 
        for (int i = 0; i < matriz.length; i++) {
            for (int j = 0; j < matriz.length; j++) {
                matriz[i][j] = entrada.nextInt();
            }
        }
    }
 
    public static void mostrarMatriz(int matriz[][]) {
 
        System.out.printf("\nOrden: %d\n", matriz.length);
        for (int i = 0; i < matriz.length; i++) {
            for (int j = 0; j < matriz.length; j++) {
                System.out.printf("\t%d", matriz[i][j]);
            }
            System.out.println();
        }
    }
 
    public static int determinante(int matriz[][]) {
 
        int det = 0;
 
        if (matriz.length == 1) {
            return matriz[0][0];
 
        } else {
            for (int j = 0; j < matriz.length; j++) {
                det = det + matriz[0][j] * cofactor(matriz, 0, j);
            }
        }
 
        return det;
    }
 
    public static int cofactor(int matriz[][], int fila, int columna) {
 
        int submatriz[][];
        int n = matriz.length - 1;
 
        submatriz = new int[n][n];
        int x = 0;
        int y = 0;
        for (int i = 0; i < matriz.length; i++) {
            for (int j = 0; j < matriz.length; j++) {
                if (i != fila && j != columna) {
                    submatriz[x][y] = matriz[i][j];
                    y++;
                    if (y >= n) {
                        x++;
                        y = 0;
                    }
                }
            }
        }
 
        return (int)Math.pow(-1.0, fila + columna) * determinante(submatriz);
    }
}
				
			

Videotutoriales