南昌航空大學實驗報告
二0 21 年 5月 20 日
課程名稱： 數據結構實驗 實驗名稱： 數組及其應用
班級： 姓名： 同組人：
指導教師評定： 簽名：
1.必做：
一、 需求分析
題目：稀疏矩陣A、B均采用三元組順序表表示，驗證實現矩陣A快速轉置算法，並設計、驗證矩陣A、B相加得到矩陣C的算法。
(1)從鍵盤輸入矩陣的行數和列數，隨機生成稀疏矩陣。
(2) 設計算法將隨機生成的稀疏矩陣轉換成三元組順序表形式存儲。
(3) 設計算法將快速轉置得到的與相加得到的三元組順序表分別轉換成矩陣形式。
(4) 輸出隨機生成的稀疏矩陣A、B及其三元組順序表、快速轉置得到的與相加得到的三元組順序表及其矩陣形式。
1、在本次實驗中，首先，從鍵盤輸入A，B矩陣的行數與列數並建立稀疏矩陣A和B的信息，然后使兩個矩陣相加，再輸出A，B矩陣三元組表，轉置三元組表。
2. 演示程序以用戶和計算機對話的方式進行，即在計算機終端上顯示“提示信息”之后，由用戶在鍵盤上先后輸入兩個矩陣信息。
3. 程序執行的命令包括：
(1) 輸入矩陣A的行數和列數；
(2) 輸出A的三元組順序表；
(3) 將A矩陣轉置，並輸出轉置后的三元組表和矩陣；
(4) 輸入矩陣B的行數和列數；
(5) 輸出B的三元組順序表；
(6) 將B矩陣轉置，並輸出轉置后的三元組表和矩陣。
(7) 將矩陣A與B相加得到矩陣C
(8) 結束
4. 測試數據
輸入：
請輸入A矩陣的行數和列數：
4 5
A的三元組順序表如下：
4 4 1
A的稀疏矩陣如下：
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 1 0
A轉置的三元組順序表如下：
4 4 1
A轉置的稀疏矩陣如下：
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 1 0
請輸入B矩陣的行數和列數：
4 5
B的三元組順序表如下：
1 4 7
4 4 3
B的稀疏矩陣如下：
0 0 0 7 0
0 0 0 0 0
0 0 0 0 0
0 0 0 3 0
B轉置的三元組順序表如下：
4 1 7
4 4 3
B轉置的稀疏矩陣如下：
0 0 0 0 0
0 0 0 0 0
7 0 0 3 0
0 0 0 0 0
矩陣A+B的三元組順序表如下：
1 4 7
4 4 4
矩陣A+B如下：
0 0 0 7 0
0 0 0 0 0
0 0 0 0 0
0 0 0 4 0
二、 概要設計
1. 抽象數據類型定義
為實現上述程序功能，需要一個抽象數據類型：圖。
ADT Graph{
基本操作：
InitMatrix(TSMatrix &s)
操作結果：初始化矩陣
CreatMatrix(int mu,int nu,TSMatrix &s)
操作結果：生成隨機矩陣
TransposeSMatrix(TSMatrix M,TSMatrix &T)
操作結果：將稀疏矩陣轉置
TSMatrix_to_Matrix(TSMatrix s)
操作結果：三元組轉換成矩陣並輸出
PrintMatrix(TSMatrix s)
操作結果：打印三元組順序表
AddMatrix(TSMatrix s1,TSMatrix s2,TSMatrix &s)
操作結果：將兩個矩陣相加
2.程序模塊
（1）主程序流程
void main{
初始化三個矩陣，
根據提示輸入矩陣信息；
兩個矩陣相加；
輸出每個矩陣的三元組順序表；
輸出每個矩陣的轉置矩陣；
}
（2）生成隨機矩陣；
（3）矩陣轉置；
（4）三元組表轉成矩陣並輸出；
（5）打印三元組順序表
（6）將兩個矩陣相加
3.程序結構圖
各模塊之間的調用關系如圖所示。
圖1 模塊之間調用關系圖
三、 詳細設計
1.數據類型及結構體
typedef struct{//非零元行下標列下標和值
int i,j;
ElemType e;
}Triple;
typedef struct{
Triple data[MAXSIZE+1];//非零元三元組表，data[0]未使用
int mu,nu,tu;//矩陣行數，列數和非零元數
}TSMatrix;
void InitMatrix(TSMatrix &s)；//初始化
void CreatMatrix(int mu,int nu,TSMatrix &s)//創建隨機矩陣
void TransposeSMatrix(TSMatrix M,TSMatrix &T)//采用三元組順序表存儲表示，求稀疏矩陣M的轉置矩陣T
void TSMatrix_to_Matrix(TSMatrix s){//將三元組順序表變為矩陣並輸出
void PrintMatrix(TSMatrix s){//打印三元組順序表
void AddMatrix(TSMatrix s1,TSMatrix s2,TSMatrix &s)//A矩陣與B矩陣相加
2.主函數
int main(){
int mu,nu;
TSMatrix s1,s2,s11,s12,s;
InitMatrix(s1);
InitMatrix(s2);
InitMatrix(s11);//s1用於轉置
InitMatrix(s12);//s2用於轉置
InitMatrix(s);//用於矩陣相加
printf("請輸入A矩陣的行數和列數:\n");
scanf("%d %d",&mu,&nu);
CreatMatrix(mu,nu,s1);
TransposeSMatrix(s1,s11);
printf("A的三元組順序表如下:\n");
PrintMatrix(s1);
printf("A的稀疏矩陣如下:\n");
TSMatrix_to_Matrix(s1);
printf("A轉置的三元組順序表如下:\n");
PrintMatrix(s11);
printf("A轉置的稀疏矩陣如下:\n");
TSMatrix_to_Matrix(s11);
printf("請輸入B矩陣的行數和列數:\n");
scanf("%d %d",&mu,&nu);
CreatMatrix(mu,nu,s2);
if(s1.mu!=s2.mu||s1.nu!=s2.nu)
{
printf("無法進行計算");
exit(-1);
}
TransposeSMatrix(s2,s12);
printf("B的三元組順序表如下:\n");
PrintMatrix(s2);
printf("B的稀疏矩陣如下:\n");
TSMatrix_to_Matrix(s2);
printf("B轉置的三元組順序表如下:\n");
PrintMatrix(s12);
printf("B轉置的稀疏矩陣如下:\n");
TSMatrix_to_Matrix(s12);
AddMatrix(s1,s2,s);
printf("矩陣A+B的三元順序表如下:\n");
PrintMatrix(s);
printf("矩陣A+B如下:\n");
TSMatrix_to_Matrix(s);
return 0;
}
四、 調試分析
1. 調試過程中第一次采用了二維數組過渡，經改正利用for循環直接存儲與輸出代替了二維數組
2.隨機數每次生成都一樣，加入代碼srand((unsigned)time(NULL));
3.兩矩陣相加的函數里面第一次完成時出錯，得到的答案並不是正確的，經檢查發現兩矩陣相加必須行數與列數相同。
4.該算法的中矩陣的生成，轉置等算法的時間復雜度都為O（m*n)m為行數，n為列數，所以本算法的時間復雜度為O(m*n)
五、 用戶手冊
1. 本程序的運行環境為DOS操作系統，執行文件為：main.exe。
2. 進入演示程序后即顯示文本方式的用戶界面。
3. 程序運行后，按照提示信息輸入矩陣信息。
4. 輸出結果轉置，三元組順序表矩陣相加等結果。
六、 測試結果
測試結果
輸入：
請輸入A矩陣的行數和列數：
4 5
A的三元組順序表如下：
4 4 1
A的稀疏矩陣如下：
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 1 0
A轉置的三元組順序表如下：
4 4 1
A轉置的稀疏矩陣如下：
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 1 0
請輸入B矩陣的行數和列數：
4 5
B的三元組順序表如下：
1 4 7
4 4 3
B的稀疏矩陣如下：
0 0 0 7 0
0 0 0 0 0
0 0 0 0 0
0 0 0 3 0
B轉置的三元組順序表如下：
4 1 7
4 4 3
B轉置的稀疏矩陣如下：
0 0 0 0 0
0 0 0 0 0
7 0 0 3 0
0 0 0 0 0
矩陣A+B的三元組順序表如下：
1 4 7
4 4 4
矩陣A+B如下：
0 0 0 7 0
0 0 0 0 0
0 0 0 0 0
0 0 0 4 0
七、 附錄
源代碼:#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define MAXSIZE 10000
#define ElemType int
typedef struct{//非零元行下標列下標和值
int i,j;
ElemType e;
}Triple;
typedef struct{
Triple data[MAXSIZE+1];//非零元三元組表，data[0]未使用
int mu,nu,tu;//矩陣行數，列數和非零元數
}TSMatrix;
void InitMatrix(TSMatrix &s)
{
s.data[0].i=-1;
s.data[0].j=-1;
s.data[0].e=-1;
s.mu=s.nu=s.tu=0;
}
void CreatMatrix(int mu,int nu,TSMatrix &s)//創建隨機矩陣
{
int a,k1,k2,k,k3=0;
s.mu = mu;
s.nu = nu;
srand((unsigned)time(NULL));
for(k1=1;k1<=mu;k1++)
{
for(k2=1;k2<=nu;k2++)
{
a=rand()%10;
if(a==1)
{
k3++;
s.data[k3].i=k1;
s.data[k3].j=k2;
s.data[k3].e=rand()%9+1;
}
}
}
s.tu=k3;
}
void TransposeSMatrix(TSMatrix M,TSMatrix &T)//采用三元組順序表存儲表示，求稀疏矩陣M的轉置矩陣T
{
T.mu=M.nu;T.nu=M.mu;T.tu=M.tu;
if(T.tu){
int q=1;
for(int col=1;col<=M.nu;++col)
for(int p=1;p<=M.tu;++p)
if(M.data[p].j==col){
T.data[q].i=M.data[p].j;
T.data[q].j=M.data[p].i;
T.data [q].e=M.data[p].e;
++q;
}
}
}
void TSMatrix_to_Matrix(TSMatrix s){//將三元組順序表變為矩陣並輸出
int k1,k2,k=1;
for(k1=1;k1<=s.mu;k1++)
{
for(k2=1;k2<=s.nu;k2++)
{
if(s.data[k].i==k1&&s.data[k].j==k2)
{
printf("%d ",s.data[k].e);
k++;
}
else{
printf("0 ");
}
}
printf("\n");
}
}
void PrintMatrix(TSMatrix s){//打印三元組順序表
for(int i=1;i<=s.tu;i++){
printf("%d %d %d\n",s.data[i].i,s.data[i].j,s.data[i].e);
}
printf("\n");
}
void AddMatrix(TSMatrix s1,TSMatrix s2,TSMatrix &s)//A矩陣與B矩陣相加
{
s.mu=s1.mu;
s.nu=s1.nu;
int k1=1,k2=1,count=0;
while(k1<=s1.tu&&k2<=s2.tu)
{
if(s1.data[k1].i<s2.data[k2].i)
{
count++;
s.data[count].i=s1.data[k1].i;
s.data[count].j=s1.data[k1].j;
s.data[count].e=s1.data[k1].e;
k1++;
}else{
if(s1.data[k1].i>s2.data[k2].i)
{
count++;
s.data[count].i=s2.data[k2].i;
s.data[count].j=s2.data[k2].j;
s.data[count].e=s2.data[k2].e;
k2++;
}
else
{
if(s1.data[k1].j<s2.data[k2].j)
{
count++;
s.data[count].i=s1.data[k1].i;
s.data[count].j=s1.data[k1].j;
s.data[count].e=s1.data[k1].e;
k1++;
}else {
if(s1.data[k1].j>s2.data[k2].j)
{
count++;
s.data[count].i=s2.data[k2].i;
s.data[count].j=s2.data[k2].j;
s.data[count].e=s2.data[k2].e;
k2++;
}else
{
if(s1.data[k1].e+s2.data[k2].e!=0)
{
count++;
s.data[count].e=s1.data[k1].e+s2.data[k2].e;
s.data[count].i=s2.data[k2].i;
s.data[count].j=s2.data[k2].j;
}
k2++;k1++;
}
}
}
}
}
while(k1<=s1.tu)
{
count++;
s.data[count].i=s1.data[k1].i;
s.data[count].j=s1.data[k1].j;
s.data[count].e=s1.data[k1].e;
k1++;
}
while(k2<=s2.tu)
{
count++;
s.data[count].i=s2.data[k2].i;
s.data[count].j=s2.data[k2].j;
s.data[count].e=s2.data[k2].e;
k2++;
}
s.tu=count;
}
int main(){
int mu,nu;
TSMatrix s1,s2,s11,s12,s;
InitMatrix(s1);
InitMatrix(s2);
InitMatrix(s11);//s1用於轉置
InitMatrix(s12);//s2用於轉置
InitMatrix(s);//用於矩陣相加
printf("請輸入A矩陣的行數和列數:\n");
scanf("%d %d",&mu,&nu);
CreatMatrix(mu,nu,s1);
TransposeSMatrix(s1,s11);
printf("A的三元組順序表如下:\n");
PrintMatrix(s1);
printf("A的稀疏矩陣如下:\n");
TSMatrix_to_Matrix(s1);
printf("A轉置的三元組順序表如下:\n");
PrintMatrix(s11);
printf("A轉置的稀疏矩陣如下:\n");
TSMatrix_to_Matrix(s11);
printf("請輸入B矩陣的行數和列數:\n");
scanf("%d %d",&mu,&nu);
CreatMatrix(mu,nu,s2);
if(s1.mu!=s2.mu||s1.nu!=s2.nu)
{
printf("無法進行計算");
exit(-1);
}
TransposeSMatrix(s2,s12);
printf("B的三元組順序表如下:\n");
PrintMatrix(s2);
printf("B的稀疏矩陣如下:\n");
TSMatrix_to_Matrix(s2);
printf("B轉置的三元組順序表如下:\n");
PrintMatrix(s12);
printf("B轉置的稀疏矩陣如下:\n");
TSMatrix_to_Matrix(s12);
AddMatrix(s1,s2,s);
printf("矩陣A+B的三元順序表如下:\n");
PrintMatrix(s);
printf("矩陣A+B如下:\n");
TSMatrix_to_Matrix(s);
return 0;
}
2.選做：
一、 需求分析
題目：兩個n*n階的對稱矩陣A、B均采用三元組順序表表示，設計並驗證矩陣A、B兩相乘算法
1、在本次實驗中，首先，從鍵盤輸入A矩陣的行數與列數並建立稀疏矩陣A的信息，按照對稱生成矩陣B，將兩個矩陣相乘。
2. 演示程序以用戶和計算機對話的方式進行，即在計算機終端上顯示“提示信息”之后，由用戶在鍵盤上先后輸入矩陣信息。
3. 程序執行的命令包括：
(1) 輸入矩陣A的行數和列數；
(2) 輸出A的三元組順序表與稀疏矩陣；
(3) 根據對稱得到矩陣B；
(4) 輸出B的三元組順序表與稀疏矩陣；
(5)將矩陣A與B相乘並輸出
4. 測試數據
輸入：
請輸入A矩陣的行數和列數：
4 4
A的三元組順序表如下：
3 2 1
A的稀疏矩陣如下：
0 0 0 0
0 0 0 0
0 1 0 0
0 0 0 0
B的三元組順序表如下：
2 3 1
B的稀疏矩陣如下：
0 0 0 0
0 0 1 0
0 0 0 0
0 0 0 0
矩陣A+B的三元組順序表如下：
3 31
矩陣A+B如下：
0 0 0 0
0 0 0 0
0 0 1 0
0 0 0 0
二、 概要設計
1. 抽象數據類型定義
為實現上述程序功能，需要一個抽象數據類型：圖。
ADT Graph{
基本操作：
InitMatrix(RLSMatrix &s)
操作結果：初始化矩陣
CreatMatrix(int mu,int nu,RLSMatrix &s)
操作結果：生成隨機矩陣
TSMatrix_to_Matrix(RLSMatrix s)
操作結果：三元組轉換成矩陣並輸出
SortMatrix(RLSMatrix s1,RLSMatrix &s2)
操作結果：生成對稱矩陣
PrintMatrix(RLSMatrix s)
操作結果：打印三元組順序表
MultSMatrix(RLSMatrix M, RLSMatrix N, RLSMatrix &Q)
操作結果：將兩個矩陣相乘
2.程序模塊
（1）主程序流程
void main{
初始化三個矩陣，
根據提示輸入矩陣信息；
兩個矩陣相乘；
輸出每個矩陣的三元組順序表與矩陣；
}
(2)生成隨機矩陣；
(3)生成對稱矩陣；
(4)三元組表轉成矩陣並輸出；
(5)打印三元組順序表
(6)將兩個矩陣相乘
3.程序結構圖
各模塊之間的調用關系如圖所示。
圖1 模塊之間調用關系圖
三、 詳細設計
1.數據類型及結構體
typedef struct{//非零元行下標列下標和值
int i,j;
ElemType e;
}Triple;
typedef struct{
Triple data[MAXSIZE+1];//非零元三元組表，data[0]未使用
int rpos[MAXSIZE];//每行第一個非零元素在data數組中的位置
int count;//rpos[]中的個數
int mu,nu,tu;//矩陣行數，列數和非零元數
}RLSMatrix;
void InitMatrix(RLSMatrix &s)；//初始化
void CreatMatrix(int mu,int nu,RLSMatrix &s)//創建隨機矩陣
void SortMatrix(RLSMatrix s1,RLSMatrix &s2){//矩陣對稱且排序
void TSMatrix_to_Matrix(RLSMatrix s){//將三元組順序表變為矩陣並輸出
void PrintMatrix(RLSMatrix s){//打印三元組順序表
int MultSMatrix(RLSMatrix M, RLSMatrix N, RLSMatrix &Q)//A矩陣與B矩陣相乘
- 主函數
int main(){
int mu,nu;
RLSMatrix s1,s2,s;
InitMatrix(s1);
InitMatrix(s2);
InitMatrix(s);//用於矩陣相加
printf("請輸入A矩陣的行數和列數:\n");
scanf("%d %d",&mu,&nu);
CreatMatrix(mu,nu,s1);
printf("A的三元組順序表如下:\n");
PrintMatrix(s1);
printf("A的稀疏矩陣如下:\n");
TSMatrix_to_Matrix(s1);
SortMatrix(s1,s2);
printf("B的三元組順序表如下:\n");
PrintMatrix(s2);
printf("B的稀疏矩陣如下:\n");
TSMatrix_to_Matrix(s2);
MultSMatrix(s1,s2,s);
printf("矩陣A*B的三元順序表如下:\n");
PrintMatrix(s);
printf("矩陣A*B如下:\n");
TSMatrix_to_Matrix(s);
return 0;
}
四、 調試分析
1. 第一次矩陣逆置后忘了排序，導致無法輸出矩陣B與排序，排序代碼：
for(int k1=1;k1<=s2.tu;k1++)
{
int a,b,c;
for(int k2=k1+1;k2<=s2.tu;k2++)
{
if((s2.data[k2].i<s2.data[k1].i)||(s2.data[k2].i==s2.data[k1].i&&s2.data[k2].j<s2.data[k1].j))
{
a=s2.data[k2].i;
b=s2.data[k2].j;
c=s2.data[k2].e;
s2.data[k2].i=s2.data[k1].i;
s2.data[k2].j=s2.data[k1].j;
s2.data[k2].e=s2.data[k1].e;
s2.data[k1].i=a;
s2.data[k1].j=b;
s2.data[k1].e=c;
}
}
}
2.做乘法是遍歷出現了問題，做乘法時矩陣的對應的行乘上對應的列再相加，生成的數放到新矩陣中行為矩陣A的行，列為矩陣B的列。
3.該算法的中矩陣的生成,對稱矩陣生成后排序等算法的時間復雜度都為O（m*m)m為行數與列數，對稱矩陣的生成時間復雜度為O(m)，矩陣相乘的時間復雜度為O(m*m*m),所以本算法的時間復雜度為O(m*m*m)
五、 用戶手冊
1. 本程序的運行環境為DOS操作系統，執行文件為：main.exe。
2. 進入演示程序后即顯示文本方式的用戶界面。
3. 程序運行后，按照提示信息輸入矩陣信息。
4. 輸出矩陣相乘的三元組順序表等結果。
六、 測試結果
測試結果
輸入：
請輸入A矩陣的行數和列數：
4 4
A的三元組順序表如下：
3 2 1
A的稀疏矩陣如下：
0 0 0 0
0 0 0 0
0 1 0 0
0 0 0 0
B的三元組順序表如下：
2 3 1
B的稀疏矩陣如下：
0 0 0 0
0 0 1 0
0 0 0 0
0 0 0 0
矩陣A+B的三元組順序表如下：
3 31
矩陣A+B如下：
0 0 0 0
0 0 0 0
0 0 1 0
0 0 0 0
七、 附錄
源代碼:#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define MAXSIZE 10000
#define ERROR 0
#define OK 1
#define ElemType int
typedef struct{//非零元行下標列下標和值
int i,j;
ElemType e;
}Triple;
typedef struct{
Triple data[MAXSIZE+1];//非零元三元組表，data[0]未使用
int rpos[MAXSIZE];//每行第一個非零元素在data數組中的位置
int count;//rpos[]中的個數
int mu,nu,tu;//矩陣行數，列數和非零元數
}RLSMatrix;
void InitMatrix(RLSMatrix &s)
{
s.data[0].i=-1;
s.data[0].j=-1;
s.data[0].e=-1;
s.mu=s.nu=s.tu=s.count=0;
}
void CreatMatrix(int mu,int nu,RLSMatrix &s)//創建隨機矩陣
{
int a,b=0,c=0,k1,k2,k,k3=0;
s.mu = mu;
s.nu = nu;
srand((unsigned)time(NULL));
for(k1=1;k1<=mu;k1++)
{
b=0;
for(k2=1;k2<=nu;k2++)
{
a=rand()%10;
if(a==1)
{
k3++;
s.data[k3].i=k1;
s.data[k3].j=k2;
s.data[k3].e=rand()%9+1;
if(b==0)
{
s.rpos[c++]=k3;
}
b++;
}
}
}
s.tu=k3;
s.count=c;
}
void TSMatrix_to_Matrix(RLSMatrix s){//將三元組順序表變為矩陣並輸出
int k1,k2,k=1;
for(k1=1;k1<=s.mu;k1++)
{
for(k2=1;k2<=s.nu;k2++)
{
if(s.data[k].i==k1&&s.data[k].j==k2)
{
printf("%d ",s.data[k].e);
k++;
}
else{
printf("0 ");
}
}
printf("\n");
}
}
void SortMatrix(RLSMatrix s1,RLSMatrix &s2){//矩陣對稱且排序
int i;
s2.mu=s1.nu;
s2.nu=s1.mu;
s2.tu=s1.tu;
for(i=1;i<=s1.tu;i++) {
s2.data[i].e=s1.data[i].e;
s2.data[i].i=s1.data[i].j;
s2.data[i].j=s1.data[i].i;
}
for(int k1=1;k1<=s2.tu;k1++)
{
int a,b,c;
for(int k2=k1+1;k2<=s2.tu;k2++)
{
if((s2.data[k2].i<s2.data[k1].i)||(s2.data[k2].i==s2.data[k1].i&&s2.data[k2].j<s2.data[k1].j))
{
a=s2.data[k2].i;
b=s2.data[k2].j;
c=s2.data[k2].e;
s2.data[k2].i=s2.data[k1].i;
s2.data[k2].j=s2.data[k1].j;
s2.data[k2].e=s2.data[k1].e;
s2.data[k1].i=a;
s2.data[k1].j=b;
s2.data[k1].e=c;
}
}
}
}
void PrintMatrix(RLSMatrix s){//打印三元組順序表
for(int i=1;i<=s.tu;i++){
printf("%d %d %d\n",s.data[i].i,s.data[i].j,s.data[i].e);
}
printf("\n");
}
int MultSMatrix(RLSMatrix M, RLSMatrix N, RLSMatrix &Q)
{
Q.mu = M.mu;
Q.nu = N.nu;
Q.tu = 0;
if(M.tu * N.tu == 0)//其中任意矩陣的元素個數為零，則不能做乘運算
return ERROR;
else
{
int row,col,num,Count=1;
for(int k1=0;k1<M.count;k1++)
{
int k=M.rpos[k1];
row=M.data[k].i;
num=0;
for(int k2=1;k2<=N.nu;k2++)
{
num=0;
k=M.rpos[k1];
while(M.data[k].i==row)
{
col=M.data[k].j;
for(int k3=1;k3<=N.tu;k3++)
{
if(N.data[k3].j==k2&&N.data[k3].i==col)
{
num=num+M.data[k].e*N.data[k3].e;
}
}
k++;
}
if(num!=0)
{
Q.data[Count].i=M.data[M.rpos[k1]].i;
Q.data[Count].j=k2;
Q.data[Count].e=num;
Count++;
}
}
}
Q.tu=Count-1;
return OK;
}
}
int main(){
int mu,nu;
RLSMatrix s1,s2,s;
InitMatrix(s1);
InitMatrix(s2);
InitMatrix(s);//用於矩陣相加
printf("請輸入A矩陣的行數和列數:\n");
scanf("%d %d",&mu,&nu);
CreatMatrix(mu,nu,s1);
printf("A的三元組順序表如下:\n");
PrintMatrix(s1);
printf("A的稀疏矩陣如下:\n");
TSMatrix_to_Matrix(s1);
SortMatrix(s1,s2);
printf("B的三元組順序表如下:\n");
PrintMatrix(s2);
printf("B的稀疏矩陣如下:\n");
TSMatrix_to_Matrix(s2);
MultSMatrix(s1,s2,s);
printf("矩陣A*B的三元順序表如下:\n");
PrintMatrix(s);
printf("矩陣A*B如下:\n");
TSMatrix_to_Matrix(s);
return 0;
}