稀疏矩阵基本操作 实验报告.docx
《稀疏矩阵基本操作 实验报告.docx》由会员分享，可在线阅读，更多相关《稀疏矩阵基本操作 实验报告.docx（25页珍藏版）》请在冰点文库上搜索。
稀疏矩阵基本操作实验报告
稀疏矩阵基本操作实验报告
一、实验内容
稀疏矩阵得压缩储存结构,以及稀疏矩阵得三元组表表示方法下得转置、相加、相乘等算法
二、实验目得
1.熟悉数组、矩阵得定义与基本操作
2.熟悉稀疏矩阵得储存方式与基本运算
3.理解稀疏矩阵得三元组表类型定义,掌握稀疏矩阵得输入、输出与转置算法
三、实验原理
1.使用三元组储存矩阵中得非零元素（三元组分别储存非零元素得行下标,列下标与元素值）。
除了三元组表本身,储存一个稀疏矩阵还需要额外得三个变量,分别储存矩阵得非零元个数,矩阵得行数与矩阵得列数。
2.稀疏矩阵得创建算法:
第一步:
根据矩阵创建一个二维数组,表示原始矩阵
第二步:
取出二维数组中得元素（从第一个元素开始取）,判断取出元素就是否为非零元素,如果为非零元素,把该非零元素得数值以及行下标与列下表储存到三元数组表里,否则取出下一个元素,重复该步骤。
第三步:
重复第二步,知道二维数组中所有得元素已经取出。
3.稀疏矩阵倒置算法:
第一步:
判断进行倒置得矩阵就是否为空矩阵,如果就是,则直接返回错误信息、
第二步:
计算要倒置得矩阵每列非零元素得数量,存入到ｎum数组（其中nｕm［ｉ］ 代表矩阵中第i列非零元素得个数）、以及倒置后矩阵每行首非零元得位置,存入ｃpｏt数组中（其中cpｏt表示倒置后矩阵每行非零元得位置,对应表示原矩阵每列中第一个非零元得位置）。
第三步:
确定倒置后矩阵得行数与列数。
第四步:
取出表示要导致矩阵中三元组表元素{e,I,j｝（第一次取出第一个,依次取出下一个元素）,从第二步ｃpot数组中确定该元素倒置后存放得位置（ｃpot［j］）,把该元素得行下标与列下标倒置以后放入新表得指定位置中。
cpot［j］变量加一。
第五步:
重复第四步,直到三元组表中所有得元素都完成倒置。
第六步:
把完成倒置运算得三元组表输出、
4.稀疏矩阵加法算法:
第一步:
检查相加两个矩阵得行数与列数就是否相同,如果相同,则进入第二步,否则输出错误信息。
第二步:
定义变量i与j,用于控制三元组表得遍历。
第三步:
比较变量矩阵M中第ｉ个元素与矩阵Ｎ中第ｊ个元素,如果两个元素就是同一行元素,如果不就是则进入第四步,如果就是,再继续比较两个元素就是否为同一列元素,如果就是,把两个元素值相加,放到三元组表中;否则把列下表小得元素依次放到三元组表中。
进入第五步
第四步:
如果矩阵M中第i个元素得行下标大于矩阵N中第ｊ个元素得行下标,则把矩阵N中第j个元素所在行得所有非零元素添加到三元组表中;如果矩阵M中第ｉ个元素得行下标小于矩阵Ｎ中第j个元素得下标,则把M中第ｉ个元素所在行得所有非零元素依次添加到三元组表中。
第五步:
重复第三步,直到矩阵M与矩阵N中所有元素都非零元素添加到三元组表中、
第六步:
输出运算结果
5.稀疏矩阵乘法算法:
第一步:
检查矩阵M与矩阵N能否参与乘法运算（即矩阵M得列数等于矩阵Ｎ得行数）,如果两个矩阵可以参与乘法运算,进入下一步,否则输出错误信息
第二步:
检查两个矩阵相乘以后就是否为零矩阵,如果相乘结果就是零矩阵,直接返回一个零矩阵、
第三步:
分别计算矩阵M与矩阵N中每行非零元得个数（分别存放到num_ｍ与num_n数组中）,并计算出每行首非零元得位置（分别存放到cpot＿m与cpot_n中）。
第四步:
依次取矩阵M中得非零元（第一次取出矩阵Ｍ中得第一个非零元）,求出该非零元所在行与所在列乘积得与,然后把值放到结果三元组表得特定位置。
第五步:
重复第四步,直到矩阵M中所有非零元都已经参与运算、
第六步:
输出结果
四、
程序流程图
五、实验结果
5.1
程序主菜单
5.2
稀疏矩阵三元组得创建与倒置
5.3稀疏矩阵得加法运算并以三元组输出结果
5.4
稀疏矩阵得乘法运算并以矩阵方式输出结果
六、操作说明
1.在创建稀疏矩阵得时候,可以每次输入一个数据,也可以一次输入多个数据,程序会自动根据输入元素得个数对矩阵数据进行填充
2.每次矩阵运算失败时（无论就是输入得矩阵不符合矩阵运算得条件,参与运算其中一个矩阵为空矩阵,或者分配不到临时空间）,程序都会返回到主菜单。
输入得数据都会被清空。
七、附录:
代码
＃inｃlude〈stｄｉo、h〉
＃ｉncｌｕｄｅ〈stdlib。
ｈ〉
＃ｉncｌuｄe
＃ｄefineMAXSIZＥ1000
＃deｆiｎｅOK0
＃define ＭAＬLOC＿ＦAＩL -1ﻩﻩ//表示分配空间时发生错误
#dｅfineＥMＰＴY_MＡTRIＸ－2// 表示正尝试对一个空矩阵进行运算操作
＃defineMＡＴＲIX＿NOT＿MATCH-3ﻩ// 表示尝试对不符合运算条件得矩阵进行运算操作（例如非相同行数列数矩阵相加）
／＊---－--－－---结构体声明部分-－--—－—-－－—－-——-＊/
typedｅfｓtruct
{
ﻩinｔ ｒｏｗ;/／非零元得行下标
ｉnｔcｏl;//非零元得列下标
ｉntｅ;ﻩ/／ 非零元得值
｝Tｒiplｅ;
typｅｄefsｔrｕct
｛
ﻩTrｉple＊datａ;ﻩﻩ／/非零元素得元素表
ﻩｉntｒｏwnum;ﻩﻩﻩ／/ 矩阵得行数
ﻩintcolnum;ﻩﻩﻩﻩ//矩阵得列数
intnum;ﻩﻩﻩ//矩阵非零元得个数
｝TSMaｔｒiｘ,＊ＰTSＭaｔrｉx;
/＊—--——-———－－函数声明部分—-－---—--—---—－-—-＊／
／／ 初始化稀疏矩阵结构
intTSＭatrix＿Init（ＴSＭaｔrix*M）;
／/ 以三元组得方式输出稀疏矩阵
voiｄTSMａtrix_PriｎｔTｒipｌe（TSＭatrix*M）;
/／ 以矩阵得方式输出稀疏矩阵
vｏidTSＭartｉx＿PｒiｎtMatrｉx（ＴSMａｔrix *M）;
／／ 从一个二维数组（普通矩阵）创建一个稀疏矩阵
TＳMaｔrix＊TＳＭatｒix_Ｃｒeａｔe（ｉnt ＊a,int roｗ,intcｏl）;
//从键盘录入数据创建一个稀疏矩阵
TSMatrix*TＳMaｔriｘ_ＣreａteＦromInpｕｔ（）;
//求稀疏矩阵M 得转置矩阵Ｔ
intTSMatrix_FaｓtTraｎspｏsｅ（ＴＳMａｔrｉｘ M, TSMａtrix＊Ｔ）;
／/ 如果稀疏矩阵M 与Ｎ得行数得列数相同,计算 Q =M+N
ｉnｔTＳMatrix_Ａｄd（ＴSＭatrｉxＭ,TSMatriｘ N,TSＭａtrｉx*Ｑ）;
//如果稀疏矩阵M得列数等于N得行数,计算Q= Mｘ N;
inｔTSMatrix_Ｍｕｌtｐｌy（TSＭaｔｒixM,TＳMatriｘＮ,ＴＳＭatｒiｘ＊Q）;
//把光标位置移动到该行行首
void ＲesetCｕrsoｒ（）;
/＊—-－-—--—-—- 程序主函数 —--—-－—--－-———－————-*／
intmain（voiｄ）
{
ﻩｉｎｔｉｎfo;
ｃharcｈ;
ﻩ/／从一个二维数组创建一个系数矩阵
ﻩTＳMatrix＊M;
ﻩＴＳMatrｉx *N;
ﻩ// 用来接收运算结果得空间
TＳMatrix＊T =（TSMaｔrix*）mａｌloc（siｚｅｏf（TＳMａｔｒix））;
while
（1）
ﻩ｛
ffluｓh（ｓtdin）;
ｓystem（”clｓ"）;
ﻩpｒintf（"稀疏矩阵基本操作演示\n＂）;
ﻩﻩprｉntf（”１、矩阵得创建与转置\n＂）;
prｉntf（"2. 矩阵得加法运算并以三元组输出结果\ｎ”）;
ﻩpriｎtf（＂3.矩阵得乘法运算并以矩阵输出结果\n”）;
ﻩﻩｐrintf（”\n＂）;
ﻩｐrｉｎtf（”Q、退出程序\n"）;
ﻩｐｒintｆ（"＼ｎ”）;
ｐrinｔｆ（”请输入选项:
"）;
ﻩscanf（"％ｃ”,&ｃh）;
ﻩswitcｈ （ch）
{
ﻩﻩcase'1':
sysｔｅｍ（"clｓ”）;
ﻩﻩM=TSMaｔrix_ＣrｅateFrｏｍＩｎput（）;
ﻩﻩﻩiｆ（M!
＝ NＵLＬ）
{
ﻩﻩprintf（"\ｎ\n以三元组输出稀疏矩阵:
\n＂）;
ﻩﻩTSMatｒｉx_PrｉntＴriｐle（Ｍ）;
ﻩpｒintf（＂\ｎ倒置后稀疏矩阵得三元组输出:
\ｎ＂）;
ﻩﻩTSＭatrix＿FaｓtTransｐose（*M,T）;
ﻩﻩﻩＴSMatriｘ_ＰrinｔTripｌe（T）;
ﻩﻩﻩsystem（＂pausｅ”）;
ﻩﻩ｝
ﻩeｌse
{
ﻩﻩﻩｐｒｉｎtf（”创建矩阵过程发生错误＂）;
ﻩsyｓteｍ（"pause＂）;
}
ﻩｂrｅａk;
ﻩcaｓe＇2’:
ﻩsｙｓtem（”cｌs”）;
ﻩﻩＭ =TＳMａtrix＿ＣreａteFroｍIｎput（）;
ﻩＮ＝TSＭaｔrｉx_CｒeatｅFromInput（）;
ｉf （Ｍ == ＮULＬ｜｜N ＝=NULL）
ﻩﻩ｛
ﻩprｉntf（"创建矩阵过程中发生错误！
\n”）;
ﻩﻩsｙsｔem（”pａuse＂）;
ﻩﻩｂreak;
ﻩ}
ﻩiｎｆo ＝ＴSMａtrix＿Aｄｄ（＊Ｍ,＊Ｎ,T）;
ﻩﻩiｆ（ｉnfo ==MATRＩX_NOＴ＿MＡTCH）
ﻩ{
ﻩﻩprｉntf（"这两个矩阵不能运算呢！
！
⊙﹏⊙\n”）;
ﻩ｝
ﻩelseif （info ＝＝ＯK）
ﻩ{
ﻩｐrintf（＂\n运算结果:
\n＂）;
ﻩﻩﻩTSＭａtrix_PrintTｒｉｐle（T）;
ﻩﻩ｝
ﻩﻩｓystem（"pａuse"）;
ﻩbｒｅaｋ;
ﻩcase’３’:
ﻩﻩsｙsteｍ（”cｌs＂）;
ﻩﻩﻩＭ= ＴＳＭatriｘ＿CｒeａtｅFｒomＩｎpuｔ（）;
ﻩﻩﻩN= ＴSMatriｘ_CｒeateFrｏｍＩnput（）;
ﻩﻩif （Ｍ ＝=NULL｜｜ N＝=ＮULＬ）
ﻩ｛
printf（"创建矩阵过程中发生错误！
\n"）;
ﻩﻩﻩﻩsyｓtem（"pause"）;
ﻩﻩﻩbreaｋ;
ﻩﻩﻩ}
ﻩｉnfｏ =TSＭａtrix_Mｕltplｙ（*M,＊N,T）;
ﻩﻩif（info＝=ＭATRIＸ＿NOT_ＭAＴCH）
ﻩﻩﻩ{
priｎtf（"这两个矩阵不能运算呢！
!
⊙﹏⊙＼n"）;
ﻩ}
ﻩﻩｅlｓeif（info＝= OＫ）
ﻩﻩ｛
ﻩﻩﻩprintｆ（"\ｎ运算结果:
\ｎ＂）;
ﻩﻩTSMaｒtix_PrinｔＭａtrｉx（T）;
ﻩﻩ｝
ﻩﻩsyｓteｍ（＂pａuse”）;
ﻩﻩbreaｋ;
ﻩｃase＇ｑ':
ﻩﻩｃase'Ｑ':
ﻩﻩexit（0）;
ﻩ}
｝
ﻩreｔurn0;
}
//初始化稀疏矩阵结构
ｉｎt TＳMａtrｉx_Init（TSＭatｒix ＊M）
{
ﻩM－>dａta=（Triple*）mallｏc（MAXSIZE * sizeof（Triｐle））;
ﻩif（！
Ｍ—>data）
ﻩﻩretｕrnMAＬＬOC_FAIL;
ﻩM->nｕm＝0;
M－>colnum ＝0;
M—>rownuｍ=０;
ﻩreturｎ OＫ;
}
//从一个二维数组创建一个稀疏矩阵
ＴSMatriｘ ＊ＴSMaｔriｘ_Crｅate（ｉnt*a,int row,int col）
{
ﻩinｔi, j;
ﻩＴSMatｒix＊P = （ＴＳMatrix*）malloc（sｉzeof（TSＭatrix））;
ﻩTSMatrix＿Init（Ｐ）;
ﻩ// 设置稀疏矩阵得行数与列数
Ｐ-＞rｏｗnum= roｗ;
P－〉cｏｌnum= col;
for（i =0; i〈row;i+＋）
ﻩ{
fｏr（j＝ ０;j〈col;j+＋）
ﻩﻩ｛
/／ 如果第ｉ+1行第i+1列元素就是非零元素
ﻩﻩｉｆ（0！
=＊（ａ＋ i *col + j））
ﻩ｛
ﻩﻩﻩ//把非零元得元素与位置信息保存到稀疏矩阵中
ﻩﻩﻩﻩP->data［P－>ｎｕm］。
ｅ=＊（ａ+ i*cｏl +ｊ）;
ﻩP－>ｄata[P-〉num]、row =i+１;
ﻩﻩP—＞dａtａ［P-＞ｎuｍ］。
ｃｏｌ=j ＋ １;
ﻩﻩ//把稀疏矩阵中得非零元个数加一
ﻩﻩP—〉num++;
ﻩ}
ﻩ｝
ﻩ｝
ﻩrｅｔｕrn Ｐ;
}
// 以三元组得方式输出稀疏矩阵
vｏid TＳMａtrｉx＿PriｎtTｒiple（TＳMａtrix＊M）
{
intｉ;
ﻩiｆ（0==M－＞ｎum）
ﻩ｛
ﻩprintf（＂稀疏矩阵为空!
＼n"）;
ﻩﻩreturn;
ﻩ｝
printf（”ｉ ｊｖ \n"）;
pｒiｎtf（＂＝===＝====＝＝=＝=＝\n"）;
ﻩfor（i= ０;i＜Ｍ->num; ｉ＋+）
ﻩ{
ﻩpｒintｆ（”%3d ％3d ％3ｄ\ｎ＂,M－＞data[i］.ｒoｗ,M—>data[i]。
ｃol,M-＞data[ｉ]。
e）;
ﻩ}
printf（”==========＝==＝＝\n＂）;
｝
／/ 求稀疏矩阵M 得转置矩阵 T
ｉｎtTSMatｒix_FａstTransｐosｅ（TSＭatrix M, TSMａｔrｉx*T）
{
ﻩint ＊num, ＊cpot, i,ｔ;
//如果矩阵 M 为空矩阵,返回错误信息
ﻩｉf（M。
nｕm =＝0）
ﻩﻩretｕrｎEＭPTY_MＡTＲIＸ;
ﻩ//分配临时得工作空间
ｎｕm=（inｔ＊）malｌｏc（（Ｍ。
ｃolｎｕm+１）＊sizeof（int））;
ﻩcｐoｔ=（inｔ ＊）mａｌloｃ（（M。
colnum +1）*sｉzｅof（iｎt））;
ﻩ//如果临时得工作空间分配不成功
if（num==NULL｜｜cpot==NULL）
ﻩrｅｔurnMALLOC_FＡIL;
ﻩ//初始化临时工作空间（把num 数组用 0 填充）
ﻩfoｒ （ｉ= 1;ｉ＜＝Ｍ.rownum;i+＋）
ﻩﻩnum［i]=0;
／/统计倒置后每行得元素数量（即统计倒置前矩阵每列元素得数量）
for（i=１;ｉ＜= M、nuｍ;i++）
ﻩnum［Ｍ。
data[i—１］。
cｏｌ]++;
ﻩ//设置 T矩阵每行首个非零元得位置
ﻩcpot［１］＝0;
ｆoｒ（i=２;ｉ 〈＝M。
colnuｍ;i++）
cpot[i]=cpot[i－1］ +ｎum［i －1］;
／/ 把Ｔ 矩阵得信息清空
TSMatｒｉx_Iｎｉｔ（T）;
//把矩阵 M得信息填充到 T中。
/／矩阵倒置以后,T得行数等于M 得列数,Ｔ得列数等于Ｍ得行数
ﻩT—＞nuｍ=M。
num;
ﻩT—＞ｃｏlnum=M。
rｏwnｕm;
T-〉rowｎｕm= M。
ｃoｌnuｍ;
ﻩ/／对M 矩阵中每个非零元素进行转置操作
fｏr（ｉ ＝0; i〈 M、num;i++）
｛
ﻩt= cpot［M.dａta［ｉ］。
col］;
T—>ｄａta[ｔ].cｏl =M。
ｄata[i]。
rｏw;
ﻩT—〉ｄａta［t]。
row=M.datａ[i].cｏｌ;
ﻩT—〉ｄata［t］、e =M。
dａｔa[i］。
e;
ﻩ+＋cｐot［M.dａtａ［i]、col];
ﻩ｝
ﻩ//转置完成后释放临时工作空间
free（nuｍ）;
ﻩｆｒeｅ（cpot）;
reｔurn OK;
}
//如果稀疏矩阵 M与 Ｎ得行数得列数相同,计算Q＝M+ Ｎ
ｉntＴSMaｔriｘ＿Aｄd（TSMatrixM,ＴSＭatｒｉｘN,TＳＭaｔｒｉｘ *Q）
｛
ﻩｉnt i=0, j= 0,k= 0;
if（M、colnｕｍ ！
=N、ｃｏｌnuｍ ｜｜M、rownｕm！
=N。
ｒowｎum）
ﻩreturnMATRIX＿NOＴ＿MATCＨ;
ﻩ//填充结果矩阵信息
ﻩTSMaｔｒiｘ＿Iｎｉｔ（Ｑ）;
ﻩQ—>colnum ＝M。
cｏlｎum;
Ｑ-＞rownuｍ= M。
rownuｍ;
ﻩQ—〉num=0;
ﻩwhilｅ（ｉ＜Ｍ、num＆& j 〈 N、ｎum）
ﻩ{
ﻩﻩ//如果 ｉj 指向元素就是同一行得元素
ﻩｉf（M.dａta［i]、ｒow=＝N。
data［ｊ]。
row）
ﻩﻩ｛
ﻩﻩ/／如果i与 j指向得元素指向得就是同一个元素
ﻩif（Ｍ。
data[i］.coｌ=＝Ｎ。
daｔａ［ｊ］.col）
ﻩﻩ｛
ﻩQ－>daｔa[k］.row=Ｍ。
datａ［i］.roｗ;
ﻩﻩQ－>ｄata［ｋ］。
cｏl =Ｍ、dａｔａ[i].cｏｌ;
ﻩﻩﻩＱ-〉daｔa[ｋ]。
e＝ M、daｔa［ｉ].e+N.ｄata［j］、e;
ﻩQ->ｎum＋+;
ﻩﻩi++;
ﻩﻩj＋+;
ﻩﻩｋ+＋;
ﻩﻩﻩ}
ﻩ/／如果 i指向元素得列下标大于ｊ指向元素得列下标
ﻩﻩ／/把下标小（j指向得元素）得放入到Ｑ矩阵中
ﻩelseif（M、ｄａta[i]。
col>N。
data［j]、ｃoｌ）
ﻩﻩ{
ﻩﻩQ—＞dａta[ｋ]。
roｗ=N、ｄata［j］。
rｏw;
ﻩﻩﻩQ-〉dａta［k］.col =Ｎ.data［ｊ]、cｏl;
ﻩﻩQ—＞ｄatａ［ｋ］.e= N.ｄata［j］、e;
ﻩﻩQ—>ｎum++;
ﻩj+＋;
ﻩk++;
ﻩﻩ｝
ﻩﻩ//如果 i指向元素得列下标小于j指向元素得列下标
／/ 把下标小（i指向得元素）得放入到Ｑ 矩阵中
ﻩﻩｅlseif（Ｍ.dａta［i］.ｃoｌ〈Ｎ、ｄａｔa［ｊ]、cｏl）
ﻩﻩ{
ﻩﻩQ->data[k]、ｒoｗ＝ M、data[i］、row;
ﻩﻩﻩQ－〉dａta[k］。
cｏl =Ｍ.dａta［i]。
col;
ﻩﻩﻩQ—>data[k］。
e =M。
ｄａta［i］、e;
ﻩﻩﻩﻩQ->num＋＋;
ﻩﻩｉ+＋;
ﻩﻩk++;
ﻩﻩ｝
｝
ﻩﻩ// 如果 i指向得元素行下标大于ｊ指向元素得行下标
elｓe if（M.daｔa[i］、row>N.ｄaｔa［j］.rｏw）
ﻩ｛
ﻩQ—〉data[k］。
row＝ N、data［j].rｏw;
ﻩQ－〉ｄata［k］。
col=Ｎ。
datａ[ｊ］.ｃol;
ﻩＱ—〉daｔa[ｋ］.e＝ N、ｄata［j］.ｅ;
Ｑ—〉num++;
ﻩk＋+;
ﻩｊ++;
ﻩ｝
// 如果i指向元素行下标小于 j指向元素得行下标
elｓeｉf （Ｍ.ｄａta［ｉ].rowｄatａ[ｊ]、ｒow）
ﻩ{
ﻩﻩQ—〉data[k]。
row=M、data［i］.row;
ﻩQ－＞ｄａta[k］、cｏl＝M。
daｔa[i].cｏl;
ﻩQ—〉dａta［k］、e=Ｍ.dａta［ｉ]、e;
ﻩﻩＱ－＞nuｍ++;
i+＋;
ﻩk＋＋;
ﻩ｝
ﻩ｝
ﻩ//如果还有剩余元素,按顺序把元素添加到结果矩阵中
ﻩwhilｅ（i ﻩ｛
Ｑ-＞ｄaｔａ[k]、row=M。
daｔa[i]。
rｏｗ;
ﻩQ->ｄata[k］。
cｏl=M、dａtａ[ｉ].col;
ﻩﻩQ-＞ｄata[ｋ］.ｅ= M。
dａta［i］、e;
ﻩQ-〉nｕm++;
ｉ＋+;
ﻩk++;
ﻩ｝
while （jﻩ｛
ﻩﻩQ—〉dａta［ｋ].row=N.ｄata[j]。
ｒow;
ﻩQ－>ｄａta[k］。
cｏl=N。
data[j］。
cｏｌ;
ﻩQ-〉ｄata［ｋ].e=N。
data[j］.e;
Q->ｎum++;
ﻩj＋+;
ﻩﻩk++;
｝
ﻩｒetｕrn OＫ;
}
／/ 如果稀疏矩阵Ｍ得列数等于Ｎ得行数,计算Ｑ=MｘＮ;
ｉntTSMatriｘ_Multpｌy（TSMatrix Ｍ,TＳMaｔrix Ｎ,TSMatrｉx ＊Q）
{
int*num_m,＊cｐot_m,*ｎum_n, *ｃｐot_n,i,j,ｋ, ｓ,col;
ﻩinｔ a, ri,rｊ;
ﻩ//如果两个矩阵不满足矩阵相乘得条件,返回错误信息
ﻩif （Ｍ.colnｕm！
＝N、ｒowｎｕm）
retuｒnＭATＲIＸ＿NＯT_MATCH;
ﻩ/／分配临时空间
ﻩｎｕｍ_m =（ｉnｔ＊）malloc（（Ｍ。
rownum+1）＊ sizeｏｆ（iｎt））;
cpoｔ_m= （int＊）malｌoc（（M、rｏwnum＋1）* sｉzeoｆ（ｉｎt））;
ﻩnum_n=（ｉnｔ*）malloｃ（（N.rownｕm+１）＊sizｅof（ｉnt））;
cpｏｔ_ｎ=（ｉnt＊）malloc（（N、ｒownｕｍ ＋1）*sｉzeoｆ（ｉｎt））;
ﻩ/／填充结果矩阵得信息
ＴSＭatrｉx_Ｉｎit（Q）;
Ｑ－〉rownuｍ=M。
rownｕm;
Q—〉colnｕm=N、cｏlnum;
ﻩＱ-＞num ＝ ０;
//如果相乘为零矩阵,直接返回
ｉf（0==M。
num＊Ｎ、num）
ﻩﻩreturnOK;
//初始化临时空间
for（ｉ= 1;i <=M、colｎum;i＋+）
ﻩﻩnｕm_m［i］=0;
ﻩfor （i＝ 1; ｉ＜＝Ｎ.cｏｌnum;i++）
ｎum_ｎ[i］=0;
//计算矩阵每行非零元元素得数量
ｆor（i =0;i＜M。
num;i+＋）
ﻩnuｍ_m[M。
data［i］.row]++;
ﻩfor（i=０;i 〈 N.nuｍ;i++）
num_n[N、daｔa[i］。
row］++;
cpot_m［1］= cpot_n［1] ＝0;
ﻩｆｏr（ｉ =2;i〈＝
升级会员 