目的：
        程式設計實現稀疏矩陣的四則運算。
實現：
1. 稀疏矩陣的儲存結構採用行邏輯表示的三元組
2.

#define MAXSIZE  12500
#define MAXRC 12500
typedef struct {
    int i, j;
    int e;
}Triple;
typedef struct {
    Triple data[MAXSIZE + 1];
    int rpos[MAXRC + 1];
    int mu, nu, tu;
}RLSMatrix;

        先通過建立mu nu tu的值再根據這些值採用迴圈輸入得到data，之後再通過掃描確定rpos的值則可以完成建立。
        通過三元組的形式將非零元對應的行列以及數值儲存下來，再由稀疏矩陣結構存下矩陣的行數列數以及非零元個數，即可囊括稀疏矩陣的所有資訊。這樣就可以以三元組的形式把矩陣非零元素儲存下來，節省了儲存量的同時便於矩陣運算。

1. 矩陣的加法
          根據矩陣的相關知識，兩個矩陣相加要求兩個矩陣的行數，列數要相等。故需要設定判斷是否滿足矩陣相加的條件。若滿足條件，則進行加法運算。根據矩陣加法法則，得到的新矩陣擁有與原來兩矩陣相同的行數和列數，其元素數值則為兩矩陣對應位置的元素值之和。

2. 矩陣的減法
          和加法相同地根據三種情況採用三個迴圈處理對應的資料，只不過兩個都有的情況結果要變為兩者之差，N有M沒有的情況要改為N元素的相反數，其餘相同。則可以得到減法的演算法。

3. 矩陣的乘法
           根據矩陣乘法的理論，在滿足M.nu==N.mu的情況下，新矩陣Q（i，j）的值即滿足M（i，k）與N（k，j）的所有元素乘積之和。對於稀疏矩陣不需要對滿足條件的每個元素都進行乘積，因為兩者中若有一個為零則其乘積為零。所以只要在所有非零元中找到滿足條件的配對進行相乘，在將乘積進行累加即可得到該位置的元素值。結合rpos可以高效地進行迴圈查詢。
   程式程式碼：
   Matrix.h檔案

#include<stdio.h>
#define MAXSIZE  12500
#define MAXRC 12500
#define ERROR 0
#define OK 1
typedef struct {
    int i, j;
    int e;
}Triple;
typedef struct {
    Triple data[MAXSIZE + 1];
    int rpos[MAXRC + 1];
    int mu, nu, tu;
}RLSMatrix;
void CreateMatrix(RLSMatrix *M);
void Initrpos(RLSMatrix *M);
void
 
 Printrpos(RLSMatrix M);
int Add(RLSMatrix M, RLSMatrix N, RLSMatrix  *sum);
int Minus(RLSMatrix M, RLSMatrix N, RLSMatrix *minus);
int Multi(RLSMatrix M, RLSMatrix N, RLSMatrix *multi);
void PrintMatrix(RLSMatrix M);

Matrix.c檔案

#include<stdio.h>
#include"Matrix.h"
void CreateMatrix(RLSMatrix *M) {
    printf("請輸入矩陣的行數，列數，和非零元個數\n");
    scanf("%d%d%d", &M->mu, &M->nu, &M->tu);
    if (M->tu > (M->mu)*(M->nu)) { printf("該矩陣不存在！請重新輸入！\n"); CreateMatrix(&M); }
    int s;
    for (s = 1; s <= M->tu; s++) {
        printf("請輸入第%d非零元所在的行，列，及其數值\n", s);
        scanf("%d%d%d", &M->data[s].i, &M->data[s].j, &M->data[s].e);
        if (M->data[s].i < 0) { printf("行數須為正數！\n"); s -= 1; continue; }
        if(M->data[s].j < 0) { printf("列數須為正數！\n"); s -= 1; continue; }
        if(M->data[s].e==0){ printf("非零元不能為零！\n"); s -= 1; continue; }
    }
}
void Initrpos(RLSMatrix *M) {
    int i, j, tag, s;
    for (i = M->mu; i >= 1; i--) {
        tag = 0;
        for (j = 1; j <= M->nu; j++) {
            for (s = 1; s <= M->tu; s++) {
                if (M->data[s].i == i&&M->data[s].j == j) {
                    M->rpos[i] = s; tag = 1; break;
                }
            }
            if (tag == 1)break;
        }
        if (i == M->mu&&tag == 0)M->rpos[i] = M->tu + 1;
        if (i != M->mu&&tag == 0)M->rpos[i] = M->rpos[i + 1];
    }
}
void Printrpos(RLSMatrix M) {
    int i;
    printf("rpos\n");
    for (i = 1; i <= M.mu; i++) {
        printf("第%d行：%d\n", i, M.rpos[i]);
    }
}

int Add(RLSMatrix M, RLSMatrix N, RLSMatrix *sum) {
    int m, n, c = 1;
    if (M.mu != N.mu || M.nu != N.nu) { printf("無法相加！\n"); return ERROR; }
    sum->mu = M.mu;
    sum->nu = M.nu;
    for (m = 1; m <= M.tu; m++) {
        for (n = 1; n <= N.tu; n++) {
            if (N.data[n].i == M.data[m].i&&N.data[n].j == M.data[m].j) {
                sum->data[c].i = N.data[n].i;
                sum->data[c].j = N.data[n].j;
                sum->data[c].e = M.data[m].e + N.data[n].e;
                c++;
            }

        }       
    }
    for (m = 1; m <= M.tu; m++) {
        for (n = 1; n <= N.tu; n++) {
            if (N.data[n].i == M.data[m].i && N.data[n].j == M.data[m].j) {
                 break;
            }           
        }
        if (n-1 == N.tu) {
            sum->data[c].i = M.data[m].i;
            sum->data[c].j = M.data[m].j;
            sum->data[c].e = M.data[m].e;
            c++;
        }
    }

    for (n = 1; n <= N.tu; n++) {
        for (m = 1; m <= M.tu; m++) {
            if (N.data[n].i == M.data[m].i && N.data[n].j == M.data[m].j) {
                break;
            }
        }
        if (m-1 == M.tu) {
            sum->data[c].i = N.data[n].i;
            sum->data[c].j = N.data[n].j;
            sum->data[c].e = N.data[n].e;
            c++;
        }
    }
    sum->tu = c - 1;
    return OK;
}

int Minus(RLSMatrix M, RLSMatrix N, RLSMatrix *minus) {
    int m, n, c = 1;
    if (M.mu != N.mu || M.nu != N.nu) { printf("無法相減！\n"); return ERROR; }
    minus->mu = M.mu;
    minus->nu = M.nu;
    for (m = 1; m <= M.tu; m++) {
        for (n = 1; n <= N.tu; n++) {
            if (N.data[n].i == M.data[m].i&&N.data[n].j == M.data[m].j) {
                minus->data[c].i = N.data[n].i;
                minus->data[c].j = N.data[n].j;
                minus->data[c].e = M.data[m].e - N.data[n].e;
                c++;
            }

        }
    }
    for (m = 1; m <= M.tu; m++) {
        for (n = 1; n <= N.tu; n++) {
            if (N.data[n].i == M.data[m].i && N.data[n].j == M.data[m].j) {
                 break;
            }           
        }
        if (n-1 == N.tu) {
            minus->data[c].i = M.data[m].i;
            minus->data[c].j = M.data[m].j;
            minus->data[c].e = M.data[m].e;
            c++;
        }
    }
    for (n = 1; n <= N.tu; n++) {
        for (m = 1; m <= M.tu; m++) {
            if (M.data[m].i == N.data[n].i && M.data[m].j == N.data[n].j) {
               break;
            }           
        }
        if (m-1 == M.tu) {
            minus->data[c].i = N.data[n].i;
            minus->data[c].j = N.data[n].j;
            minus->data[c].e = -N.data[n].e;
            c++;
        }
    }
    minus->tu = c - 1;
    return OK;
}
int Multi(RLSMatrix M, RLSMatrix N, RLSMatrix *Q) {
    if (M.nu != N.mu)return ERROR;
    Q->mu = M.mu; Q->nu=N.nu; Q->tu = 0;
    int tp; int i;
    int p, brow;
    int q, ccol;
    if (M.tu*N.tu != 0) {
        int arow;
        int ctemp[12500];
        for (arow = 1; arow <= M.mu; ++arow) {
            for (i = 1; i <= M.nu; i++) ctemp[i] = 0;
            Q->rpos[arow] = Q->tu + 1;
            if (arow < M.mu)tp = M.rpos[arow + 1];
            else { tp = M.tu + 1; }
            for (p = M.rpos[arow]; p<tp; ++p) {
                brow = M.data[p].j;
                int t;
                if (brow < M.mu)t = N.rpos[brow + 1];
                else { t = N.tu + 1; }
                for (q = N.rpos[brow]; q < t; ++q) {
                    ccol = N.data[q].j;
                    ctemp[ccol] += M.data[p].e * N.data[q].e;
                }
            }
            for (ccol = 1; ccol <= Q->nu; ++ccol) {
                if (ctemp[ccol]) {
                    if (++Q->tu > MAXSIZE)return ERROR;
                    Q->data[Q->tu].i = arow;
                    Q->data[Q->tu].j = ccol;
                    Q->data[Q->tu].e = ctemp[ccol];
                }
            }
        }
    }
    return OK;
}

void PrintMatrix(RLSMatrix M) {
    int m, n, s;
    int tag;
    for (m = 1; m <= M.mu; m++) {
        for (n = 1; n <= M.nu; n++) {
            tag = 0;
            for (s = 1; s <= M.tu; s++) {
                if (M.data[s].j == n && M.data[s].i == m) { 
                    if(M.data[s].e>=0)printf(" %d ", M.data[s].e);
                    else if(M.data[s].e<0){ printf("%d ", M.data[s].e); }
                    tag = 1;
                }
            }
            if(tag==0)printf(" 0 ");
        }printf("\n");
    }
}
}

Main.c檔案

#include<stdio.h>
#include<stdlib.h>
#include"Matrix.h"
int main() {
RLSMatrix M, N, temp;
int tag;
CreateMatrix(&M); Initrpos(&M); printf("所得矩陣為：\n"); PrintMatrix(M); Printrpos(M);
CreateMatrix(&N); Initrpos(&N); printf("所得矩陣為：\n"); PrintMatrix(N); Printrpos(N);
tag=Add(M, N, &temp); Initrpos(&temp); 
 if(tag == OK) {
     printf("兩矩陣相加所得為：\n"); PrintMatrix(temp);
  }
tag=Minus(M, N, &temp); Initrpos(&temp); 
if (tag == OK) {
      printf("兩矩陣相減所得為：\n"); PrintMatrix(temp);
  }
tag=Multi(M, N, &temp); Initrpos(&temp); 
  if(tag == OK){ 
      printf("兩矩陣相乘所得為：\n"); 
      PrintMatrix(temp);
  }
system("pause");
}

演示示例如下：

注：
1. 為了使輸出的矩陣更加形狀好看規則，設計了元素的正負判定（因為負數輸出時會多一個負號），使得正數和負數的數字部分可以對齊。
2. 為了減少非法輸入的可能，在建立矩陣的函式中加入了非零元素不能多於矩陣行列數乘積的判定。以及列數行數必須為正整數，輸入非零元不能為零的判定。
3. 在矩陣不滿足加法減法（或是乘法）條件的時候，需要報錯。為此將運算函式設定為int型別，根據返回值來判斷該列印運算結果還是直接列印報錯。
4. 在主函式的設計過程中，在建立函式和rpos初始化結束後立即列印輸出矩陣和對應的rpos值便於立即檢驗函式建立的矩陣是否正確，也便於使用者檢視對比。