C++ 为什么我的2d阵列不旋转？

我有一个二维正方形阵列，我想顺时针和逆时针旋转

我在这里按照这个答案向右旋转：

我开发的代码：

void rotateRight()
{  
    for (int i = 0; i < m_width; i += 1) {
        for (int j = i + 1; j < m_height; j += 1) {
            std::swap(get(i, j), get(j, i));  
        }
    }
}

我怎样才能让它旋转？是否必须制作新阵列？谢谢你的帮助。谢谢

更新：

最近的尝试。好的，“7”最后向右旋转，从左上角到右上角。但是当再次调用rotateRight（）时，它会失败。我在右上角的7已经不见了，再也找不到了。调查一下

for (int i = 0; i < m_width; i += 1) {
    for (int j = i + 1; j < m_height; j += 1) {
        get(j, i) = get(i, j);
    }
}
for (int i = 0; i < m_height; i++) {
    for (int j = 0, k = m_height - 1; j<k; j++, k--) {
        std::swap(get(j, i), get(k, i));
    }
}

最终代码

// Rotates a squared array clockwise.
void rotateRight()
{         
    T temp; 
    int halfwidth_floor = m_width / 2;
    int halfwidth_ceil = (m_width + 1) / 2; 

    for (int j = 0; j < halfwidth_floor; j += 1) {
        for (int i = 0; i < halfwidth_ceil; i += 1) {
            std::swap(temp, get(i, j)); 
            std::swap(get(i, j), get(j, m_width - i - 1));
            std::swap(get(j, m_width - i - 1), get(m_width - i - 1, m_width - j - 1));
            std::swap(get(m_width - i - 1, m_width - j - 1), get(m_width - j - 1, i));
            std::swap(get(m_width - j - 1, i), temp);
        }
    } 
}   

// Rotates a squared array counter-clockwise.
void rotateLeft()
{
    T temp; 
    int n = m_width;  

    for (int i = 0;  i < n / 2; i++) {
        for (int j = i; j < n - i - 1; j++) {
            std::swap(temp, get(i, j));  
            std::swap(get(i, j), get(n - j - 1, i));
            std::swap(get(n - j - 1, i), get(n - i - 1, n - j - 1));
            std::swap(get(n - i - 1, n - j - 1), get(j, n - i - 1));
            std::swap(get(j, n - i - 1), temp);
        }
    }
} 

//顺时针旋转正方形数组。
void rotateRight（）
{         
温度；
int半宽地板=m半宽/2；
int halfwidth_ceil=（m_width+1）/2；
对于（int j=0；j

内部循环的每个迭代都将（i，j）与（j，i）交换

如果（i==j），那么它将不起任何作用

如果（i！=j），则交换将进行两次-例如，当i==3和j==4时进行的交换将在i==4和j==3时再次进行。当然，交换两次不会导致任何事情发生

这就是为什么代码将以一个与开始时完全相同的数组结束

相反，您可能想做的是将数据写入一个与您开始使用的数组不同的数组中

编辑：没关系，我错过了问题的

intj=I+1

部分，认为两个循环都是从0到宽度或高度迭代的。（尽管如此，上述内容对于希望做同样事情的人来说仍然是一个有用的见解。）

您的代码将转置而不是旋转数组。（转置意味着从左上到右下沿对角线反射。）要旋转，需要将每个元素（i，j）移动到（j，w-i-1）或（h-j-1，i）。（当然，要旋转90度，数组必须是正方形，即（w==h））

编辑2：

如果要将方形数组原地旋转90度，std:：swap将不起作用（因为它交换2个元素），而原始赋值将不起作用（因为它会丢失信息）。但是，您可以做的是迭代数组的四分之一并旋转一个由4个元素组成的序列，如下所示：

void rotateRight()
{
    int halfwidth_floor = m_width / 2;
    int halfwidth_ceil = (m_width + 1) / 2;
    for (int j = 0; j < halfwidth_floor; j += 1) {
        for (int i = 0; i < halfwidth_ceil; i += 1) {
            value_type temp = get(i, j);
            get(i, j) = get(j, m_width-i-1);
            get(j, m_width-i-1) = get(m_width-i-1, m_width-j-1);
            get(m_width-i-1, m_width-j-1) = get(m_width-j-1, i);
            get(m_width-j-1, i) = temp;
        }
    }
}

void rotateRight（）
{
int半宽地板=m半宽/2；
int halfwidth_ceil=（m_width+1）/2；
对于（int j=0；j

其中，

value\u type

是数组元素的类型（m\u width==m\u height）

---

在第一次迭代中，这会将左下角移动到左上角，然后将右下角移动到左下角，然后将右上角移动到右下角，然后将（临时保存的）左上角移动到右上角。后续迭代将对其他点执行相同的操作，使其更接近中心。请注意，循环的一个循环迭代到向下舍入大小的一半，而另一个循环则向上舍入：这样，在奇数大小（例如5x5）的数组中，它将查看2x3的矩形及其围绕正方形的“旋转”，以避免中间元素旋转两次（或根本不旋转）。

你应该做什么 旋转矩阵的算法包括两个步骤

转置矩阵（如果向左旋转）。如果向右旋转，则对列进行换位和颠倒顺序）

倒立

如下图所示

    1 2 3        1 4 7      3 6 9
    4 5 6    =>  2 5 8  =>  2 5 8
    7 8 9        3 6 9      1 4 7

代码 与此类似，（初始化将容纳旋转阵列的辅助阵列，因为形状可能不是正方形）

void rotate（）
{  
对于（int i=0；i对于（int j=0，int k=m_height-1；简单地说，做一个2D数组做得很好，有1D存储和索引包装器！你在做什么（交换
i
和
j
）相当于围绕其前导对角线反射数组，而不是旋转它。此外，如果
宽度
和
高度
不相等，您期望的行为是什么？（必须“缩小”数组或将其部分切除）旁注：有一个函数。@Ron我不认为函数意义上的旋转是OP想要的。我只对平方旋转感兴趣。我试着遵循这一点，得到了一些有趣的结果。如上所述。你能尝试使用更小的数组并添加一些调试打印，打印到
7
的索引中吗ng移动？在3x3数组的上方发布。m_大小是m_宽度*m_高度。将大小放入get（w，h）会导致异常。我应该吗
void rotateRight()
{
    int halfwidth_floor = m_width / 2;
    int halfwidth_ceil = (m_width + 1) / 2;
    for (int j = 0; j < halfwidth_floor; j += 1) {
        for (int i = 0; i < halfwidth_ceil; i += 1) {
            value_type temp = get(i, j);
            get(i, j) = get(j, m_width-i-1);
            get(j, m_width-i-1) = get(m_width-i-1, m_width-j-1);
            get(m_width-i-1, m_width-j-1) = get(m_width-j-1, i);
            get(m_width-j-1, i) = temp;
        }
    }
}

    1 2 3        1 4 7      3 6 9
    4 5 6    =>  2 5 8  =>  2 5 8
    7 8 9        3 6 9      1 4 7

void rotate()
{  
    for (int i = 0; i < m_width; i += 1) {
        for (int j = i + 1; j < m_height; j += 1) {
            aux_array[j][i] = get(i, j)
        }
    }
    for (int i=0; i < m_height; i++) {
        for (int j=0,  int k=m_height-1; j<k; j++,k--) {
            swap(aux_array[j][i], aux_array[k][i]);
        }
    }
}