稀疏矩阵运算器

对稀疏矩阵进行加减乘简单运算，矩阵元素初定为整型，需要的话可以更改为实型，矩阵大小初定为20×20，可更改相应代码进行扩大。

仓促写的。。= =，没有优化可能比较臃肿。。，输入的时候得按照行列顺序输入，懒得编对输入进行

处理的函数了。。。= =||

使用方法见图例：

加法：

减法：

乘法：

//  20*20以内的矩阵运算
 

#include <stdio.h>
#include <conio.h>

 #define MAXSIZE 500
 #define MAXRC 30    //更改为更大的数以支持更大的矩阵运算

typedef struct
{
    int i, j;
    int e;
}Triple;

typedef struct
{
    Triple data[MAXSIZE + 1];
    int mu, nu, tu;
}TSMatrix;


 int Abstract(TSMatrix A, int i, int j)        //提取A矩阵中第i行第j列的元素
 {
    int k;
    for (k = 1; k < A.tu + 1; k++)
    {
        if (A.data[k].i == i && A.data[k].j == j)
            return A.data[k].e;
    }
    return 0;
}

 void Prin(TSMatrix T)                 //矩阵的输出函数
 {
    int Array[50][50] = {0};
    int i, j;
    for (i = 1; i < T.tu + 1; i++)
    {
        Array[T.data[i].i][T.data[i].j] = T.data[i].e;
    }
    for (i = 1; i < T.mu + 1; i++)
    {
        for (j = 1; j < T.nu + 1; j++)
        {
            printf("%4d ", Array[i][j]);
            if (j == T.nu)
                printf("\n");
        }
    }
}

TSMatrix Add(TSMatrix A, TSMatrix B)                //矩阵相加函数
 {
    int i, j, k, temp;
    i = j = k = 1;
    TSMatrix C;
    C.mu = A.mu;
    C.nu = A.nu;
    
    //方法一：
 

    /*              只对非零元进行运算，免去了一个一个提取矩阵元素的过程
    while (i < A.tu + 1 || j < B.tu + 1)                
    {
        if (i > A.tu && j <= B.tu)                //A中的非零元素处理完毕，B没有时，将B剩余非零元直接复制入C
        {
            C.data[k] = B.data[j];
            j++;
            k++;
        }
        else
        {
            if (i <= A.tu && j > B.tu)              //B中的非零元素处理完毕，A没有时，将A剩余非零元直接复制入C
            {
                C.data[k] = A.data[j];
                i++;
                k++;
            }
            else
            {

                if (A.data[i].i < B.data[j].i)             //A中非零元素行优先
                {
                    C.data[k] = A.data[j];
                    i++;
                    k++;
                }
                else
                {
                    if (A.data[i].i > B.data[j].i)         //B中非零元素行优先
                    {
                        C.data[k] = B.data[j];
                        j++;
                        k++;
                    }
                    else
                    {
                        if (A.data[i].j < B.data[j].j)        //A中非零元素列优先
                        {
                            C.data[k] = A.data[i];
                            i++;
                            k++;
                        }
                        else
                        {
                            if (A.data[i].i > B.data[j].i)         //B中非零元素列优先
                            {
                                C.data[k] = B.data[j];
                                j++;
                                k++;
                            }
                            else                              //A，B矩阵非零元素处于同一位置时相加，并且和为0时作出相应处理
                            {
                                C.data[k].e = A.data[i].e + B.data[j].e;
                                C.data[k].i = A.data[i].i;
                                C.data[k].j = A.data[i].j;
                                if (C.data[k].e == 0)
                                    k--;
                                i++;
                                j++;
                                k++;
                            }
                        }
                    }

                }
            }
        }
    }
    C.tu = k - 1;
    return C;
    */

    //方法二：
 
    for (i = 1; i < C.mu + 1; i++)
    {
        for (j = 1; j < C.nu + 1; j++)
        {
            temp = Abstract(A, i, j) + Abstract(B, i, j);     //依次对每个元素进行运算
             if ( temp != 0)
            {
                C.data[k].e = temp;
                C.data[k].i = i;
                C.data[k].j = j;
                k++;
            }
        }
    }
    C.tu = k - 1;
    return C;
}

TSMatrix Substract(TSMatrix A, TSMatrix B)       //减法函数，先将B矩阵元素取相反数，再与A相加即可
 {
    TSMatrix C;
    int i;
    for (i = 1; i < B.tu + 1; i++)
    {
        B.data[i].e = -1 * B.data[i].e;
    }
    C = Add(A, B);
    return C;
}





int RowMultiCol(TSMatrix A, TSMatrix B, int i, int j)       //行与列对应相乘
{
    int m, sum;
    sum = 0;
    for (m = 1; m < A.nu + 1; m++)
    {
        sum = sum + Abstract(A, i, m) * Abstract(B, m, j);

    }
    return sum;
}
TSMatrix Multiply(TSMatrix A, TSMatrix B)          //乘法的函数
{
    int i, j, k, t, temp = 0;
    i = j = k = 1;
    TSMatrix C;
    C.mu = A.mu;
    C.nu = B.nu;
    for (t = 1; t < MAXSIZE + 1; t++)
    {
        C.data[t].e = 0;
    }
    for (i = 1; i < C.mu + 1; i++)
    {
        for (j = 1; j < C.nu + 1; j++)
        {
            temp = RowMultiCol(A, B, i, j);
            if ( temp != 0)
            {
                C.data[k].e = temp;
                C.data[k].i = i;
                C.data[k].j = j;
                k++;
            }
        }
    }
    C.tu = k - 1;
    return C;


}

void main()
{
    char c;
    int i;
    TSMatrix A, B, C;
    printf("Input the row(<=20),colmun(<=20) and t of Matrix A:\n");
    scanf("%d %d %d", &A.mu, &A.nu, &A.tu);
    printf("Input the element of Matrix A in order(first row then column):\n");
    for (i = 1; i < A.tu + 1; i++)
    {
        scanf(" (%d,%d,%d)", &A.data[i].i, &A.data[i].j, &A.data[i].e);
    }
    printf("Input the row(<=20),colmun(<=20) and t of Matrix B:\n");
    scanf("%d %d %d", &B.mu, &B.nu, &B.tu);
    printf("Input the element of Matrix B in order(first row then column):\n");
    for (i = 1; i < B.tu + 1; i++)
    {
        scanf(" (%d,%d,%d)", &B.data[i].i, &B.data[i].j, &B.data[i].e);
    }
    printf("Matrix A:\n");
    Prin(A);
    printf("\nMatrix B:\n");
    Prin(B);
    printf("Choose a operation:\n1) Add;\n2) Substract;\n3) Multiply\n");
    scanf(" %c", &c);
    if (c == '1')                           //对各种输入情况进行判断并处理矩阵
    {    
        if (A.mu == B.mu && A.nu == B.nu)
        {
            C = Add(A, B);
            printf("\nA + B:\n");
            Prin(C);
        }
        else
            printf("Error!\n");
    }
    else
    {
        if (c == '2')
        {
            if (A.mu == B.mu && A.nu == B.nu)
            {
                C = Substract(A, B);
                printf("\nA - B:\n");
                Prin(C);
            }
            else
                printf("Error!\n");
        }
        else
        {

            if (c == '3')
            {
                if (A.nu == B.mu)
                {
                    C = Multiply(A, B);
                    printf("\nA * B:\n");
                    Prin(C);
                }
                else
                    printf("Error!\n");
            }
            else
            {
                printf("Error!\n");
            }
        }
    }
}