C++ 如何顺时针交换二次矩阵的四分之一（从左上角开始）？

我想写一个程序：

生成大小为（2Nx2N）的二次矩阵

打印这个矩阵

顺时针交换矩阵的四分之一（从顶部开始 （左角）

打印更改矩阵

例如，我的程序的输出应如下所示：

01 02 03 04 
05 06 07 08 
09 10 11 12
13 14 15 16

Matrix (changed)

09 10 01 02
13 14 05 06
11 12 03 03 
15 16 07 08

for (int i = 0; i < N; ++i) {
    for (int k = 0; k < N; ++k) {
        int t = m[i][k];
        m[i][k] = m[N + i][k];
        m[N + i][k] = m[N + i][N + k];
        m[N + i][N + k] = m[i][N + k];
        m[i][N + k] = t;
    }
}

以下是我的源代码：

#include <iostream>
#include <stdlib.h>
#include <time.h>
#include <iomanip>
using namespace std;

const int n = 4; // size of matrix

void CreateMatrix(int matrix[][n], int n); // functions' prototypes
void PrintMatrix(int matrix[][n], int n);
void ProcessMatrix(int matrix[][n], int n);
int main()
{
    int matrix[n][n];

    srand(time(NULL));

    CreateMatrix(matrix, n);    //create matrix
    PrintMatrix(matrix, n);     //print matrix
    ProcessMatrix(matrix, n);   //change matrix

    cout<<"\nMatrix(changed):\n"; 

    PrintMatrix(matrix, n);    // print changed matrix

}
void CreateMatrix(int matrix[][n],int n)
{
    for (int i =0; i<n; i++)
        for(int j = 0; j<n; j++)
            matrix[i][j] = rand()%10;
}
void PrintMatrix(int matrix[][n], int n)
{
    for(int i=0; i<n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            cout<<matrix[i][j]<<" ";
        }
        cout<<"\n";
    }
}
void ProcessMatrix(int matrix[][n], int n) 
{
    // I don't know how to write this function
}

#包括
#包括
#包括
#包括
使用名称空间std；
常数int n=4；//矩阵大小
void CreateMatrix（int-matrix[][n]，int-n）；//函数的原型
void PrintMatrix（int-matrix[][n]，int-n）；
void ProcessMatrix（int-matrix[][n]，int-n）；
int main（）
{
整数矩阵[n][n]；
srand（时间（空））；
CreateMatrix（矩阵，n）；//创建矩阵
PrintMatrix（矩阵，n）；//打印矩阵
ProcessMatrix（矩阵，n）；//更改矩阵
你可以为（0..N-1，0..N-1）中的（i，j）旋转m[i][j]、m[N+i][j]、m[N+i][N+j]和m[N+i][j]。
你为（0..N-1，0..N-1）中的（i，j）旋转m[i][j]、m[N+i][j]、m[N+i][N+j]和m[N+i][j]

//这里有什么问题吗

错误的是，在处理矩阵的某些部分之前，您开始覆盖它们

你需要一份你可以使用的矩阵副本，而不需要修改原始矩阵。完成后，你可以更新原始矩阵

void ProcessMatrix(int matrix[][n], int n) {
    int newmatrix[n][n];

    // build new one
    for (int i = 0; i<n/2; i++) {
        for (int j=0; j<n/2; j++) {
            newmatrix[i][j] = matrix[i][j+n/2];
            newmatrix[i][j+n/2] = matrix[i+n/2][j+n/2];
            newmatrix[i+n/2][j+n/2] = matrix[i+n/2][j];
            newmatrix[i+n/2][j] = matrix[i][j];
        }
    }

    // copy it to old
    for (int i = 0; i<n; i++) {
        for(int j=0; j<n; j++) {
            matrix[i][j] = newmatrix[i][j];
        }
    }
}

void ProcessMatrix（int-matrix[][n]，int-n）{
int newmatrix[n][n]；
//新建一个
对于（int i=0；i
//这里有什么问题吗

错误的是，在处理矩阵的某些部分之前，您开始覆盖它们

你需要一份你可以使用的矩阵副本，而不需要修改原始矩阵。完成后，你可以更新原始矩阵

void ProcessMatrix(int matrix[][n], int n) {
    int newmatrix[n][n];

    // build new one
    for (int i = 0; i<n/2; i++) {
        for (int j=0; j<n/2; j++) {
            newmatrix[i][j] = matrix[i][j+n/2];
            newmatrix[i][j+n/2] = matrix[i+n/2][j+n/2];
            newmatrix[i+n/2][j+n/2] = matrix[i+n/2][j];
            newmatrix[i+n/2][j] = matrix[i][j];
        }
    }

    // copy it to old
    for (int i = 0; i<n; i++) {
        for(int j=0; j<n; j++) {
            matrix[i][j] = newmatrix[i][j];
        }
    }
}

void ProcessMatrix（int-matrix[][n]，int-n）{
int newmatrix[n][n]；
//新建一个
对于（int i=0；i请注意，
N
是矩阵大小的一半，如问题描述中所用，但不在代码中。这里的矩阵是
m[2*N][2*N]

其思想是迭代矩阵的四分之一，然后在所有四分之一的相应位置对四个元素进行周期性交换。元素需要按如下所示的周期移动：

m[i    ][k] ----> m[i    ][N + k]
     A                  |
     |                  |
     |                  |
     |                  V
m[N + i][k] <---- m[N + i][N + k]

m[i][k]--->m[i][N+k]
A|
|                  |
|                  |
|五
m[N+i][k]请注意，以下是表示
N
为矩阵大小的一半，如在问题描述中所用，但不在代码中。此处的矩阵是
m[2*N][2*N]

其思想是迭代矩阵的四分之一，然后在所有四分之一的相应位置对四个元素进行周期性交换。元素需要按如下所示的周期移动：

m[i    ][k] ----> m[i    ][N + k]
     A                  |
     |                  |
     |                  |
     |                  V
m[N + i][k] <---- m[N + i][N + k]

m[i][k]--->m[i][N+k]
A|
|                  |
|                  |
|五
m[N+i][k]这感觉有点像家庭作业。你试过什么了吗？请给我们你的矩阵和你想要的矩阵结果。第一件事：使用向量或数组这会使你的代码更简单，因为你不需要传播矩阵的大小arrays@fejese见我的编辑question@Gabriel我会使用向量，但我不能，因为我的老师不喜欢它这有点像家庭作业。你试过什么了吗？请给我们你的矩阵和你想要的矩阵结果。第一件事：使用向量或数组这会使你的代码更简单，因为你不需要传播矩阵的大小arrays@fejese见我的编辑question@Gabriel我会使用向量，但我不能，因为我的老师不喜欢我假设你意思是应该有4个for循环。但是这些循环的条件是什么？我不明白。间隔不是应该是
（0..n/2-1）
？哦，我想我知道混乱的根源。这个问题是关于2Nx2N矩阵（你在回答中使用了它）但是OP的代码使用
n
作为矩阵的实际大小，我在回答中使用了它。我想你的意思是应该有4个for循环。但是这些循环的条件是什么？我不明白。间隔不应该是
（0..n/2-1）
？哦，我想我知道混乱的根源。这个问题是关于2Nx2N矩阵的（您在回答中使用了该选项）但是OP的代码使用
n
作为矩阵的实际大小，我在回答中使用了它。老实说，我也在考虑矩阵的副本。但是我的代码没有编译…非常感谢！你帮了我很多！你不必复制整个矩阵；每次旋转只复制一个值。我不确定我是否理解你的意思.I循环一个象限的元素，并在所有迭代中处理每个象限的一个元素，从而处理所有元素。至少这是想法：）我遗漏了什么吗？老实说，我也在考虑复制矩阵。但是我的代码没有编译…非常感谢！你帮了我很多！你不需要复制整个矩阵；每次旋转只复制一个值。我不确定我是否理解你说的话。我循环了一个象限的元素，并从一个象限处理一个元素在所有的迭代中，每个象限都会处理所有的元素。至少我的想法是：）我遗漏了什么吗？