西北工业大学数据结构noj2-2

question

完整代码

// 稀疏矩阵加法
#include <iostream>
#include <vector>
#include <iomanip>

#define MAX_SIZE 1000
struct Trida
{
    int row, col;
    int val;
};

struct SparseMatrix
{
    Trida data[MAX_SIZE];
    int m, n, len; // m为行数，n为列数
};

void buildSparseMatrix(SparseMatrix &Mat);

void insertSparseMatrix(SparseMatrix &Mat, int row, int col, int val, int pos);

void AddSparseMatrix(SparseMatrix A, SparseMatrix B, SparseMatrix &C);

void showSparseMatrix(SparseMatrix Mat);

void SparsetoNormal(SparseMatrix Mat);

int main()
{
    SparseMatrix A, B, C;
    int m, n, t1, t2;
    std::cin >> m >> n >> t1 >> t2;
    A.m = m, A.n = n, A.len = t1;
    B.m = m, B.n = n, B.len = t2;
    C.m = m, C.n = n, C.len = 0;

    std::cout << "--------------------------------------" << std::endl;
    buildSparseMatrix(A);
    // SparsetoNormal(A);

    std::cout << "--------------------------------------" << std::endl;
    buildSparseMatrix(B);
    // SparsetoNormal(B);
    std::cout << "--------------------------------------" << std::endl;

    for (auto i = 0; i < t1 + t2; ++i)
    {
        C.data[i].row = 0;
        C.data[i].col = 0;
        C.data[i].val = 0;
    }

    AddSparseMatrix(A, B, C);
    // SparsetoNormal(C);

    std::cout << "C------------------------------" << C.len << std::endl;
    showSparseMatrix(C);

    std::cout << "--------------------------------------" << std::endl;
    std::cout << "A:" << std::endl;
    SparsetoNormal(A);

    std::cout << "--------------------------------------" << std::endl;
    std::cout << "B:" << std::endl;
    SparsetoNormal(B);

    std::cout << "--------------------------------------" << std::endl;
    std::cout << "C:" << std::endl;
    SparsetoNormal(C);

    system("pause");
    return 0;
}

void buildSparseMatrix(SparseMatrix &Mat)
{
    int row, col, val;
    for (auto i = 0; i < Mat.len; ++i)
    {
        std::cin >> row >> col >> val;
        Mat.data[i].row = row;
        Mat.data[i].col = col;
        Mat.data[i].val = val;
    }
}

void insertSparseMatrix(SparseMatrix &Mat, int row, int col, int val, int pos)
{
    Mat.data[pos].row = row;
    Mat.data[pos].col = col;
    Mat.data[pos].val = val;
}

void AddSparseMatrix(SparseMatrix A, SparseMatrix B, SparseMatrix &C)
{
    int posA = 0, posB = 0, posC = 0;
    while (posA < A.len && posB < B.len)
    {
        if (A.data[posA].row < B.data[posB].row || (A.data[posA].row == B.data[posB].row && A.data[posA].col < B.data[posB].col))
        {
            insertSparseMatrix(C, A.data[posA].row, A.data[posA].col, A.data[posA].val, posC);
            ++posA, ++posC;
        }
        else if (A.data[posA].row > B.data[posB].row || (A.data[posA].row == B.data[posB].row && A.data[posA].col > B.data[posB].col))
        {
            insertSparseMatrix(C, B.data[posB].row, B.data[posB].col, B.data[posB].val, posC);
            ++posB, ++posC;
        }
        // else if (A.data[posA].col < B.data[posB].col)
        // {
        //     insertSparseMatrix(C, A.data[posA].row, A.data[posA].col, A.data[posA].val, posC);
        //     ++posA, ++posC;
        // }
        // else if (A.data[posA].col > B.data[posB].col)
        // {
        //     insertSparseMatrix(C, B.data[posB].row, B.data[posB].col, B.data[posB].val, posC);
        //     ++posB, ++posC;
        // }
        else
        {
            int sum = A.data[posA].val + B.data[posB].val;
            if (sum != 0)
            {
                insertSparseMatrix(C, A.data[posA].row, A.data[posA].col, sum, posC);
                ++posC;
            }
            ++posA, ++posB;
        }
    }
    // 矩阵A有剩余
    while (posA < A.len)
    {
        insertSparseMatrix(C, A.data[posA].row, A.data[posA].col, A.data[posA].val, posC);
        ++posA, ++posC;
    }
    // 矩阵B有剩余
    while (posB < B.len)
    {
        insertSparseMatrix(C, B.data[posB].row, B.data[posB].col, B.data[posB].val, posC);
        ++posB, ++posC;
    }

    C.len = posC;
}

void showSparseMatrix(SparseMatrix Mat)
{
    for (auto i = 0; i < Mat.len; ++i)
    {
        std::cout << Mat.data[i].row << " " << Mat.data[i].col << " " << Mat.data[i].val << std::endl;
    }
}

void SparsetoNormal(SparseMatrix Mat)
{
    std::vector<std::vector<int>> temp(Mat.m, std::vector<int>(Mat.n, 0));
    for (auto i = 0; i < Mat.len; ++i)
    {
        temp[Mat.data[i].row][Mat.data[i].col] = Mat.data[i].val;
    }

    for (auto i = 0; i < Mat.m; ++i)
    {
        for (auto j = 0; j < Mat.n; ++j)
        {
            std::cout << std::setw(3) << temp[i][j] << ' ';
        }
        std::cout << std::endl;
    }
}

// 3 4 3 2
// 1 1 1
// 1 3 1
// 2 2 2
// 1 2 1
// 2 2 3