输入两个稀疏矩阵，求相加，减，乘，及任一矩阵的转置结果，C++

以下是 C++ 的代码实现：

#include <iostream>
#include <vector>

using namespace std;

// 定义稀疏矩阵结构体
struct SparseMatrix {
    int m, n; // 矩阵的行数和列数
    vector<vector<int>> data; // 存储非零元素的值及其位置
};

// 矩阵加法
SparseMatrix add(SparseMatrix a, SparseMatrix b) {
    SparseMatrix c;
    if (a.m != b.m || a.n != b.n) { // 当两个矩阵的行列数不相同时，无法进行加法运算
        cout << "Error: The two matrices can't be added." << endl;
        return c;
    }
    c.m = a.m;
    c.n = a.n;
    int i = 0, j = 0;
    while (i < a.data.size() && j < b.data.size()) { // 合并两个矩阵的非零元素
        if (a.data[i][0] < b.data[j][0] || (a.data[i][0] == b.data[j][0] && a.data[i][1] < b.data[j][1])) {
            c.data.push_back(a.data[i]);
            i++;
        } else if (a.data[i][0] > b.data[j][0] || (a.data[i][0] == b.data[j][0] && a.data[i][1] > b.data[j][1])) {
            c.data.push_back(b.data[j]);
            j++;
        } else {
            if (a.data[i][2] + b.data[j][2] != 0) {
                c.data.push_back({a.data[i][0], a.data[i][1], a.data[i][2] + b.data[j][2]});
            }
            i++;
            j++;
        }
    }
    while (i < a.data.size()) {
        c.data.push_back(a.data[i]);
        i++;
    }
    while (j < b.data.size()) {
        c.data.push_back(b.data[j]);
        j++;
    }
    return c;
}

// 矩阵减法
SparseMatrix sub(SparseMatrix a, SparseMatrix b) {
    SparseMatrix c;
    if (a.m != b.m || a.n != b.n) { // 当两个矩阵的行列数不相同时，无法进行减法运算
        cout << "Error: The two matrices can't be subtracted." << endl;
        return c;
    }
    c.m = a.m;
    c.n = a.n;
    int i = 0, j = 0;
    while (i < a.data.size() && j < b.data.size()) { // 合并两个矩阵的非零元素
        if (a.data[i][0] < b.data[j][0] || (a.data[i][0] == b.data[j][0] && a.data[i][1] < b.data[j][1])) {
            c.data.push_back(a.data[i]);
            i++;
        } else if (a.data[i][0] > b.data[j][0] || (a.data[i][0] == b.data[j][0] && a.data[i][1] > b.data[j][1])) {
            c.data.push_back({b.data[j][0], b.data[j][1], -b.data[j][2]});
            j++;
        } else {
            if (a.data[i][2] - b.data[j][2] != 0) {
                c.data.push_back({a.data[i][0], a.data[i][1], a.data[i][2] - b.data[j][2]});
            }
            i++;
            j++;
        }
    }
    while (i < a.data.size()) {
        c.data.push_back(a.data[i]);
        i++;
    }
    while (j < b.data.size()) {
        c.data.push_back({b.data[j][0], b.data[j][1], -b.data[j][2]});
        j++;
    }
    return c;
}

// 矩阵乘法
SparseMatrix mul(SparseMatrix a, SparseMatrix b) {
    SparseMatrix c;
    if (a.n != b.m) { // 当第一个矩阵的列数不等于第二个矩阵的行数时，无法进行乘法运算
        cout << "Error: The two matrices can't be multiplied." << endl;
        return c;
    }
    c.m = a.m;
    c.n = b.n;
    vector<vector<int>> bt(b.n); // 存储 b 矩阵的转置矩阵
    for (int i = 0; i < b.data.size(); i++) {
        bt[b.data[i][1]].push_back(i);
    }
    for (int i = 0; i < a.m; i++) { // 计算 c 矩阵的非零元素
        vector<int> c_row(c.n);
        for (int j = 0; j < a.data.size(); j++) {
            int k = a.data[j][1];
            for (int l = 0; l < bt[k].size(); l++) {
                int p = bt[k][l];
                if (b.data[p][0] == k) {
                    c_row[b.data[p][1]] += a.data[j][2] * b.data[p][2];
                }
            }
        }
        for (int j = 0; j < c_row.size(); j++) {
            if (c_row[j] != 0) {
                c.data.push_back({i, j, c_row[j]});
            }
        }
    }
    return c;
}

// 矩阵转置
SparseMatrix transpose(SparseMatrix a) {
    SparseMatrix b;
    b.m = a.n;
    b.n = a.m;
    b.data.resize(a.data.size());
    vector<int> count(a.n); // 存储每一列非零元素的个数
    for (int i = 0; i < a.data.size(); i++) {
        count[a.data[i][1]]++;
    }
    vector<int> index(a.n); // 存储每一列第一个非零元素在 b.data 中的位置
    for (int i = 1; i < a.n; i++) {
        index[i] = index[i - 1] + count[i - 1];
    }
    for (int i = 0; i < a.data.size(); i++) {
        int j = a.data[i][1];
        b.data[index[j]] = {j, a.data[i][0], a.data[i][2]};
        index[j]++;
    }
    return b;
}

int main() {
    SparseMatrix a = {3, 4, {{0, 1, 1}, {1, 2, 2}, {2, 0, 3}, {2, 3, 4}}};
    SparseMatrix b = {4, 3, {{0, 1, 1}, {1, 0, 2}, {2, 1, 3}, {2, 2, 4}}};
    SparseMatrix c = add(a, b);
    SparseMatrix d = sub(a, b);
    SparseMatrix e = mul(a, b);
    SparseMatrix f = transpose(a);
    for (int i = 0; i < c.data.size(); i++) {
        cout << c.data[i][0] << " " << c.data[i][1] << " " << c.data[i][2] << endl;
    }
    cout << endl;
    for (int i = 0; i < d.data.size(); i++) {
        cout << d.data[i][0] << " " << d.data[i][1] << " " << d.data[i][2] << endl;
    }
    cout << endl;
    for (int i = 0; i < e.data.size(); i++) {
        cout << e.data[i][0] << " " << e.data[i][1] << " " << e.data[i][2] << endl;
    }
    cout << endl;
    for (int i = 0; i < f.data.size(); i++) {
        cout << f.data[i][0] << " " << f.data[i][1] << " " << f.data[i][2] << endl;
    }
    return 0;
}

其中，稀疏矩阵的存储方式为三元组 (i, j, value)，表示矩阵中第 i 行第 j 列的元素值为 value。在加法和减法运算中，需要按照行优先的顺序合并两个矩阵的非零元素；在乘法运算中，需要先将第二个矩阵转置，然后按照稀疏矩阵乘法的定义计算。在转置运算中，需要按照列优先的顺序将矩阵中的非零元素存储到转置矩阵中。