void main()
{
TSMatrix A, B;
printf("创建矩阵A: ");
CreateSMatrix(&A);
PrintSMatrix(A);
FastTransposeSMatrix(A, &B);
printf("矩阵B(A的快速转置): ");
PrintSMatrix(B);
DestroySMatrix(&A);
DestroySMatrix(&B);
}
void SubtSMatrix(CrossList M,CrossList N,CrossList *Q)
{ /* 初始条件：稀疏矩阵M与N的行数和列数对应相等。操作结果：求稀疏矩阵的差Q=M-N */
int i;
OLink pq,pm,pn;
if(M.mu!=N.mu||M.nu!=N.nu)
{
printf("两个矩阵不是同类型的,不能相减\n");
exit(OVERFLOW);
}
(*Q).mu=M.mu; /* 初始化Q矩阵 */
(*Q).nu=M.nu;
(*Q).tu=0; /* Q矩阵元素个数的初值为0 */
InitSMatrixList(Q); /* 初始化Q的表头指针向量 */
for(i=1;i<=M.mu;i++) /* 按行的顺序相减 */
{
pm=M.rhead[i]; /* pm指向矩阵M的第i行的第1个结点 */
pn=N.rhead[i]; /* pn指向矩阵N的第i行的第1个结点 */
while(pm&&pn) /* pm和pn均不空 */
{
pq=(OLink)malloc(sizeof(OLNode)); /* 生成矩阵Q的结点 */
switch(comp(pm->j,pn->j))
{
case -1: *pq=*pm; /* M的列<N的列，将矩阵M的当前元素值赋给pq */
InsertAscend(Q,pq); /* 将结点pq按行列值升序插到矩阵Q中 */
pm=pm->right; /* 指针向后移 */
break;
case 0: *pq=*pm; /* M、N矩阵的列相等，元素值相减 */
pq->e-=pn->e;
if(pq->e!=0) /* 差为非零元素 */
InsertAscend(Q,pq); /* 将结点pq按行列值升序插到矩阵Q中 */
else
free(pq); /* 释放结点 */
pm=pm->right; /* 指针向后移 */
pn=pn->right;
break;
case 1: *pq=*pn; /* M的列>N的列，将矩阵N的当前元素值赋给pq */
pq->e*=-1; /* 求反 */
InsertAscend(Q,pq); /* 将结点pq按行列值升序插到矩阵Q中 */
pn=pn->right; /* 指针向后移 */
}
}
while(pm) /* pn=NULL */
{
pq=(OLink)malloc(sizeof(OLNode)); /* 生成矩阵Q的结点 */
*pq=*pm; /* M的列<N的列，将矩阵M的当前元素值赋给pq */
InsertAscend(Q,pq); /* 将结点pq按行列值升序插到矩阵Q中 */
pm=pm->right; /* 指针向后移 */
}
while(pn) /* pm=NULL */
{
pq=(OLink)malloc(sizeof(OLNode)); /* 生成矩阵Q的结点 */
*pq=*pn; /* M的列>N的列，将矩阵N的当前元素值赋给pq */
pq->e*=-1; /* 求反 */
InsertAscend(Q,pq); /* 将结点pq按行列值升序插到矩阵Q中 */
pn=pn->right; /* 指针向后移 */
}
}
if((*Q).tu==0) /* Q矩阵元素个数为0 */
DestroySMatrix(Q); /* 销毁矩阵Q */
}
/* main5-3.c 检验bo5-3.c的主程序(与main5-2.c很相像) */
#include"c1.h"
typedef int ElemType;
#include"c5-3.h" /* 此行与main5-2.c不同 */
#include"bo5-3.c" /* 此行与main5-2.c不同 */
void main()
{
RLSMatrix A,B,C; /* 此行与main5-2.c不同 */
printf("创建矩阵A: ");
CreateSMatrix(&A);
PrintSMatrix(A);
printf("由矩阵A复制矩阵B:\n");
CopySMatrix(A,&B);
PrintSMatrix1(B);
DestroySMatrix(&B);
printf("销毁矩阵B后:\n");
PrintSMatrix1(B);
printf("创建矩阵B2:(与矩阵A的行、列数相同，行、列分别为%d,%d)\n",A.mu,A.nu);
CreateSMatrix(&B);
PrintSMatrix1(B);
AddSMatrix(A,B,&C);
printf("矩阵C1(A+B):\n");
PrintSMatrix1(C);
SubtSMatrix(A,B,&C);
printf("矩阵C2(A-B):\n");
PrintSMatrix1(C);
TransposeSMatrix(A,&C);
printf("矩阵C3(A的转置):\n");
PrintSMatrix1(C);
printf("创建矩阵A2:");
CreateSMatrix(&A);
PrintSMatrix1(A);
printf("创建矩阵B3:(行数应与矩阵A2的列数相同=%d)\n",A.nu);
CreateSMatrix(&B);
PrintSMatrix1(B);
MultSMatrix(A,B,&C);
printf("矩阵C5(A×B):\n");
PrintSMatrix1(C);
}
void main()
{
CrossList A,B,C;
InitSMatrix(A); // CrossList类型的变量在初次使用之前必须初始化
InitSMatrix(B);
printf("创建矩阵A: ");
CreateSMatrix(A);
PrintSMatrix(A);
printf("由矩阵A复制矩阵B: ");
CopySMatrix(A,B);
PrintSMatrix(B);
DestroySMatrix(B); // CrossList类型的变量在再次使用之前必须先销毁
printf("销毁矩阵B后,矩阵B为:\n");
PrintSMatrix1(B);
printf("创建矩阵B2:(与矩阵A的行、列数相同，行、列分别为%d,%d)\n",A.mu,A.nu);
CreateSMatrix(B);
PrintSMatrix1(B);
printf("矩阵C1(A+B):\n");
AddSMatrix(A,B,C);
PrintSMatrix1(C);
DestroySMatrix(C);
printf("矩阵C2(A-B):\n");
SubtSMatrix(A,B,C);
PrintSMatrix1(C);
DestroySMatrix(C);
printf("矩阵C3(A的转置):\n");
TransposeSMatrix(A,C);
PrintSMatrix1(C);
DestroySMatrix(A);
DestroySMatrix(B);
DestroySMatrix(C);
printf("创建矩阵A2: ");
CreateSMatrix(A);
PrintSMatrix1(A);
printf("创建矩阵B3:(行数应与矩阵A2的列数相同=%d)\n",A.nu);
CreateSMatrix(B);
PrintSMatrix1(B);
printf("矩阵C5(A×B):\n");
MultSMatrix(A,B,C);
PrintSMatrix1(C);
DestroySMatrix(A);
DestroySMatrix(B);
DestroySMatrix(C);
}
void CreateSMatrix(CrossList *M)
{ /* 创建稀疏矩阵M，采用十字链表存储表示。算法5.4改 */
int i,k;
OLink p;
if((*M).rhead)
DestroySMatrix(M);
printf("请输入稀疏矩阵的行数 列数 非零元个数: ");
scanf("%d%d%d",&(*M).mu,&(*M).nu,&i);
InitSMatrixList(M); /* 初始化M的表头指针向量 */
printf("请按任意次序输入%d个非零元的行 列 元素值:\n",(*M).tu);
for(k=0;k<i;k++)
{
p=(OLink)malloc(sizeof(OLNode)); /* 生成结点 */
if(!p)
exit(OVERFLOW);
scanf("%d%d%d",&p->i,&p->j,&p->e); /* 给结点的3个成员赋值 */
InsertAscend(M,p); /* 将结点p按行列值升序插到矩阵M中 */
}
}
void MultSMatrix(CrossList M,CrossList N,CrossList *Q)
{ /* 初始条件：稀疏矩阵M的列数等于N的行数。操作结果：求稀疏矩阵乘积Q=M×N */
int i,j,e;
OLink pq,pm,pn;
InitSMatrix(Q);
(*Q).mu=M.mu;
(*Q).nu=N.nu;
(*Q).tu=0;
InitSMatrixList(Q); /* 初始化Q的表头指针向量 */
for(i=1;i<=(*Q).mu;i++)
for(j=1;j<=(*Q).nu;j++)
{
pm=M.rhead[i];
pn=N.chead[j];
e=0;
while(pm&&pn)
switch(comp(pn->i,pm->j))
{
case -1: pn=pn->down; /* 列指针后移 */
break;
case 0: e+=pm->e*pn->e; /* 乘积累加 */
pn=pn->down; /* 行列指针均后移 */
pm=pm->right;
break;
case 1: pm=pm->right; /* 行指针后移 */
}
if(e) /* 值不为0 */
{
pq=(OLink)malloc(sizeof(OLNode)); /* 生成结点 */
if(!pq) /* 生成结点失败 */
exit(OVERFLOW);
pq->i=i; /* 给结点赋值 */
pq->j=j;
pq->e=e;
InsertAscend(Q,pq); /* 将结点pq按行列值升序插到矩阵Q中 */
}
}
if((*Q).tu==0) /* Q矩阵元素个数为0 */
DestroySMatrix(Q); /* 销毁矩阵Q */
}
void CopySMatrix(CrossList M,CrossList *T)
{ /* 初始条件：稀疏矩阵M存在。操作结果：由稀疏矩阵M复制得到T */
int i;
OLink p,q;
if((*T).rhead) /* 矩阵T存在 */
DestroySMatrix(T);
(*T).mu=M.mu;
(*T).nu=M.nu;
InitSMatrixList(T); /* 初始化T的表头指针向量 */
for(i=1;i<=M.mu;i++) /* 按行复制 */
{
p=M.rhead[i]; /* p指向i行链表头 */
while(p) /* 没到行尾 */
{
q=(OLNode*)malloc(sizeof(OLNode)); /* 生成结点q */
if(!q)
exit(OVERFLOW);
*q=*p; /* 给结点q赋值 */
InsertAscend(T,q); /* 将结点q按行列值升序插到矩阵T中 */
p=p->right;
}
}
}
