icoding测试代码--矩阵加法

icoding的数据结构并没有一个测试代码，其都是直接编写一个函数的形式，因此很难知道自己的实际输出是什么。针对部分题目，我编写了一系列测试代码以供大家进行数据输出的测试。

bool add_matrix(const TSMatrix *pM, const TSMatrix *pN, TSMatrix *pQ){
    //TODO
}

请将您的函数代码复制到上述函数中，然后修改main函数的相关内容，完成测试样例的输入

矩阵加法内置了对输入的三元组数据的正确性判断，因此很冗长。

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>


typedef int ElemType;
#define MAXSIZE 100          //假设非零元个数的最大值为100
typedef struct {
    int i,j;									//非零元的行下标和列下标，i 和 j 从 1 开始计数，与数学中矩阵元素的编号一致
    ElemType e;						//非零元的值
}Triple;

typedef struct {
    Triple data[MAXSIZE];			// 非零元三元组表
    int    m, n, len;							// 矩阵的行数、列数和非零元个数
}TSMatrix;

bool add_matrix(const TSMatrix *pM, const TSMatrix *pN, TSMatrix *pQ){
    //TODO
}


void PrintfMatrix2(TSMatrix *M,char str) {
    int i, j, k = 1;
    Triple *t;

    printf(">>打印矩阵%c：\n", str);
    for (i = 1; i <= M->m; ++i) {
        for (j = 1; j <= M->n; ++j) {
            t = &M->data[k];
            printf("%4d", t->i == i && t->j == j ? (++k, t->e) : 0);
        }
        putchar('\n');
    }
    //putchar('\n');
}

//打印矩阵(相加后的矩阵)
void PrintfMatrix(TSMatrix *M,TSMatrix *N,TSMatrix *Q) {
    int i, j, k1 = 1,k2=1,k3=1;
    Triple *t;
    Triple *s;
    Triple *r;


    for (i = 0; i <= M->m; ++i) {
        //从0开始是为了显示MN；从第一行开始是为了显示矩阵
        if(i==0){
            //打印一半矩阵长度的空格
            printf("%*c%*c%*c\n",2+4*(M->n)/2,'M',3+2+4*(M->n)/2+4*(N->n)/2,'N',3+2+4*(M->n)/2+4*(N->n)/2,'Q');
            
        }else{
        for (j = 1; j <= M->n; ++j) {
            t = &M->data[k1-1];
            printf("%4d", t->i == i && t->j == j ? (++k1, t->e) : 0);
        }

        if(i==M->m/2+1){
            printf("    +");
        }else{
            printf("     ");
        }
        

        for (j = 1; j <= N->n; ++j) {
            s = &N->data[k2-1];
            printf("%4d", s->i == i && s->j == j ? (++k2, s->e) : 0);
        }

        if(i==M->m/2+1){
            printf("    =");
        }else{
            printf("     ");
        }

        for (j = 1; j <= Q->n; ++j) {
            r = &Q->data[k3-1];
            printf("%4d", r->i == i && r->j == j ? (++k3, r->e) : 0);
        }
        putchar('\n');


        }
    }
    return ;
}


int main(){
//--------您 可 以 修 改 以 下 代 码 ---------
    int m_rownum=3;//m的行数
    int m_colnum=3;//m的列数

    int m_row[]  ={1,2,3};
    int m_col[]  ={2,3,3};
    int m_value[]={1,2,4};
    //m的非零元三元组表
    //其中m_row,m_col,m_value的长度为分别表示一个非0元的行数、列数和值，其满足列相互对应
    //例如：
    // int m_row[]  ={1,2,2};
    // int m_col[]  ={2,2,3};
    // int m_value[]={1,2,4};
    //表示：在1行2列有值1，在2行2列有值2，在2行3列有值4

    //三元组表的排列应该满足一定规则，即：
    //三个数组的长度应该相等，且他们的长度应该大于等于1
    //且不应该有重复的行列。
    //m_row[0]表示第一个非0元的行数，m_row[1]表示第二个非0元的行数，以此类推
    //而且row必须满足单增，而在row相同的条件下，col也必须按照单增顺序排列
    //例如：
    // int m_row[]  ={3,1,2,2};
    // int m_col[]  ={3,3,3,2};
    // int m_value[]={9,5,2,4};
    //是错误的，因为
    //1. m_row[]  ={3,1,2,2}不满足单增
    //2. 在row都是2时 m_col[]  ={3,3,3,2}对应项目（最后两项）不满足单增
    //正确排序应该是：
    // int m_row[]  ={1,2,2,3};
    // int m_col[]  ={3,2,3,3};
    // int m_value[]={5,2,4,9};
    //别担心会在这里犯错，我们的程序会检测这个的。


    int n_rownum=3;// n的行数
    int n_colnum=3;// n的列数

    int n_row[]  ={1,1,2};
    int n_col[]  ={1,2,2};
    int n_value[]={1,8,4};
    //n的非零元三元组表
    //规则同上
//--------您 可 以 修 改 以 上 代 码 ---------


    printf("----icoding----\n");
    printf("矩阵加法\n");
    printf(">>初始化中...\n");
    printf("提示##当出现提示“程序自动终止”说明在main函数的三元组表初始错误，需要在main函数修改相关值\n\n");
    int m_row_len=sizeof(m_row)/sizeof(m_row[0]);
    int m_col_len=sizeof(m_col)/sizeof(m_col[0]);
    int n_row_len=sizeof(n_row)/sizeof(n_row[0]);
    int n_col_len=sizeof(n_col)/sizeof(n_col[0]);


    int m_len=sizeof(m_value)/sizeof(m_value[0]);
    int n_len=sizeof(n_value)/sizeof(n_value[0]);
    if(m_len<=0||n_len<=0){
        printf("三元组表的长度为非正数，请检查！\n程序自动终止\n");
        return 0;
    }
    if(m_row_len!=m_col_len||m_row_len!=m_len||n_row_len!=n_col_len||n_row_len!=n_len){
        printf("三元组表的长度不等，请检查！\n程序自动终止\n");
        return 0;
    }


    //检查数组是否超出界限
    for(int i=0;i<m_row_len;i++){
        if(m_row[i]<=0||m_row[i]>m_rownum){
            printf("三元组表的m_row[%d]超出界限(正确范围为[1,%d],含端点)，请检查！\n程序自动终止\n",i,m_rownum);
            return 0;
        }
    }
    for(int i=0;i<m_col_len;i++){
        if(m_col[i]<=0||m_col[i]>m_colnum){
            printf("三元组表的m_col[%d]超出界限(正确范围为[1,%d],含端点)，请检查！\n程序自动终止\n",i,m_colnum);
            return 0;
        }
    }
    for(int i=0;i<n_row_len;i++){
        if(n_row[i]<=0||n_row[i]>n_rownum){
            printf("三元组表的n_row[%d]超出界限(正确范围为[1,%d],含端点)，请检查！\n程序自动终止\n",i,n_rownum);
            return 0;
        }
    }
    for(int i=0;i<n_col_len;i++){
        if(n_col[i]<=0||n_col[i]>n_colnum){
            printf("三元组表的n_col[%d]超出界限(正确范围为[1,%d],含端点)，请检查！\n程序自动终止\n",i,n_colnum);
            return 0;
        }
    }
   
   


    //检查输入的合法性
    for(int a=0;a<m_len;a++){
        for(int b=a;b<m_len;b++){
        if(m_row[a]>m_row[b]){
            printf("输入数据不满足要求,m_row[]需要为不减数列\n程序自动终止，请修改后重新运行\n");
            return 0;
        }
        if(m_row[a]==m_row[b]&&m_col[a]>m_col[b]){
            printf("输入数据不满足要求,m_col[]在m_row相同时需要为单增数列\n程序自动终止，请修改后重新运行\n");
            return 0;
        }
        if(m_row[a]==m_row[b]&&m_col[a]==m_col[b]&&a!=b){
            printf("对于M矩阵，输入数据行列有相同\n程序自动终止，请修改后重新运行\n");
            return 0;
        }
        }
        }
    for(int a=0;a<n_len;a++){
        for(int b=a;b<n_len;b++){
        if(n_row[a]>n_row[b]){
            printf("输入数据不满足要求,n_row[]需要为不减数列\n程序自动终止，请修改后重新运行\n");
            return 0;
        }
        if(n_row[a]==n_row[b]&&n_col[a]>n_col[b]){
            printf("输入数据不满足要求,n_col[]在n_row相同时需要为单增数列\n程序自动终止，请修改后重新运行\n");
            return 0;
        }
        if(n_row[a]==n_row[b]&&n_col[a]==n_col[b]&&a!=b){
            printf("对于N矩阵，输入数据行列有相同\n程序自动终止，请修改后重新运行\n");
            return 0;
        }
        }
        }
    
    
    //初始化广义数组
    TSMatrix M,N,Q;
    M.m=m_rownum;
    M.n=m_colnum;
    M.len=m_len;
    N.m=n_rownum;
    N.n=n_colnum;
    N.len=n_len;
    Q.m=0;
    Q.n=0;
    Q.len=0;

    //初始化三元组
    for(int i=0;i<M.len;i++){
        M.data[i].i=m_row[i];
        M.data[i].j=m_col[i];
        M.data[i].e=m_value[i];
    }
    for(int i=0;i<N.len;i++){
        N.data[i].i=n_row[i];
        N.data[i].j=n_col[i];
        N.data[i].e=n_value[i];
    }
    printf(">>初始化成功\n>>矩阵相加中...\n");
    //打印矩阵
    bool flag=false;
    flag=add_matrix(&M,&N,&Q);
    
    if(flag==1){
    printf("函数返回true\nM矩阵长宽为%d*%d  |  N矩阵的长宽为%d*%d  |  Q矩阵的长宽为%d*%d\n程序按行打印,打印时以M的行数为标准\n",M.m,M.n,N.m,N.n,Q.m,Q.n);
    PrintfMatrix(&M,&N,&Q);
    if(Q.m==0||Q.n==0){
        printf("\n##您似乎没有对Q矩阵的长宽赋值，因而Q显示空白\n");
    }
    if(Q.len==0){
        printf("##请确认Q矩阵的len赋值是否完成(若两个矩阵相加确实全为0请忽略)\n");
    }

    }
    else{
        printf("函数返回false,矩阵不能相加\n这两个矩阵分别是\n");

        PrintfMatrix2(&M,'M');
        printf("M矩阵的长宽为%d*%d\n\n",M.m,M.n);
        PrintfMatrix2(&N,'N');
        printf("N矩阵的长宽为%d*%d\n\n",N.m,N.n);
    }
    printf("\n\n本程序仅输出结果，不对结果进行正误判断\n---测试完成---\n");
    
    return 0;
}

若不对main函数内置的测试样例进行修改，那么正确的输出结果为