利用压缩存储方法编程实现稀疏矩阵转置，并以矩阵形式输出。

稀疏矩阵转置的压缩存储方法可以使用三元组存储法。具体实现步骤如下：

1. 定义稀疏矩阵的三元组结构体，包括行数、列数、非零元素个数和三个数组分别存储非零元素的行下标、列下标和元素值。

struct SparseMatrix {
    int rows;
    int cols;
    int nums;
    int *rowIndex;
    int *colIndex;
    double *value;
};

2. 定义稀疏矩阵转置函数 `transpose`，接受一个稀疏矩阵作为参数，并返回转置后的稀疏矩阵。

SparseMatrix transpose(const SparseMatrix &matrix) {
    SparseMatrix transposed;
    transposed.rows = matrix.cols;
    transposed.cols = matrix.rows;
    transposed.nums = matrix.nums;
    transposed.rowIndex = new int[transposed.nums];
    transposed.colIndex = new int[transposed.nums];
    transposed.value = new double[transposed.nums];
    int *rowCounts = new int[matrix.cols];
    int *rowStarts = new int[matrix.cols];
    for (int i = 0; i < matrix.cols; i++) {
        rowCounts[i] = 0;
    }
    for (int i = 0; i < matrix.nums; i++) {
        rowCounts[matrix.colIndex[i]]++;
    }
    rowStarts[0] = 0;
    for (int i = 1; i < matrix.cols; i++) {
        rowStarts[i] = rowStarts[i - 1] + rowCounts[i - 1];
    }
    for (int i = 0; i < matrix.nums; i++) {
        int j = rowStarts[matrix.colIndex[i]];
        transposed.rowIndex[j] = matrix.colIndex[i];
        transposed.colIndex[j] = matrix.rowIndex[i];
        transposed.value[j] = matrix.value[i];
        rowStarts[matrix.colIndex[i]]++;
    }
    delete[] rowCounts;
    delete[] rowStarts;
    return transposed;
}

3. 在 `main` 函数中创建一个稀疏矩阵，调用 `transpose` 函数得到转置后的稀疏矩阵，并以矩阵形式输出两个矩阵。

int main() {
    SparseMatrix matrix;
    matrix.rows = 5;
    matrix.cols = 4;
    matrix.nums = 6;
    matrix.rowIndex = new int[matrix.nums];
    matrix.colIndex = new int[matrix.nums];
    matrix.value = new double[matrix.nums];
    matrix.rowIndex[0] = 1;
    matrix.colIndex[0] = 2;
    matrix.value[0] = 3.0;
    matrix.rowIndex[1] = 2;
    matrix.colIndex[1] = 1;
    matrix.value[1] = 4.0;
    matrix.rowIndex[2] = 3;
    matrix.colIndex[2] = 2;
    matrix.value[2] = 5.0;
    matrix.rowIndex[3] = 4;
    matrix.colIndex[3] = 4;
    matrix.value[3] = 6.0;
    matrix.rowIndex[4] = 4;
    matrix.colIndex[4] = 3;
    matrix.value[4] = 7.0;
    matrix.rowIndex[5] = 5;
    matrix.colIndex[5] = 1;
    matrix.value[5] = 8.0;
    SparseMatrix transposed = transpose(matrix);
    for (int i = 1; i <= matrix.rows; i++) {
        for (int j = 1; j <= matrix.cols; j++) {
            bool found = false;
            for (int k = 0; k < matrix.nums; k++) {
                if (matrix.rowIndex[k] == i && matrix.colIndex[k] == j) {
                    cout << matrix.value[k] << '\t';
                    found = true;
                    break;
                }
            }
            if (!found) {
                cout << "0\t";
            }
        }
        cout << endl;
    }
    cout << endl;
    for (int i = 1; i <= transposed.rows; i++) {
        for (int j = 1; j <= transposed.cols; j++) {
            bool found = false;
            for (int k = 0; k < transposed.nums; k++) {
                if (transposed.rowIndex[k] == i && transposed.colIndex[k] == j) {
                    cout << transposed.value[k] << '\t';
                    found = true;
                    break;
                }
            }
            if (!found) {
                cout << "0\t";
            }
        }
        cout << endl;
    }
    delete[] matrix.rowIndex;
    delete[] matrix.colIndex;
    delete[] matrix.value;
    delete[] transposed.rowIndex;
    delete[] transposed.colIndex;
    delete[] transposed.value;
    return 0;
}

输出结果如下：

0       0       0       0
0       0       3       0
0       4       0       5
0       7       6       0
8       0       0       0

0       0       0       0       8
0       0       4       7       0
0       3       0       6       0
0       0       5       0       0