Bonjour a tous,
 
Actuellement étudiant en informatique, je dois pour un projet d'algorithmique réaliser un programme permettant de calculer le déterminant d'une matrice.
Je n'ai pas le droit d'utiliser de langage objet, hormis pour la création d'une nouvelle structure a utiliser comme variable. Mes fonctions et procédure doivent toujours être de la forme 'public static'.
Et pour être honnête, ce projet j'en bave... Je viens vers vous dans l'espoir de recevoir vos lumières, si quelqu'un sait pourquoi ce que je vais poster ne marche pas...
 
J'utilise donc une structure matrice définie dans une classe mat :

public class mat {
    int col;
    int row;
    int [][] T ;
}
 
Et j'ai crée le code suivant pour calculer le déterminant d'une matrice carrée ( le fameux qui ne marche pas ), que j'ai essayé de commenter a maximum. J'utilise la méthode des cofacteurs (http://fr.wikipedia.org/wiki/Comatrice). Je vous invite a le copier dans votre IDE et si vous arrivez a le faire tourner, je serai vraiment fort reconnaissant ! Voici le code :
 
import java.util.Scanner;
 
public class testdet3 {
    private static Scanner scanner = new Scanner(System.in);
     
     
     
    public static void main(String[] args) {
     
     mat matricetest;
     matricetest = new mat ();
     remplirmatrice(matricetest);
     int det;
     det = determinant(matricetest);
     
     System.out.println("Le determinant est : "+det);
     
     
     afficherMatrice(matricetest);
 
 
 
     }
     
    public static int determinant(mat matrice)
    {
         
    int determ = 0, row, col;
     
    // On crée un tableau dans lesquel on stockera les déterminants des cofacteurs de la premiere ligne
    int detcofact[] = new int [matrice.col-1];
 
     
     
     
    /*calcule le cofacteur (sans le signe) pour chaque cases de la premiere ligne du tableau et
     * le reporte dans le tableau des cofacteurs de la premiere ligne */
 
 
            for ( col = 0; col < matrice.col; col++)  
 
            {
            detcofact[col] = detcofacteur(matrice,col,matrice.col);
            }
             
   // multiplie chaque case de la premiere ligne de la matrice en entrée par son cofacteur calculé dans le tableau cofacteur
             
                   for ( col = 0; col < matrice.col; col++)  
 
                    {
                    detcofact[col]=matrice.T[0][col]*detcofact[col];
                    determ += detcofact[col]*(-1^col);
                    }
       return determ;
    }
     
     
     
     
    public static int detcofacteur(mat matricofact,int rang, int dim)
             
    {
    int detcofact = 0;
     
    // si la dimension de la matrice entrée est 1*1, on retourne alors le seul nombre concerné
 
     
    if (dim == 1)
         
    {
    detcofact=matricofact.T[0][0];
    }
     
    // Sinon on définit la sous matrice par apport a matricofact dont on devra calculer le déterminant, qu'on appelle cofact
    else  
            {
            mat cofact;
            cofact = new mat();
            // Cofact aura donc une ligne et une colonne de moins que matricofact
             
            cofact.T = new int [dim-2][dim-2];
             
             
            // Dans le cas ou le cofacteur calculé n'est pas celui en [0][0]
            if (rang != 0)
                 
            {
             
            // On remplit Cofact par les éléments de matricofact AVANT la colonne du cofacteur en cours de calcul
            for (int colonne=0 ; colonne < rang ; colonne++)
            {
                for (int ligne=1 ; ligne < dim ; ligne ++)
                {
                // Ligne -1 car dans cofact, la premiere ligne ne doit pas être vide
                cofact.T[ligne-1][colonne]=matricofact.T[ligne][colonne];
                }
            }
             
             // On remplit Cofact par les éléments de matricofact APRES la colonne du cofacteur en cours de calcul
                        for (int colonne=dim-1 ; colonne > rang ; colonne--)
                    {
                        for (int ligne = 1 ; ligne < dim ; ligne ++)
                        {
                        // Colonne -1 car une colonne a été enlevée dans matricofact : celle du cofacteur en cours de calcul
                        cofact.T[ligne-1][colonne-1]=matricofact.T[ligne][colonne];
                        }
                    }
                                 
                                 
             detcofact=determinant(cofact);
            }
             
            // Dans le cas ou le cofacteur calculé est celui en [0][0]
             
            else  
            {
                        for (int colonne=dim-1 ; colonne > rang ; colonne--)
                    {
                        for (int ligne = 1 ; ligne < dim ; ligne ++)
                        {
                        // Colonne -1 car une colonne a été enlevée dans matricofact : celle du cofacteur en cours de calcul
                        cofact.T[ligne-1][colonne-1]=matricofact.T[ligne][colonne];
                        }
                    }
            }
            }
    return detcofact;
    }
     
    public static void remplirmatrice(mat matrice)
        {
            int row,col;
        System.out.println("Saisie d'une matrice :" );
         
        System.out.println("Merci de rentrer un nombre de lignes (entier positif < 10) :" );
        matrice.row = scanner.nextInt();
         
        System.out.println("Merci de rentrer un nombre de colonnes (entier positif < 10) :" );
        matrice.col = scanner.nextInt();
         
        matrice.T = new int [11][11];
         
        System.out.println("Veuillez maintenant rentrer les valeurs de chaque case de la"
                + " matrice, comprises dans ]-100,100[ et entieres" );
         
            for ( row = 0; row < matrice.row; row++)
            {
            for ( col = 0; col < matrice.col; col++)  
                 
            {
                System.out.print(" mat[" + (row + 1) + "," + (col + 1) + "]=" );
                matrice.T[row][col] = scanner.nextInt();
            }
            }
        }
     
     
public static void afficherMatrice(mat add) {
             
            for (int row = 0; row < add.row; row++) {
             
            for (int col = 0; col < add.col; col++) {
                 
            /* Pour un affichage plus propre, si le nombre est négatif et comporte donc
               un "-", on mettra un espace de moins que si le nombre est positif
               De même si le nombre a 2 chiffres, on lui enlevera un espace ( donc un nombre a 2 chiffres max)*/
                 
                if (add.T[row][col]<0)
                {
                    if (add.T[row][col] <= -10)
                    {
                System.out.print(" " +add.T[row][col] );
                    }
                    else
                    {
                       System.out.print("  " +add.T[row][col] );  
                    }
                }
                else
                {
                    if (add.T[row][col] > 10)
                    {
                System.out.print("  " +add.T[row][col] );
                    }
                    else
                    {
                    System.out.print("   " +add.T[row][col] );
                    }
                }
            }
            // Retour à la ligne
            System.out.println();
        }
    }
}

 
 
Y'a quelques trucs bizarres dans ton code. Par exemple:
 

// On crée un tableau dans lesquel on stockera les déterminants des cofacteurs de la premiere ligne
    int detcofact[] = new int [matrice.col-1]; 
     
    /*calcule le cofacteur (sans le signe) pour chaque cases de la premiere ligne du tableau et
     * le reporte dans le tableau des cofacteurs de la premiere ligne */
 
 
     for ( col = 0; col < matrice.col; col++)  
     {
            detcofact[col] = detcofacteur(matrice,col,matrice.col);
     }

 
Le nombre de boucles ne correspond pas à la taille du tableau "detcofact".
 
 
Il y a aussi
 

determ += detcofact[col]*(-1^col);

 
J'ai pas de souvenirs qu'on puisse coder une puissance ainsi dans Java.