问题分析

本实验的主要目标是开发一个稀疏矩阵乘法算法，该算法能够将两个稀疏矩阵 A 和 B 相乘，然后输出结果矩阵 C。在这个算法中，稀疏矩阵使用三元组表示，并且用户可以多次输入不同的矩阵数据，计算它们的乘积。

算法设计

稀疏矩阵乘法算法的设计如下：

• 使用 struct 结构体来表示矩阵，其中包括矩阵的行数、列数、稀疏矩阵元素的个数，以及一个数组用于存储节点的信息。
• 输入函数 input 用于获取矩阵的三元组表示，检查输入的合法性，然后存储在内存中的结构体中。
• 输出函数 output 将稀疏矩阵以标准矩阵的形式打印出来，便于用户查看。
• 矩阵乘法函数 multiplier 接受两个输入矩阵 A 和 B，计算它们的乘积，并将结果存储在矩阵 C 中。

  数据结构设计

• matrix 结构体包含了矩阵的行数 m、列数 n、稀疏矩阵元素的个数 L，以及 Ma 数组用于存储节点信息。
• node 结构体表示稀疏矩阵的每个非零元素，包括行索引 i、列索引 j 以及元素的值 data。

  调试过程

• 代码中有一些错误处理机制，例如检查输入是否合法，检查内存分配是否成功，以及检查矩阵相乘是否合法。
• 在输入稀疏矩阵数据时，用户会得到错误消息并要求重新输入，以确保输入的数据符合矩阵的大小。
• 稀疏矩阵乘法算法中，会检查矩阵的列和行是否匹配，以确保它们可以相乘。

  输出结果

  
  Matlab验证结果：
  
  

用户可以输入两个矩阵 A 和 B，然后程序会计算它们的乘积并输出结果矩阵 C。用户可以选择继续进行稀疏矩阵乘法计算，也可以选择退出程序。程序会一直运行，直到用户选择退出。

总结

总体而言，该实验成功实现了稀疏矩阵的乘法操作，提供了友好的用户界面和错误处理机制，以确保输入的矩阵数据是有效的。然后，它正确计算了两个稀疏矩阵的乘积并将结果以标准矩阵的形式输出。

源代码

#include<bits/stdc++.h>
using namespace std;
#define MAX 1000

struct node{
    int i;
    int j;
    int data;
};
struct matrix{
    int m;
    int n;
    int L;
    node* Ma[MAX];
};

int input(matrix* A){
    int m,n,data;
    for(int i=0;i<A->L;i++){
        cin>>m>>n>>data;
        if(m<0||m>=A->m||n<0||n>=A->n){
            cout<<"输入错误,行/列超出矩阵大小!"<<endl;
            return 1;
        }
        A->Ma[i]=(node*)malloc(sizeof(node));
        if(!A->Ma[i]){
            cout<<"申请空间失败!"<<endl;
            return 2;
        }else{
            A->Ma[i]->i=m;
            A->Ma[i]->j=n;
            A->Ma[i]->data=data;
        }
    }
    return 0;
}

void output(matrix* A,string name){
    cout<<"矩阵"<<name<<"为:"<<endl;
    int nums[A->m][A->n];

    memset(nums,0,sizeof(nums));
    for(int i=0;i<A->L;i++){
        nums[A->Ma[i]->i][A->Ma[i]->j]=A->Ma[i]->data;
    }
    for(int i=0;i<A->m;i++){
        for(int j=0;j<A->n;j++){
            cout<<nums[i][j]<<'\t';
        }
        cout<<endl;
    }
}

void multiplier(matrix* A,matrix* B,matrix* C){
    C->m=A->m;
    C->n=B->n;
    C->L=0;
    int x,y,z;
    bool sert=false;
    for(int i=0;i<A->L;i++){
        for(int j=0;j<B->L;j++){
            if(A->Ma[i]->j==B->Ma[j]->i){//A的列号==B的行号
                x=A->Ma[i]->i;
                y=B->Ma[j]->j;
                z=A->Ma[i]->data*B->Ma[j]->data;
                sert=false;
                for(int k=0;k<C->L;k++){
                    if(x==C->Ma[k]->i&&y==C->Ma[k]->j){
                        C->Ma[k]->data+=z;
                        sert=true;
                        break;
                    }
                }
                if(!sert){
                    C->L++;
                    C->Ma[C->L-1]=(node*)malloc(sizeof(node));
                    C->Ma[C->L-1]->i=x;
                    C->Ma[C->L-1]->j=y;
                    C->Ma[C->L-1]->data=z;
                }
            }
        }
    }
}

int main(){
start:
    matrix* A=(matrix*)malloc(sizeof(matrix));
    matrix* B=(matrix*)malloc(sizeof(matrix));
    matrix* C=(matrix*)malloc(sizeof(matrix));
    cout<<"请输入A矩阵三元组长度,矩阵行数,矩阵列数:"<<endl;
    cin>>A->L>>A->m>>A->n;
    cout<<"请输入A矩阵:"<<endl;
    if(input(A)){
        cout<<"出现错误,请重新输入!"<<endl;
        goto start;
    }
    output(A,"A");
    cout<<"请输入B矩阵三元组长度,矩阵行数,矩阵列数:"<<endl;
    cin>>B->L>>B->m>>B->n;
    cout<<"请输入B矩阵:"<<endl;
    if(input(B)){
        cout<<"出现错误,请重新输入!"<<endl;
        goto start;
    }
    output(B,"B");
    multiplier(A,B,C);
    output(C,"C");

    cout<<"是否继续进行稀疏矩阵乘法计算(y/n):";
    char choice;
choise:
    cin>>choice;
    if(choice=='y'||choice=='Y'){
        goto start;
    }else if(choice=='n'||choice=='N'){
        return 0;
    }else{
        cout<<"输入错误,请重新输入:";
        goto choise;
    }
    return 0;
}