[已解决]分块矩阵转置

晴雨皆宜

开卷有益，多多益善·····

人造人

这个你还是没有说对不对
不过你没有说错，而且从你说的内容来看，应该是对的，那我就认为是对的了

1. #include <algorithm>
   
2. #include <iostream>
   
3. 
   
4. using namespace std;
   
5. 
   
6. void TransposeMatri(int **array, int n) { //全部转置
   
7.     for(int i = 0; i < n; i++)
   
8.         for(int j = 0; j < n; j++) {
   
9.             if(j > i) //主副三角
   
10.                 swap(array[i][j], array[j][i]);
    
11.         }
    
12. }
    
13. 
    
14. void Block_transpose(int **array, int n) { //分块转置
    
15.     int k = 2;
    
16.     for(int i = 0; i < n; i += k)
    
17.         for(int j = 0; j < n; j += k)
    
18.             TransposeMatri((int **)((int *)array + i * n + j), k);
    
19. }
    
20. 
    
21. int main() {
    
22.     int **a = new int *[4];
    
23.     for(int i = 0; i < 4; i++)
    
24.         a[i] = new int[4];
    
25.     for(int i = 0; i < 4; i++) {
    
26.         for(int j = 0; j < 4; j++) {
    
27.             a[i][j] = i * 4 + j;
    
28.         }
    
29.     }
    
30.     for(int i = 0; i < 4; i++) {
    
31.         for(int j = 0; j < 4; j++)
    
32.             cout << a[i][j] << ' ';
    
33.         cout << endl;
    
34.     }
    
35.     Block_transpose(a, 4);
    
36.     cout << "---------------------" << endl;
    
37.     /*
    
38.     for(int i = 0; i < 4; i++)
    
39.         for(int j = 0; j < 4; j++)
    
40.             cout << a[i][j] << ' ';
    
41.     cout << endl;
    
42.     */
    
43.     for(int i = 0; i < 4; i++) {
    
44.         for(int j = 0; j < 4; j++)
    
45.             cout << a[i][j] << ' ';
    
46.         cout << endl;
    
47.     }
    
48.     // 释放一定要写，不写释放的代码在一些环境下会报错的
    
49.     for(int i = 0; i < 4; i++)
    
50.         delete[] a[i];
    
51.     delete[] a;
    
52.     return 0;
    
53. }
    

复制代码

这个代码是错的，因为你进行了强制类型转换，可以通过编译了，但是类型不对
地址值是一样的，但是类型不对
应该转成下面这样

1. #include <algorithm>
   
2. #include <iostream>
   
3. 
   
4. using namespace std;
   
5. 
   
6. void TransposeMatri(int **array, int n) { //全部转置
   
7.     for(int i = 0; i < n; i++)
   
8.         for(int j = 0; j < n; j++) {
   
9.             if(j > i) //主副三角
   
10.                 //swap(array[i][j], array[j][i]);
    
11.                 swap((*(int (*)[n][n])(array))[i][j], (*(int (*)[n][n])(array))[j][i]);
    
12.         }
    
13. }
    
14. 
    
15. void Block_transpose(int **array, int n) { //分块转置
    
16.     int k = 2;
    
17.     for(int i = 0; i < n; i += k)
    
18.         for(int j = 0; j < n; j += k)
    
19.             TransposeMatri((int **)((int *)array + i * n + j), k);
    
20. }
    
21. 
    
22. int main() {
    
23.     int **a = new int *[4];
    
24.     for(int i = 0; i < 4; i++)
    
25.         a[i] = new int[4];
    
26.     for(int i = 0; i < 4; i++) {
    
27.         for(int j = 0; j < 4; j++) {
    
28.             a[i][j] = i * 4 + j;
    
29.         }
    
30.     }
    
31.     for(int i = 0; i < 4; i++) {
    
32.         for(int j = 0; j < 4; j++)
    
33.             cout << a[i][j] << ' ';
    
34.         cout << endl;
    
35.     }
    
36.     Block_transpose(a, 4);
    
37.     cout << "---------------------" << endl;
    
38.     /*
    
39.     for(int i = 0; i < 4; i++)
    
40.         for(int j = 0; j < 4; j++)
    
41.             cout << a[i][j] << ' ';
    
42.     cout << endl;
    
43.     */
    
44.     for(int i = 0; i < 4; i++) {
    
45.         for(int j = 0; j < 4; j++)
    
46.             cout << a[i][j] << ' ';
    
47.         cout << endl;
    
48.     }
    
49.     // 释放一定要写，不写释放的代码在一些环境下会报错的
    
50.     for(int i = 0; i < 4; i++)
    
51.         delete[] a[i];
    
52.     delete[] a;
    
53.     return 0;
    
54. }
    

复制代码

1. TransposeMatri((int **)((int *)array + i * n + j), k);

复制代码

我一开始确实是在这里改的，但是我发现这里修改对 int a[4][4];，这样的数组无效，所以修改了

1. swap((*(int (*)[n][n])(array))[i][j], (*(int (*)[n][n])(array))[j][i]);

复制代码

但是这样依然不对，因为这样的转换要求数组中的值是连续存放的，通过 new 这样的形式创建出来的数组，数组中存储的值不是连续的

1. #include <algorithm>
   
2. #include <iostream>
   
3. 
   
4. using namespace std;
   
5. 
   
6. void TransposeMatri(int **array, int n) { //全部转置
   
7.     for(int i = 0; i < n; i++)
   
8.         for(int j = 0; j < n; j++) {
   
9.             if(j > i) //主副三角
   
10.                 //swap(array[i][j], array[j][i]);
    
11.                 swap((*(int (*)[n][n])(array))[i][j], (*(int (*)[n][n])(array))[j][i]);
    
12.         }
    
13. }
    
14. 
    
15. void Block_transpose(int **array, int n) { //分块转置
    
16.     int k = 2;
    
17.     for(int i = 0; i < n; i += k)
    
18.         for(int j = 0; j < n; j += k)
    
19.             TransposeMatri((int **)((int *)array + i * n + j), k);
    
20. }
    
21. 
    
22. int main() {
    
23.     /*
    
24.     int **a = new int *[4];
    
25.     for(int i = 0; i < 4; i++)
    
26.         a[i] = new int[4];
    
27.     */
    
28.     int a[4][4];
    
29.     for(int i = 0; i < 4; i++) {
    
30.         for(int j = 0; j < 4; j++) {
    
31.             a[i][j] = i * 4 + j;
    
32.         }
    
33.     }
    
34.     for(int i = 0; i < 4; i++) {
    
35.         for(int j = 0; j < 4; j++)
    
36.             cout << a[i][j] << ' ';
    
37.         cout << endl;
    
38.     }
    
39.     //Block_transpose(a, 4);
    
40.     Block_transpose((int **)a, 4);
    
41.     cout << "---------------------" << endl;
    
42.     /*
    
43.     for(int i = 0; i < 4; i++)
    
44.         for(int j = 0; j < 4; j++)
    
45.             cout << a[i][j] << ' ';
    
46.     cout << endl;
    
47.     */
    
48.     for(int i = 0; i < 4; i++) {
    
49.         for(int j = 0; j < 4; j++)
    
50.             cout << a[i][j] << ' ';
    
51.         cout << endl;
    
52.     }
    
53.     /*
    
54.     // 释放一定要写，不写释放的代码在一些环境下会报错的
    
55.     for(int i = 0; i < 4; i++)
    
56.         delete[] a[i];
    
57.     delete[] a;
    
58.     */
    
59.     return 0;
    
60. }
    

复制代码

1. $ ./main
   
2. 0 1 2 3
   
3. 4 5 6 7
   
4. 8 9 10 11
   
5. 12 13 14 15
   
6. ---------------------
   
7. 0 2 1 4
   
8. 3 5 6 7
   
9. 8 10 9 12
   
10. 11 13 14 15
    
11. $

复制代码

这样就能运行了，不会在运行的时候报错，然后停止运行了
但是结果依然不对
因为这个数组在内存中是这样存储的
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
是线性的，0 后面存储 1，1 后面存储 2，2 后面存储 3，。。。
第一个子矩阵中，你要互换的是 1 和 4，但是 1 和 4 并不挨着
要么进行计算，算出 4 的地址，要么创建一个临时数组，让 1 和 4 挨着
我选择了后者

1. #include <algorithm>
   
2. #include <iostream>
   
3. 
   
4. using namespace std;
   
5. 
   
6. void TransposeMatri(int **array, int n) { //全部转置
   
7.     for(int i = 0; i < n; i++)
   
8.         for(int j = 0; j < n; j++) {
   
9.             if(j > i) //主副三角
   
10.                 //swap(array[i][j], array[j][i]);
    
11.                 swap((*(int (*)[n][n])(array))[i][j], (*(int (*)[n][n])(array))[j][i]);
    
12.         }
    
13. }
    
14. 
    
15. void Block_transpose(int **array, int n) { //分块转置
    
16.     /*
    
17.     int k = 2;
    
18.     for(int i = 0; i < n; i += k)
    
19.         for(int j = 0; j < n; j += k)
    
20.             TransposeMatri((int **)((int *)array + i * n + j), k);
    
21.     */
    
22.     int k = 2;
    
23.     for(int i = 0; i < n; i += k)
    
24.         for(int j = 0; j < n; j += k) {
    
25.             int a[k][k];
    
26.             for(int y = 0; y < k; ++y) {
    
27.                 for(int x = 0; x < k; ++x) {
    
28.                     a[y][x] = (*(int (*)[n][n])array)[i + y][j + x];
    
29.                 }
    
30.             }
    
31.             //TransposeMatri((int **)((int *)array + i * n + j), k);
    
32.             TransposeMatri((int **)a, k);
    
33.             for(int y = 0; y < k; ++y) {
    
34.                 for(int x = 0; x < k; ++x) {
    
35.                     (*(int (*)[n][n])array)[i + y][j + x] = a[y][x];
    
36.                 }
    
37.             }
    
38.         }
    
39. }
    
40. 
    
41. int main() {
    
42.     /*
    
43.     int **a = new int *[4];
    
44.     for(int i = 0; i < 4; i++)
    
45.         a[i] = new int[4];
    
46.     */
    
47.     int a[4][4];
    
48.     for(int i = 0; i < 4; i++) {
    
49.         for(int j = 0; j < 4; j++) {
    
50.             a[i][j] = i * 4 + j;
    
51.         }
    
52.     }
    
53.     for(int i = 0; i < 4; i++) {
    
54.         for(int j = 0; j < 4; j++)
    
55.             cout << a[i][j] << ' ';
    
56.         cout << endl;
    
57.     }
    
58.     //Block_transpose(a, 4);
    
59.     Block_transpose((int **)a, 4);
    
60.     cout << "---------------------" << endl;
    
61.     /*
    
62.     for(int i = 0; i < 4; i++)
    
63.         for(int j = 0; j < 4; j++)
    
64.             cout << a[i][j] << ' ';
    
65.     cout << endl;
    
66.     */
    
67.     for(int i = 0; i < 4; i++) {
    
68.         for(int j = 0; j < 4; j++)
    
69.             cout << a[i][j] << ' ';
    
70.         cout << endl;
    
71.     }
    
72.     /*
    
73.     // 释放一定要写，不写释放的代码在一些环境下会报错的
    
74.     for(int i = 0; i < 4; i++)
    
75.         delete[] a[i];
    
76.     delete[] a;
    
77.     */
    
78.     return 0;
    
79. }
    

复制代码

1. $ ./main
   
2. 0 1 2 3
   
3. 4 5 6 7
   
4. 8 9 10 11
   
5. 12 13 14 15
   
6. ---------------------
   
7. 0 4 2 6
   
8. 1 5 3 7
   
9. 8 12 10 14
   
10. 9 13 11 15
    
11. $

复制代码

1. a[y][x] = (*(int (*)[n][n])array)[i + y][j + x];

复制代码

其实这样也需要计算 4 的地址，然后读取 4 的值到 临时数组
我认为创建临时数组比较好，所以选择了创建临时数组

人造人

其实对于调试程序，输入和输出是很重要的，不知道输出就不知道努力的方向，不知道应该把程序调试成什么样子，不知道应该通过调试让程序输出什么
而输出依赖于输入
正确的输出依赖于正确的输入，知道了输入和输出问题就简单了，因为你知道正确的输出，就知道了要把程序调试成什么样子

万千只cnm

人造人 发表于 2021-9-21 10:34
这个你还是没有说对不对
不过你没有说错，而且从你说的内容来看，应该是对的，那我就认为是对的了

”通过 new 这样的形式创建出来的数组，数组中存储的值不是连续的“
请问这句话啥意思 跟c的malloc不一样吗 不都是申请的一整块空间嘛

1. swap((*(int (*)[n][n])(array))[i][j], (*(int (*)[n][n])(array))[j][i]);

复制代码

这是先array转换为一个指向二维数组的指针然后解引用吗

“这个代码是错的，因为你进行了强制类型转换，可以通过编译了，但是类型不对
地址值是一样的，但是类型不对”
如果说array本来是个指针数组名  我强制转换为int** 为啥会不对

万千只cnm

jhq999 发表于 2021-9-21 06:58
这个流程，而且成员越多，小矩阵互换越多

是不不止要分成4个子矩阵换吗
我感觉正中间的子矩阵也要互换才能

人造人

万千只cnm 发表于 2021-9-21 12:49
”通过 new 这样的形式创建出来的数组，数组中存储的值不是连续的“
请问这句话啥意思 跟c的malloc不一 ...

1. #include <iostream>
   
2. 
   
3. int main() {
   
4.     int a[4][4];
   
5.     for(int i = 0; i < 4; i++) {
   
6.         for(int j = 0; j < 4; j++) {
   
7.             a[i][j] = i * 4 + j;
   
8.         }
   
9.     }
   
10.     for(int i = 0; i < 4; i++) {
    
11.         for(int j = 0; j < 4; j++) {
    
12.             std::cout << &a[i][j] << ": " << a[i][j] << std::endl;
    
13.         }
    
14.     }
    
15.     return 0;
    
16. }
    
17. /*
    
18. 0xffffcbd0: 0
    
19. 0xffffcbd4: 1
    
20. 0xffffcbd8: 2
    
21. 0xffffcbdc: 3
    
22. 0xffffcbe0: 4
    
23. 0xffffcbe4: 5
    
24. 0xffffcbe8: 6
    
25. 0xffffcbec: 7
    
26. 0xffffcbf0: 8
    
27. 0xffffcbf4: 9
    
28. 0xffffcbf8: 10
    
29. 0xffffcbfc: 11
    
30. 0xffffcc00: 12
    
31. 0xffffcc04: 13
    
32. 0xffffcc08: 14
    
33. 0xffffcc0c: 15
    
34. */
    

复制代码

1. #include <iostream>
   
2. 
   
3. int main() {
   
4.     int **a = new int *[4];
   
5.     for(int i = 0; i < 4; i++) {
   
6.         a[i] = new int[4];
   
7.         for(int j = 0; j < 4; j++) {
   
8.             a[i][j] = i * 4 + j;
   
9.         }
   
10.     }
    
11.     for(int i = 0; i < 4; i++) {
    
12.         for(int j = 0; j < 4; j++) {
    
13.             std::cout << &a[i][j] << ": " << a[i][j] << std::endl;
    
14.         }
    
15.     }
    
16.     for(int i = 0; i < 4; i++) delete[] a[i];
    
17.     delete[] a;
    
18.     return 0;
    
19. }
    
20. /*
    
21. 0x800038ca0: 0
    
22. 0x800038ca4: 1
    
23. 0x800038ca8: 2
    
24. 0x800038cac: 3
    
25. 0x800038cc0: 4      // 这里应该是 0x800038cb0 才是连续的
    
26. 0x800038cc4: 5
    
27. 0x800038cc8: 6
    
28. 0x800038ccc: 7
    
29. 0x80004b140: 8      // 0x800038cd0，如果从数组开始，这个地址是 0x800038cc0
    
30. 0x80004b144: 9
    
31. 0x80004b148: 10
    
32. 0x80004b14c: 11
    
33. 0x80004b160: 12     // 0x80004b150, 0x800038cd0
    
34. 0x80004b164: 13
    
35. 0x80004b168: 14
    
36. 0x80004b16c: 15
    
37. */
    

复制代码

人造人

万千只cnm 发表于 2021-9-21 12:49
”通过 new 这样的形式创建出来的数组，数组中存储的值不是连续的“
请问这句话啥意思 跟c的malloc不一 ...

地址一样，类型不对

1. #include <iostream>
   
2. 
   
3. void func(int **a) {
   
4.     for(int i = 0; i < 4; i++) {
   
5.         std::cout << a[i] << std::endl;
   
6.     }
   
7.     /*
   
8.     for(int i = 0; i < 4; i++) {
   
9.         for(int j = 0; j < 4; j++) {
   
10.             std::cout << a[i][j] << std::endl;
    
11.         }
    
12.     }
    
13.     */
    
14. }
    
15. 
    
16. int main() {
    
17.     int a[4][4];
    
18.     for(int i = 0; i < 4; i++) {
    
19.         for(int j = 0; j < 4; j++) {
    
20.             a[i][j] = i * 4 + j;
    
21.         }
    
22.     }
    
23.     func((int **)a);
    
24.     return 0;
    
25. }
    
26. /*
    
27. 0x100000000
    
28. 0x300000002
    
29. 0x500000004
    
30. 0x700000006
    
31. */
    

复制代码

这个输出结果你可能已经明白了，但是看了下面这个输出结果，你肯定明白了

1. #include <iostream>
   
2. 
   
3. void func(long long **a) {
   
4.     for(int i = 0; i < 4; i++) {
   
5.         std::cout << a[i] << std::endl;
   
6.     }
   
7.     /*
   
8.     for(int i = 0; i < 4; i++) {
   
9.         for(int j = 0; j < 4; j++) {
   
10.             std::cout << a[i][j] << std::endl;
    
11.         }
    
12.     }
    
13.     */
    
14. }
    
15. 
    
16. int main() {
    
17.     long long a[4][4];
    
18.     for(int i = 0; i < 4; i++) {
    
19.         for(int j = 0; j < 4; j++) {
    
20.             a[i][j] = i * 4 + j;
    
21.         }
    
22.     }
    
23.     func((long long **)a);
    
24.     return 0;
    
25. }
    
26. /*
    
27. 0
    
28. 0x1
    
29. 0x2
    
30. 0x3
    
31. */
    

复制代码

一次解引用得到的就已经是数组中存储的值了，然后再对这个值解引用？
如果这个值是 0，那就是对 0 解引用
对于第二个代码，a[i][j] 就是对 0x00000000、0x00000001、0x00000002、0x00000003
这 4 个地址解引用

1. #include <iostream>
   
2. 
   
3. void func(long long **a) {
   
4.     for(int i = 0; i < 4; i++) {
   
5.         std::cout << a[i] << std::endl;
   
6.     }
   
7.     for(int i = 0; i < 4; i++) {
   
8.         for(int j = 0; j < 4; j++) {
   
9.             std::cout << a[i][j] << std::endl;
   
10.         }
    
11.     }
    
12. }
    
13. 
    
14. int main() {
    
15.     long long a[4][4];
    
16.     for(int i = 0; i < 4; i++) {
    
17.         for(int j = 0; j < 4; j++) {
    
18.             a[i][j] = i * 4 + j;
    
19.         }
    
20.     }
    
21.     func((long long **)a);
    
22.     return 0;
    
23. }
    
24. /*
    
25. 0
    
26. 0x1
    
27. 0x2
    
28. 0x3
    
29. Segmentation fault (core dumped)
    
30. */
    

复制代码

人造人

人造人

地址一样，但是类型不对

1. #include <iostream>
   
2. 
   
3. int main() {
   
4.     long long a[4][4] = {
   
5.         {123, 456, 789, -1},
   
6.         {223, 556, 889, -2},
   
7.         {323, 656, 989, -3},
   
8.         {423, 756, 189, -4}
   
9.     };
   
10.     long long **x = (long long **)a;
    
11.     std::cout << a[0] << std::endl;
    
12.     std::cout << x[0] << std::endl;
    
13.     std::cout << (long long)a[0] << std::endl;
    
14.     std::cout << (long long)x[0] << std::endl;
    
15.     return 0;
    
16. }
    
17. /*
    
18. 0xffffcb90
    
19. 0x7b
    
20. 4294953872
    
21. 123
    
22. */
    

复制代码

万千只cnm

人造人 发表于 2021-9-21 13:51
地址一样，但是类型不对

道理我是懂呀。
但我是new申请的数组不算严格的数组吧 new申请的二维数组不就是指针形式吗
为什么swap还要换呢

人造人

万千只cnm 发表于 2021-9-21 21:44
道理我是懂呀。
但我是new申请的数组不算严格的数组吧 new申请的二维数组不就是指针形式吗
为什么swap ...

没明白你的问题

万千只cnm

人造人 发表于 2021-9-21 22:22
没明白你的问题

1. swap(array[i][j], array[j][i]);

复制代码

array本来就是一个int ** 指针呀  指向new申请的空间
不是二维数组名 ，不存在强制转换类型吧？

人造人

万千只cnm 发表于 2021-9-22 18:14
array本来就是一个int ** 指针呀  指向new申请的空间
不是二维数组名 ，不存在强制转换类型吧？

1. TransposeMatri((int **)((int *)array + i * n + j), k);

复制代码

你在这里进行了强制类型转换
还有，你可以写一个示例代码说明你的问题吗？我还是不理解你的问题
示例代码越短小越好，能够说明你的问题就好了

你这样描述，我也没有什么概念，还是尽量用代码说话比较好

万千只cnm

人造人 发表于 2021-9-22 18:29
你在这里进行了强制类型转换
还有，你可以写一个示例代码说明你的问题吗？我还是不理解你的问题
示 ...

array本身就是一个指针

1. int **a = new int *[4];

复制代码

用这种方式来形成二维数组
我为了定位到 下一个子矩阵  i*n就是一行的总地址，j就列的地址
array+行+列 就是子矩阵的首地址，然后转换为 int**  就跟原形式一样了  
但你说了new申请的空间不一定连续 我就知道我错了

人造人

万千只cnm 发表于 2021-9-22 18:43
array本身就是一个指针

用这种方式来形成二维数组

嗯，也就是说这个问题你明白了？

万千只cnm

人造人 发表于 2021-9-22 19:25
嗯，也就是说这个问题你明白了？