数据结构 稀疏矩阵的基本操作

#include<iostream>
using namespace std;

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef int ElemType;
typedef int Status;

//稀疏矩阵的三元组顺序表存储表示
#define MAXSIZE 100  //假设非零元个数的最大值为100
#define MAXRC 20
typedef struct{
int i, j; //该非零元的行下标和列下标
ElemType e;
}Triple;
typedef struct{
Triple data[MAXSIZE + 1]; //非零元三元组表，data[0]未用
int  rpos[MAXRC + 1];//每行第一个非零元素在data数组中的位置
int mu, nu, tu;            //矩阵的行数、列数和非零元个数
}TSMatrix;

//基本操作
Status CreateMatrix(TSMatrix &M)
{//创建稀疏矩阵M
int i,j;
for (i = 1; i<MAXRC + 1; i++)
M.rpos[i] = 0;
cout<< "请输入矩阵的行数，列数，非零元个数:" << endl;
cin >> M.mu >> M.nu >> M.tu;

for (i = 1; i <= M.tu; i++)
{
cout << "请按行序顺序输入第i个非零元素所在的行，列，元素值：" << endl;
cin >> M.data[i].i >> M.data[i].j >> M.data[i].e;
}
for (i = 1, j = 1; i <= M.mu; i++)
{
M.rpos[i] = j;
while (M.data[j].i <= i&&j <= M.tu)
j++;
}
return OK;
}
Status DestroySMatrix(TSMatrix &M)
{
M.mu = 0;
M.nu = 0;
M.tu = 0;
return OK;
}

void PrintSMatrix(TSMatrix &M)
{
int i, j, k = 1;//非零元计数器，初值为1
Triple *p = M.data + 1;//p指向M的第一个非零元素
for (i = 1; i <= M.mu; i++)
{
for (j = 1; j <= M.nu; j++)
{
if (k <= M.tu&&p->i == i&&p->j == j)//p指向非零元，且p所指元素为当前循环在处理的元素
{
cout << p->e << "  ";
p++;
k++;
}
else//p所指元素不是当前循环在处理的元素
{
cout << 0 << "  ";
}
}
cout << endl;
}
}

void CopySMatrix(TSMatrix M, TSMatrix &T)
{//M复制得T
T = M;
}

Status comp(int c1, int c2)
{
if (c1 < c2)
return -1;
else if (c1 == c2)
return 0;
else
return 1;
}

Status AddSMatrix(TSMatrix M, TSMatrix N, TSMatrix &Q)
{

int m = 1, n = 1, q = 0;
if (M.mu != N.mu || M.nu != N.nu)
return ERROR;
Q.mu = M.mu;
Q.nu = M.nu;
while (m <= M.tu&&n <= N.tu)
{
switch (comp(M.data[m].i, N.data
.i))
{
case -1:Q.data[++q] = M.data[m++];
break;
case 0:switch (comp(M.data[m].j, N.data
.j))
{
case -1:Q.data[++q] = M.data[m++];
break;
case 0:Q.data[++q] = M.data[m++];
Q.data[q].e += N.data[n++].e;
if (Q.data[q].e == 0)
q--;
break;
case 1:Q.data[++q] = N.data[n++];
}
break;
case 1:Q.data[++q] = N.data[n++];
}
}
while (m <= M.tu)
Q.data[++q] = M.data[m++];
while (n <= N.tu)
Q.data[++q] = N.data[n++];
if (q > MAXSIZE)
return ERROR;
Q.tu = q;
return OK;
}

Status TranspopseSMatrix(TSMatrix M, TSMatrix &T)
{
//采用三元组表存储表示，求稀疏矩阵M的转置矩阵T
int p, q = 1, col; //q指示转置矩阵T的当前元素
T.mu = M.nu;
T.nu = T.mu;
T.tu = M.tu;
if (T.tu)
{
for (col = 1; col < M.nu; ++col)
for (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;
}
}
}
return OK;
}

Status SubtSMatrix(TSMatrix M, TSMatrix N, TSMatrix &Q)
{
int i;
if (M.mu != N.mu || M.nu != N.nu)
return ERROR;
for (i = 1; i <= N.tu; i++)
N.data[i].e *= -1;
AddSMatrix(M, N, Q); //Q=M+(-N)
return OK;
}

Status MultSMatrix(TSMatrix M, TSMatrix N, TSMatrix &Q)
{//求稀疏矩阵Q=M*N
int arow, brow, p, q, ccol, ctemp[MAXRC + 1], t, tp;
if (M.nu != N.mu)
return ERROR;
Q.mu = M.mu;
Q.nu = N.nu;
Q.tu = 0;
if (M.tu*N.tu!=0)//Q是非零矩阵
{
for (arow =1; arow <= M.mu; arow++)//从M的第一行开始，到最后一行，arow是M的当前行
{
for (ccol = 1; ccol <= N.nu; ccol++)//从Q的第一列到最后一列
ctemp[ccol] = 0;  //Q的当前行的各列元素累加器清零
Q.rpos[arow] = Q.tu + 1;
if (arow < M.mu)
tp = M.rpos[arow + 1];
else
tp = M.tu + 1;
for (p = M.rpos[arow]; p < tp; p++)
{
brow = M.data[p].j;
if (brow < N.mu)
t = N.rpos[brow + 1];
else
t = N.tu + 1;
for (q = N.rpos[brow]; q < t; q++)
{
ccol = N.data[q].j;
ctemp[ccol] += M.data[p].e*N.data[q].e;
}
}
for (ccol = 1; ccol <= Q.nu; ccol++)
if (ctemp[ccol])
{
if (++Q.tu>MAXSIZE)
return ERROR;
Q.data[Q.tu].i = arow;
Q.data[Q.tu].j = ccol;
Q.data[Q.tu].e = ctemp[ccol];
}
}
}
return OK;
}

int main()
{

TSMatrix A, B, C, D, T;
cout << "创建稀疏矩阵A：" << endl;
CreateMatrix(A);
PrintSMatrix(A);
cout << "输出A的转置矩阵T：" << endl;
TranspopseSMatrix(A, T);
PrintSMatrix(T);
cout << "复制矩阵A得B，输出B：" << endl;
CopySMatrix(A, B);
cout << "输出矩阵B：" << endl;
PrintSMatrix(B);
cout << "输入矩阵C：" << endl;
CreateMatrix(C);
PrintSMatrix(C);
cout << "输出矩阵A和矩阵C的和：" << endl;
AddSMatrix(A, C, D);
PrintSMatrix(D);
cout << "输出矩阵A和矩阵C的差：" << endl;
SubtSMatrix(A, C, D);
PrintSMatrix(D);
DestroySMatrix(A);
DestroySMatrix(B);
DestroySMatrix(C);
cout << "创建稀疏矩阵A：" << endl;
CreateMatrix(A);
PrintSMatrix(A);
cout << "创建稀疏矩阵B：" << endl;
CreateMatrix(B);
PrintSMatrix(B);
cout << "输出矩阵A和B的乘积C:" << endl;
MultSMatrix(A, B, C);
PrintSMatrix(C);
return 0;
}