C++ 在c+中的O（1）时间内交换2d数组的行或列+；

我的问题是，如何在O（1）时间内交换二维数组的两行或两列？我在互联网上搜索，发现了一个函数memcpy，但我不知道如何使用它。 比如说

给定一个矩阵：

1 2 3 
4 5 6 
7 8 9

如果我们交换第1行和第2行

4 5 6
1 2 3
7 8 9

---

可以在行和列上使用间接数组。换句话说，访问您使用的元素

i，j

data[rowix[i]][colix[j]]

而不是普通的

data[i][j]

对于元素访问来说，这仍然是一个O（1）（尽管常数因子较大），但也允许您在固定时间内交换行和列（只需交换索引数组元素）

在C中++

template<int ROWS, int COLS, typename T>
struct Mat2d {
    T data[ROWS][COLS];
    int colix[COLS], rowix[ROWS];
    Mat2d() {
        for (int i=0; i<ROWS; i++) {
            for (int j=0; j<COLS; j++) {
                data[i][j] = T();
            }
        }
        for (int i=0; i<ROWS; i++) rowix[i] = i;
        for (int j=0; j<COLS; j++) colix[j] = j;
    }
    T& operator()(int i, int j) { return data[rowix[i]][colix[j]]; }
    T operator()(int i, int j) const { return data[rowix[i]][colix[j]]; }
    void swapRows(int i1, int i2) { std::swap(rowix[i1], rowix[i2]); }
    void swapCols(int j1, int j2) { std::swap(colix[j1], colix[j2]); }
};

模板
结构Mat2d{
T数据[行][COLS]；
int colix[COLS]，rowix[ROWS]；
Mat2d（）{
对于（int i=0；i您可以在行和列上使用间接数组。换句话说，要访问元素，您可以使用

data[rowix[i]][colix[j]]

而不是普通的

data[i][j]

对于元素访问来说，这仍然是一个O（1）（尽管常数因子较大），但也允许您在固定时间内交换行和列（只需交换索引数组元素）

在C中++

template<int ROWS, int COLS, typename T>
struct Mat2d {
    T data[ROWS][COLS];
    int colix[COLS], rowix[ROWS];
    Mat2d() {
        for (int i=0; i<ROWS; i++) {
            for (int j=0; j<COLS; j++) {
                data[i][j] = T();
            }
        }
        for (int i=0; i<ROWS; i++) rowix[i] = i;
        for (int j=0; j<COLS; j++) colix[j] = j;
    }
    T& operator()(int i, int j) { return data[rowix[i]][colix[j]]; }
    T operator()(int i, int j) const { return data[rowix[i]][colix[j]]; }
    void swapRows(int i1, int i2) { std::swap(rowix[i1], rowix[i2]); }
    void swapCols(int j1, int j2) { std::swap(colix[j1], colix[j2]); }
};

模板
结构Mat2d{
T数据[行][COLS]；
int colix[COLS]，rowix[ROWS]；
Mat2d（）{
对于（int i=0；i您可以在行和列上使用间接数组。换句话说，要访问元素，您可以使用

data[rowix[i]][colix[j]]

而不是普通的

data[i][j]

对于元素访问来说，这仍然是一个O（1）（尽管常数因子较大），但也允许您在固定时间内交换行和列（只需交换索引数组元素）

在C中++

template<int ROWS, int COLS, typename T>
struct Mat2d {
    T data[ROWS][COLS];
    int colix[COLS], rowix[ROWS];
    Mat2d() {
        for (int i=0; i<ROWS; i++) {
            for (int j=0; j<COLS; j++) {
                data[i][j] = T();
            }
        }
        for (int i=0; i<ROWS; i++) rowix[i] = i;
        for (int j=0; j<COLS; j++) colix[j] = j;
    }
    T& operator()(int i, int j) { return data[rowix[i]][colix[j]]; }
    T operator()(int i, int j) const { return data[rowix[i]][colix[j]]; }
    void swapRows(int i1, int i2) { std::swap(rowix[i1], rowix[i2]); }
    void swapCols(int j1, int j2) { std::swap(colix[j1], colix[j2]); }
};

模板
结构Mat2d{
T数据[行][COLS]；
int colix[COLS]，rowix[ROWS]；
Mat2d（）{
对于（int i=0；i您可以在行和列上使用间接数组。换句话说，要访问元素，您可以使用

data[rowix[i]][colix[j]]

而不是普通的

data[i][j]

对于元素访问来说，这仍然是一个O（1）（尽管常数因子较大），但也允许您在固定时间内交换行和列（只需交换索引数组元素）

在C中++

template<int ROWS, int COLS, typename T>
struct Mat2d {
    T data[ROWS][COLS];
    int colix[COLS], rowix[ROWS];
    Mat2d() {
        for (int i=0; i<ROWS; i++) {
            for (int j=0; j<COLS; j++) {
                data[i][j] = T();
            }
        }
        for (int i=0; i<ROWS; i++) rowix[i] = i;
        for (int j=0; j<COLS; j++) colix[j] = j;
    }
    T& operator()(int i, int j) { return data[rowix[i]][colix[j]]; }
    T operator()(int i, int j) const { return data[rowix[i]][colix[j]]; }
    void swapRows(int i1, int i2) { std::swap(rowix[i1], rowix[i2]); }
    void swapCols(int j1, int j2) { std::swap(colix[j1], colix[j2]); }
};

模板
结构Mat2d{
T数据[行][COLS]；
int colix[COLS]，rowix[ROWS]；
Mat2d（）{
对于（int i=0；i）您的老师要求您交换行指针。如果它是2D数组，那么您不能在O（1）中进行交换（您必须将每个元素从一行复制到另一行，因此运行时取决于列数，而不是O（1），除非您的数组始终具有相同的列数。）。您可以尝试使用指针数组，其中交换两行（无论多长）只是交换两个指针的问题。您可以用代码解释一下吗？在o（1）中交换行和列是另一个问题。这不是重复的。memcpy不会是o（1）。这是否可能取决于数据结构的实现方式。您的老师要求您交换行指针。如果是2D数组，则无法在O（1）中进行交换（您必须将每个元素从一行复制到另一行，因此运行时取决于列数，而不是O（1）除非你的数组总是有相同的列数。）。你可以尝试使用指针数组，而交换两行，无论多长，都只是交换两个指针的问题。你能用代码解释一下吗？在o（1）中交换行和列是另一个问题。这不是重复的。memcpy不会是o（1）。这是否可能取决于数据结构的实现方式。您的老师要求您交换行指针。如果是2D数组，则无法在O（1）中进行交换（您必须将每个元素从一行复制到另一行，因此运行时取决于列数，而不是O（1）除非你的数组总是有相同的列数。）。你可以尝试使用指针数组，而交换两行，无论多长，都只是交换两个指针的问题。你能用代码解释一下吗？在o（1）中交换行和列是另一个问题。这不是重复的。memcpy不会是o（1）。这是否可能取决于数据结构的实现方式。您的老师要求您交换行指针。如果是2D数组，则无法在O（1）中进行交换（您必须将每个元素从一行复制到另一行，因此运行时取决于列数，而不是O（1）除非你的数组总是有相同的列数。）。你可以尝试使用指针数组，而交换两行，无论多长，都只是交换两个指针的问题。你能用代码解释一下吗？在o（1）中交换行和列是另一个问题。这不是重复的。memcpy不会是o（1）.这是否可能取决于数据结构是如何实现的。@NeilKirk:当然可以，但仍然是O（1）对于元素访问，交换行和交换列。如果他提交这个答案，他的老师会看穿他的：-DWAY太复杂了。老师没有要求一个可以任意交换行和列的系统。只要求一些可以在O（1）中交换行的东西.老师试图让学生考虑使用指向1D数组的指针的1D数组来表示2D数组。尝试在不使用模板的情况下解决此问题。@NeilKirk:当然可以，但仍然是O（1）对于元素访问，交换行和交换列。如果他提交这个答案，他的老师会看穿他的：-DWAY太复杂了。老师没有要求一个可以任意交换行和列的系统。只要求一些可以在O（1）中交换行的东西.老师试图让学生考虑使用指向1D数组的指针的1D数组来表示2D数组。尝试在不使用模板的情况下解决此问题。@NeilKirk:当然可以，但仍然是O（1）对于元素访问，交换行和列。如果他提交