La transposition d'une matrice en C++

Je suis en train d'écrire un programme pour transposer une matrice donnée à l'aide de la mémoire allouée. La fonction fonctionne parfaitement avec matrice carrée NxN (rows==cols), mais il se bloque avec matrice MxN (lignes != cols). S'il vous plaît aider

void transpose(int **matrix, int *row, int *col)
{
    //dynamically allocate an array
    int **result;
    result = new int *[*col]; //creates a new array of pointers to int objects
    //check for error
    if (result == NULL)
    {
        cout << "Error allocating array";
        exit(1);
    }
    for (int count = 0; count < *col; count++)
    {
        *(result + count) = new int[*row];
    }

    //transposing
    for (int i = 0; i<*row; i++)
    {
       for (int j = i+1; j<*col; j++)
       {
        int temp = *(*(matrix + i) + j);
        *(*(matrix + i) + j) = *(*(matrix + j) + i);
        *(*(matrix + j) + i) = temp;
       }
    }

    for (int i = 0; i<*row; i++)
    {
       for (int j = 0; j<*col; j++)
       {
          *(*(result + i) + j) = *(*(matrix + i) + j);
          cout << *(*(result + i) + j) << "\t";
       }
       cout << endl;
    }
}

new lève une exception en cas d'échec. Utilisation new(nothrow) si vous le souhaitez à renvoyer null en cas d'échec (même si c'est rare de vouloir que).

OriginalL'auteur Casper | 2013-02-13

c++matrix transpose

5

Les lignes:
```
for (int i = 0; i<*row; i++)
{
   for (int j = i+1; j<*col; j++)
   {
    int temp = *(*(matrix + i) + j);
    *(*(matrix + i) + j) = *(*(matrix + j) + i);
    *(*(matrix + j) + i) = temp;
   }
}
```
sont le problème. Le problème est que la matrice est indexé par i, j, pas j alors je voudrais que vous faites dans la deuxième et de la troisième ligne dans la boucle while. L'Image que la matrice est une matrice 2x3, puis vous essayez d'effectuer la matrice[2][3] = matrice[3][2], mais la matrice[3][2] n'existe pas.

Il est préférable d'aller de l'initialisation de résultat directement dans cette boucle:
```
for (int i = 0; i<*row; i++)
   for (int j = 0; j<*col; j++)
     result[j][i] = matrix[i][j];
```
Alors vous pouvez la production, comme ci-dessous, ou de les supprimer de la matrice et de réaffecter la matrice de résultats que vous le souhaitez. L'ensemble de ma fonction de transposition est devenu le code suivant (ligne et le col n'a pas besoin d'être des pointeurs sur int passage par valeur est tout simplement parfait. Aussi accès à des matrices devrait utiliser le tableau des indices qu'il est plus agréable de style):
```
void transpose(int **matrix, int row, int col)
{
  //dynamically allocate an array
  int **result;
  result = new int *[col]; //creates a new array of pointers to int objects
  for (int i = 0; i < col; i++)
    result[i] = new int[row];

  //transposing
  for (int i = 0; i<row; i++)
   for (int j = 0; j<col; j++)
     result[j][i] = matrix[i][j];

  //output resulting matrix
  for (int i = 0; i<col; i++) {
   for (int j = 0; j<row; j++)
    cout << result[i][j] << "\t";
   cout << endl;
  }
}
```
j'ai essayé, mais a ensuite obtenu moches, les numéros 🙁
a partir de la production de votre déclaration? cause vous devez vous assurer que ces boucles de même de l'indice de résultat, au lieu de la ligne *par *col celles-ci doivent être *col en ligne *
J'ai ajouté mon ensemble de la fonction de transposition qui je l'ai testé
merci beaucoup
n'oubliez pas de supprimer de la mémoire allouée

OriginalL'auteur pippin1289
1

Vous essayez de transposer la matrice "en place" :

((matrice + i) + j) = ((matrice + j) + i);

vous ne devriez pas faire cela. Si le nombre de colonnes est supérieur à nombre de lignes, alloués matrix, vous pourrez lire et écrire de mémoire non alloué.

À mon humble avis, Il serait préférable de les stocker ensemble de la matrice en mémoire continue. Pas dans les différentes pièces. De cette manière, le code ressemblera à ceci:
```
void transpose( int *matrix, int row, int col )
{
    for ( int i = 0; i < row; i++ )
    {
       for ( int j = i + 1; j < col; j++ )
       {
           int temp = matrix[ i * col + j ];
           matrix[ i * col + j ] = matrix[ j * col + i ];
           matrix[ j * col + i ] = temp;
       }
    }
}
```
La seule différence de cette allocation, que vous ne pouvez pas traiter d'un élément comme matrix[ i ][ j ] mais seulement matrix[ i + col + j ]. Points positifs sont: 1) facile à allouer/désallouer de la mémoire (juste matrix = new int[ col * row ] et delete [] matrix) 2) un peu plus vite l'accès à des éléments (en raison de la localisation continus)

À la fin, je pense, qu'il serait la meilleure façon de regarder std::vector. Si vous le souhaitez, je peux vous montrer, comment allez-vous vous regarder avec un vecteur

oui merci pour vos commentaires, j'ai été dit à plusieurs reprises que l'utilisation de vecteur est beaucoup mieux mais pour ce problème, im nécessaires à l'utilisation de ce concept 🙁

OriginalL'auteur borisbn

Vous devez vous connecter pour publier un commentaire.