一、        實驗環境

VC6.0，

 二、        實驗目的

 輸入任意兩個稀疏矩陣進入三元表，求出其加法運算後的矩陣，轉置矩陣，輸出矩陣。

 三、        實驗內容

1用C語言實現稀疏矩陣的三元組儲存結構 ；

2實現稀疏矩陣的矩陣輸入、矩陣輸出等演算法；

3.利用三元組儲存結構解決稀疏矩陣的運算問題（稀疏矩陣的轉置、稀疏矩陣的加法等） 。

四、        資料結構與演算法思想描述

    用三元表實現的。採用結構體表示三元表，三元組表。

（1）建立稀疏矩陣，以行優先順序存放，使用者只需輸入稀疏矩陣非零元素的個數，及其具體座標，值。就能依次放入三元表中，

（2）兩個稀疏矩陣相加，首先遍歷A，將值全部放入C裡，同樣,B也放入C裡。

迴圈A,B。如果兩矩陣存在座標相同的點則相加之後更改C中同樣位置的值。

（3） 稀疏矩陣的轉置，將A的行列數互換再賦值給D。遍歷a，將元素值的橫縱座標互換，元素值不變，賦值到d.的三元表組裡面。

（4） 輸出稀疏矩陣，建立一個數組，大小最大為【10】【10】，全部賦值為0，在遍歷三元表，當行列存在時，將三元表的元素值賦值到數組裡。在逐個輸出陣列。

#include<stdio.h>
#include<stdlib.h>
typedef struct{
   int row,col;
   int e;
}triplelist;
typedef struct{
    triplelist data[100];
    int m,n,len;
}node;
//宣告函式
void create(node &a);//建立稀疏矩陣三元組
void add(node &a,node &b,node &c);//兩個稀疏矩陣相加
void nodeprint(node &a);//輸出稀疏矩陣
void nodetransposition(node &a,node &d);//稀疏矩陣的轉置
void create(node &a){
     int i,l;
     scanf("%d",&l);
     while(l>100){
          printf("稀疏矩陣的個數不能超過100！\n");
          printf("請重新輸入稀疏矩陣中的非零元素:");
          scanf("%d",&l);
     }
    a.len=l;
    printf("請輸入稀疏矩陣中的行數：\n");
    scanf("%d",&a.m);
    printf("請輸入稀疏矩陣中的列數：\n");
    scanf("%d",&a.n);
    for(i=0;i<l;i++){
       printf("請輸入稀疏矩陣中的第%d個非零元素的行標（從0開始），列標（從0開始），元素值：\n",i);
       scanf("%d",&a.data[i].row);
        scanf("%d",&a.data[i].col);
           scanf("%d",&a.data[i].e);
         while(a.data[i].row+1>a.m){
               printf("請重新輸入稀疏矩陣中的第%d個非零元素的行標：\n",i);
                 scanf("%d",&a.data[i].row);
         }
          while(a.data[i].col+1>a.n){
               printf("請重新輸入稀疏矩陣中的第%d個非零元素的列標：\n",i);
                 scanf("%d",&a.data[i].col);
         }
    }
}
void add(node &a,node &b,node &c){
    if(a.m==b.m&&a.n==b.n){
        int i,j,k=0;
        c.m=a.m;
        c.n=a.n;
       for(i=0;i<a.len;i++)
            for(j=0;j<b.len;j++){
                if(a.data[i].row==b.data[j].row&&a.data[i].col==b.data[j].col){
                    c.data[k].col=a.data[i].col;
                    c.data[k].row=a.data[i].row;
                    c.data[k].e=a.data[i].e+b.data[j].e;
                    k++;
                }
                else{
                    c.data[k].col=a.data[i].col;
                    c.data[k].row=a.data[i].row;
                    c.data[k].e=a.data[i].e;
                    k++;
                    c.data[k].col=b.data[j].col;
                    c.data[k].row=b.data[j].row;
                    c.data[k].e=b.data[j].e;
                    k++;
                }
                 
            }
    c.len=k;
    }
    else{
         printf("只有同型矩陣才能進行加法運算（即：兩個矩陣的行列相同）\n");
    }

}
void nodeprint(node &a){
     int k=0,i,j,m=a.m ,n=a.n;     
     int b[10][10]={0};
     for(i=0;i<m;i++)
         for(j=0;j<n;j++)
             for(k=0;k<a.len;k++)
                 if(a.data[k].row==i&&a.data[k].col==j){
                    b[i][j]=a.data[k].e;  
                }

    for(i=0;i<m;i++)
    {
        for(j=0;j<n;j++)
         printf("%d ",b[i][j]);
        printf("\n");
     }
}
void nodetransposition(node &a,node &d){
     int i;
     d.m=a.n;
     d.n=a.m;
     d.len=a.len;
     for(i=0;i<a.len;i++){
        d.data[i].col=a.data[i].row;
        d.data[i].row=a.data[i].col;
        d.data[i].e=a.data[i].e;
     }

}
int main(){
    node a,b,c,d;
    printf("輸入第一個稀疏矩陣的非零元素的個數：\n");
    create(a);
    printf("輸入第二個稀疏矩陣的非零元素的個數：\n");
    create(b);
    printf("輸出第一個稀疏矩陣：\n");
    nodeprint(a);
    printf("輸出第二個稀疏矩陣：\n");
    nodeprint(b);
    printf("輸入第一個稀疏矩陣的轉置矩陣：\n");
    nodetransposition(a,d);
    nodeprint(d);
    printf("輸入兩個稀疏矩陣相加之和為：\n");
    add(a,b,c);
    nodeprint(c);
  return 0;
}

 

實驗分析：

輸入：created（node&a）函式，輸入非零元素個數，行列數，再輸入非零元素座標，

輸出：nodeprint(node &a)函式：建立一個數組，大小最大為【10】【10】，全部賦值為0，在遍歷三元表，當行列存在時，將三元表的元素值賦值到數組裡。在逐個輸出陣列。

轉置：nodetransposition(node &a,node &d)，將a的行列數互換放到d中。遍歷a，將元素值的橫縱座標互換，元素值不變，賦值到d.data[]裡面。

加法運算：add(node&a,node &d,node &c)分別遍歷a,b將值放到c裡面，然後在同時遍歷a,b當兩矩陣相同的位置上有值時，相加在放入c中。如果兩個不同型矩陣，則不能進行加法運算。

Main()函式：建立兩個矩陣，依次呼叫created（node&a），nodeprint(node &a)，nodetransposition(node &a,node &d), add(node&a,node &d,node &c) ，nodeprint(node&a)。