已知稀疏矩阵A和B，编程代码实现基于三元组顺序表实现A+B的运算

以下是 C++ 代码实现稀疏矩阵 A+B 的运算，其中使用三元组顺序表存储稀疏矩阵：

#include <iostream>
#include <vector>

struct Triplet {
    int row;
    int col;
    int value;
};

class SparseMatrix {
private:
    int m_rows;
    int m_cols;
    std::vector<Triplet> m_data;

public:
    SparseMatrix(int rows, int cols, const std::vector<Triplet>& data) :
        m_rows(rows), m_cols(cols), m_data(data) {}

    SparseMatrix operator+(const SparseMatrix& other) const {
        if (m_rows != other.m_rows || m_cols != other.m_cols) {
            throw std::invalid_argument("SparseMatrix dimensions mismatch");
        }

        std::vector<Triplet> result_data;

        int i = 0;
        int j = 0;

        while (i < m_data.size() && j < other.m_data.size()) {
            const Triplet& a = m_data[i];
            const Triplet& b = other.m_data[j];

            if (a.row < b.row || (a.row == b.row && a.col < b.col)) {
                result_data.push_back(a);
                ++i;
            } else if (a.row == b.row && a.col == b.col) {
                result_data.push_back({a.row, a.col, a.value + b.value});
                ++i;
                ++j;
            } else {
                result_data.push_back(b);
                ++j;
            }
        }

        while (i < m_data.size()) {
            result_data.push_back(m_data[i]);
            ++i;
        }

        while (j < other.m_data.size()) {
            result_data.push_back(other.m_data[j]);
            ++j;
        }

        return SparseMatrix(m_rows, m_cols, result_data);
    }

    void print() const {
        std::cout << "SparseMatrix(" << m_rows << ", " << m_cols << "):" << std::endl;

        for (const auto& triplet : m_data) {
            std::cout << triplet.row << ", " << triplet.col << ", " << triplet.value << std::endl;
        }
    }
};

int main() {
    std::vector<Triplet> data_a = {{0, 0, 1}, {0, 1, 2}, {1, 0, 3}};
    std::vector<Triplet> data_b = {{0, 1, 4}, {1, 0, 5}, {1, 1, 6}};
    SparseMatrix A(2, 2, data_a);
    SparseMatrix B(2, 2, data_b);
    SparseMatrix C = A + B;
    C.print();
    return 0;
}

在这个例子中，我们首先定义了一个 `Triplet` 结构体来表示三元组 (行、列、值)，然后定义了 `SparseMatrix` 类来表示稀疏矩阵。在 `SparseMatrix` 类中，我们使用一个 `std::vector` 来存储稀疏矩阵中的三元组。在实现 `operator+` 函数时，我们按照行优先顺序遍历两个稀疏矩阵的三元组，并进行相应的加法运算，最后返回一个新的稀疏矩阵对象。在 `print` 函数中，我们简单地打印出稀疏矩阵中的三元组。

在 `main` 函数中，我们定义了两个稀疏矩阵 A 和 B，并将它们相加得到稀疏矩阵 C，最后输出稀疏矩阵 C 中的三元组。