矩阵转置-动态内存分配

矩阵转置是将矩阵的行转换为列，列转换为行。对于动态内存分配的情况，可以使用指针数组来实现。

在引用和引用中，都给出了一个基于动态内存分配的矩阵转置的示例代码。这两个示例代码都是使用指针数组来保存矩阵的元素。

在引用中，使用了二级指针a来指向一个指针数组，其中每个元素又指向一个一维数组。通过循环语句来输入矩阵的元素，并且使用swap函数进行矩阵元素的行列对调。然后再通过循环语句输出转置后的矩阵。

在引用中，使用了二维指针m来指向一个动态分配的二维数组。同样通过循环语句来输入矩阵的元素，并且使用swap函数进行矩阵元素的行列对调。然后再通过循环语句输出转置后的矩阵。

总结来说，动态内存分配的矩阵转置可以通过指针数组来实现，在循环语句中进行矩阵元素的行列对调操作，最后输出转置后的矩阵。

相关问题

C++编写并测试33矩阵转置函数，使用动态内存分配生成动态数组

下面是一个C++编写并测试33矩阵转置函数的例子：

#include <iostream>
using namespace std;

int main() {
    int **matrix = new int*[3]; //动态分配3行
    for(int i = 0; i < 3; i++) {
        matrix[i] = new int[3]; //动态分配3列
        for(int j = 0; j < 3; j++) {
            matrix[i][j] = i * 3 + j + 1; //为矩阵赋初值
        }
    }

    //输出原矩阵
    cout << "原矩阵：" << endl;
    for(int i = 0; i < 3; i++) {
        for(int j = 0; j < 3; j++) {
            cout << matrix[i][j] << " ";
        }
        cout << endl;
    }

    //转置矩阵
    int **transpose = new int*[3]; //动态分配3行
    for(int i = 0; i < 3; i++) {
        transpose[i] = new int[3]; //动态分配3列
        for(int j = 0; j < 3; j++) {
            transpose[i][j] = matrix[j][i]; //转置矩阵
        }
    }

    //输出转置矩阵
    cout << "转置矩阵：" << endl;
    for(int i = 0; i < 3; i++) {
        for(int j = 0; j < 3; j++) {
            cout << transpose[i][j] << " ";
        }
        cout << endl;
    }

    //释放动态内存
    for(int i = 0; i < 3; i++) {
        delete[] matrix[i];
        delete[] transpose[i];
    }
    delete[] matrix;
    delete[] transpose;

    return 0;
}

这个程序中，首先通过 `new` 运算符动态分配了一个3行3列的矩阵 `matrix`。然后，通过两重循环为矩阵赋初值，并输出原矩阵。接着，再动态分配一个3行3列的矩阵 `transpose`，并通过两重循环将 `matrix` 转置到 `transpose` 中，最后输出转置矩阵。最后，通过两重循环释放动态内存。

注意，动态分配的内存必须在不需要使用时及时释放，否则会造成内存泄漏。

使用动态内存分配生成动态数组编写并测试3*3矩阵转置函数

下面是使用动态内存分配生成动态数组编写并测试3*3矩阵转置函数的示例代码：

#include <iostream>
using namespace std;

int** createMatrix(int rows, int cols) {
    int** matrix = new int*[rows];
    for (int i = 0; i < rows; i++) {
        matrix[i] = new int[cols];
    }
    return matrix;
}

void deleteMatrix(int** matrix, int rows) {
    for (int i = 0; i < rows; i++) {
        delete[] matrix[i];
    }
    delete[] matrix;
}

void transposeMatrix(int** matrix, int rows, int cols) {
    int** temp = createMatrix(cols, rows);
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            temp[j][i] = matrix[i][j];
        }
    }

    for (int i = 0; i < rows; i++) {
        delete[] matrix[i];
    }
    delete[] matrix;

    matrix = createMatrix(cols, rows);
    for (int i = 0; i < cols; i++) {
        for (int j = 0; j < rows; j++) {
            matrix[i][j] = temp[i][j];
        }
    }

    deleteMatrix(temp, cols);
}

int main() {
    int** matrix = createMatrix(3, 3);
    int count = 1;
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            matrix[i][j] = count++;
        }
    }

    cout << "Before transpose: " << endl;
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            cout << matrix[i][j] << " ";
        }
        cout << endl;
    }

    transposeMatrix(matrix, 3, 3);

    cout << "After transpose: " << endl;
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            cout << matrix[i][j] << " ";
        }
        cout << endl;
    }

    deleteMatrix(matrix, 3);

    return 0;
}

在上面的示例代码中，我们首先定义了一个 `createMatrix` 函数来生成动态数组，该函数使用了动态内存分配来创建一个二维的动态数组。然后，我们定义了 `deleteMatrix` 函数来释放动态数组占用的内存。接下来定义了 `transposeMatrix` 函数来实现矩阵转置，该函数接受一个二维动态数组、行数和列数作为参数。在该函数中，我们首先创建一个临时的二维动态数组来存储转置后的矩阵，然后释放原始的二维动态数组占用的内存，最后重新创建一个新的二维动态数组来存储转置后的矩阵。最后，我们在 `main` 函数中生成一个3*3的矩阵，进行矩阵转置，并输出转置前和转置后的矩阵。

需要注意的是，在 `transposeMatrix` 函数中，我们使用了 `deleteMatrix` 函数来释放临时数组占用的内存。这是因为我们使用动态内存分配生成的动态数组必须手动释放，否则会造成内存泄漏。