Столбцы и строки коммутационной матрицы в C++

Question

У меня есть матрица 6 x 6, и я сохраняю ее значения в одномерном массиве размером 36. Я хочу изменить его так, чтобы строки были столбцами, а столбцы - строк. Мой метод пытается скопировать значения в другой массив, но отсортирован правильно. Я пытаюсь для цикла:

for (int i = 0; i < 6; ++i){ 
     copyArray[i]= array[i*6]; 
    } 

Это прекрасно работает для первого нового ряда, состоящего из первого столбца, но как я по-прежнему делать все из них? Я пробовал вложенные для циклов, но не могу придумать правильный алгоритм с использованием итераторов. Я мог бы сделать это вручную, но хотел бы сделать это с помощью кода.

Я кодирую на C++, но если кто-то может сделать это на том же языке, что было бы хорошо. Я чувствую, что это математическая проблема.

Вопрос: Как я могу решить для переключения строк и столбцов? (Пример: если я обозначаю первые строки и столбцы как 0, в матрице 6x6, то обе строки и столбцы идут от 0 до 5. Поэтому, переключая строки и столбцы, значение в строке 2, столбец 5 будет переключается со значением в строке 5, столбец 2.)

Answer 1

Не могли бы вы просто использовать вложенный цикл for и сделать что-то вроде этого?

for (int i = 0; i < 6; ++i) 
    for (int j = 0; j < 6; ++j) 
     copyArray[i*6+j]= array[j*6+i]; 

Вот тестовая программа вы можете запустить, чтобы показать, что это работает:

#include <stdio.h> 

int main() 
{ 
    int array[36] = {1,1,1,1,1,1, 
        2,2,2,2,2,2, 
        3,3,3,3,3,3, 
        4,4,4,4,4,4, 
        5,5,5,5,5,5, 
        6,6,6,6,6,6}; 
    int copyarray[36]; 

    for (int i = 0; i < 6; ++i) 
     for (int j = 0; j < 6; ++j) 
      copyarray[i*6+j]= array[j*6+i]; 

    for (int i = 0; i < 36; ++i) 
    { 
     if (i % 6 == 0) 
      printf("\n"); 

     printf("%d ", array[i]); 

    } 

    printf("\n"); 
    printf("\n"); 

    for (int i = 0; i < 36; ++i) 
    { 
     if (i % 6 == 0) 
      printf("\n"); 

     printf("%d ", copyarray[i]); 
    } 

    return 0; 
} 

Выход:

1 1 1 1 1 1 
2 2 2 2 2 2 
3 3 3 3 3 3 
4 4 4 4 4 4 
5 5 5 5 5 5 
6 6 6 6 6 6 


1 2 3 4 5 6 
1 2 3 4 5 6 
1 2 3 4 5 6 
1 2 3 4 5 6 
1 2 3 4 5 6 
1 2 3 4 5 6 

Answer 2

for(int i=0;i<6;i++) 
    for(int j=0;j<6;j++) 
     {   }//You can do whatever you want on original matrix here 

Давайте предположим, что вы хотите "транспонирование матрицы" и сделать некоторая обработка. Базовый переключатель i и j

for(int j=0;j<6;j++) // replaceed i with j 
    for(int i=0;i<6;i++) 
     {    }//You can do whatever you want on transpose matrix here 

Answer 3

Вы должны хранить свой одномерный массив внутри класса.
Затем вы можете поменять размерность данных без фактического перемещения.

class MySwapableArray 
{ 
    bool normal; 
    int array[36]; 


    public: 
     int& operator()(int x, int y) 
     { 
       int h = normal ? x : y; 
       int v = normal ? y : x; 

       return array[h*6+v]; 
     } 
     void swapRowsAndColumns() 
     { 
      normal = ! normal; 
     } 
}; 

Если вы хотите использовать operator[] как A [х] [у], то смотрите: How to overload array index operator for wrapper class of 2D array?

Answer 4

шаблон для этого.

template<class X> std::unique_ptr<typename std::pointer_traits<X>::element_type[]> 
transpose(const X& p, int x, int y) { 
    using T = std::pointer_traits<X>::element_type; 
    std::unique_ptr<T[]> r = new T[x*y]; 
    for(int a = 0; a < x; ++a) 
     for(int b = 0; b < y; ++b) 
      r[x*a+b] = p[y*b+a]; 
    return r; 
} 

Answer 5

Если вы хотите, чтобы избежать двойной цикл, вы должны быть в состоянии сделать это математически с чем-то вроде

for (int i = 0; i < 36; ++i) { 
    copyarray[6 * (i % 6) + i/6] = array[i] 
} 

В основном, 6 * (i % 6) выравнивает вас в правом ряду в транспонированной матрице, и i/6 (ab) использует целочисленное деление для преобразования значения столбца в значение строки. floor (i/6.0) вернее, если вы можете жить с беспорядком.