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

#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[n].i))
		{
		case -1:Q.data[++q] = M.data[m++];
			break;
		case 0:switch (comp(M.data[m].j, N.data[n].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;
}