数据结构实验四
南昌航空大学实验报告
二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;
}
