Discussion :

[mechakiss]

bonsoir

à fin de coder un programme qui va me permet d'informatisé le calcule du déterminant d'une matrice donnée de type n*n ; je dois crier une fonction qui va me permet d'allouer des matrices de type n*n selon le principe suivant : si la première matrice est de type n*n la deuxième sera de type (n-1)*(n-1) et ainsi de suite.

et à la fin de l'exécution de ma fonction , elle aura allouer une pyramide dans la mémoire.

mais ca fais 2 jours que j'essaye sans résultat, et surtout les structures de données ce n'est ma pointe forte.

je serai reconnaissant si vous m'aidez à ce sujet

Merci à l'avance

[quetzacoatl]

Appelons mon_type, le type des éléments contenus dans ta matrice:
Tu déclares :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

mon_type*** pyramide=malloc(n*sizeof(type**));

Chaque case de ce tableau correspondra à pointeur de type mon_type** que l'on peut faire pointer vers une matrice(grâce à malloc()). Avec une boucle for, tu peux aisément remplir ton tableau de matrices de la façon voulue
(il faut noter que dans mon exemple, les matrices sont représenté par des tableaux de pointeurs, mais ce n'est pas la seule solution)

[mechakiss]

Appelons mon_type, le type des éléments contenus dans ta matrice:
Tu déclares :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

mon_type*** pyramide=malloc(n*sizeof(type**));

Chaque case de ce tableau correspondra à pointeur de type mon_type** que l'on peut faire pointer vers une matrice(grâce à malloc()). Avec une boucle for, tu peux aisément remplir ton tableau de matrices de la façon voulue
(il faut noter que dans mon exemple, les matrices sont représenté par des tableaux de pointeurs, mais ce n'est pas la seule solution)

Merci quetzacoatl

j'ai une question : quand vous dites que ce n'est pas la seule solution , pouvez vous me lister les autres méthodes ,comme ca je vais choisir la meilleure pour la gestion des données et pour le traitement

Merci encore une fois

[quetzacoatl]

On peut également représenté une matrice de taille n*p par un tableau d'entiers de n*p
Seul inconvénient, pour se déplacer dans la matrice, on ne pourra pas faire A[i][j], mais on fera A[i*p+j]
L'avantage est la place mémoire occupée qui est moindre.

[souviron34]

L'avantage est la place mémoire occupée qui est moindre.

Non..

L'avantage c'est surtout que l'allocation est plus simple et qu'on peut utiliser un pointeur et donc une boucle continue...


L'avantage est donc une plus grande vitesse d'excution, sauf pour adresser un élément particulier..


Si on veut passer à travers toute la matrice :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
int  *matrice ;
int    dimx, dimy ;
 
for ( i = 0 ; i < dimx*dimy ; i++ )
{
    *matrice = ... ;
     matrice++ ;
 
    /* 
     * Ou bien 
     *         *matrice++ = ... ;
     */
}

[mechakiss]

Non..

L'avantage c'est surtout que l'allocation est plus simple et qu'on peut utiliser un pointeur et donc une boucle continue...


L'avantage est donc une plus grande vitesse d'excution, sauf pour adresser un élément particulier..

Merci les Amis

donc la 1ere méthode est la bonne pour faire beaucoup de calcules sur ma matrice !! c'est ca ?!

[souviron34]

Merci les Amis

donc la 1ere méthode est la bonne pour faire beaucoup de calcules sur ma matrice !! c'est ca ?!

tout dépend du type de calculs..

Si tu dois passer à travers toutes les cellules de la matrice, ou si tu fais une colonne ou une ligne, il est nettement plus rapide et simple d'utiliser un seul tableau à 1 dimension

Si tu a des trucs comme des filtres (se servir des N voisins), l'écriture est plus simple avec des tableaux à 2 dimensions.

Mais de manière générale la vitesse sera légèrement supérieure de toutes façons avec un seul tableau..

Et l'allocation est plus simple..


Pour allouer toute ta pyramide de n*n à 1*1 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
int **matrice ;
 
matrice = (int **) calloc ( n, sizeof(int*) );
 
for ( i = n ; i >= 1 ; i-- )
{
   matrice[n-i] = (int *) calloc ( (i*i), sizeof(int) );
}