一、        實驗環境

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)。