三元组矩阵的基本操作——加、减、矩阵乘、转置

#include<stdio.h>
#include<stdlib.h>

#define OK 1
#define ERROR 0

typedef int ElemType, Status;

#define MAXSIZE 256

typedef struct
{
	int i, j;    //数据所在的行、列值
	ElemType v;    //数据元素值
}Triple;

typedef struct
{
	Triple arr[MAXSIZE];    //非零元素的三元组
	int Rows, Cols, Nums;    //矩阵的行数、列数、非零元素个数
}SqSMatrix;

Status CtreateSMatrix(SqSMatrix& M)    //矩阵的创建
{
	printf("行数:");
	scanf_s("%d", &M.Rows);
	printf("列数:");
	scanf_s("%d", &M.Cols);
	printf("非零元个数:");
	scanf_s("%d", &M.Nums);
	printf("按行优先依次输入元素的行值、列值、数值:\n");
	int i = 0;
	while (i < M.Nums)
	{
		scanf_s("%d%d%d", &M.arr[i].i, &M.arr[i].j, &M.arr[i].v);
		i++;
	}
	return OK;
}

Status DestroySMatrix(SqSMatrix& M)    //矩阵的销毁
{
	M.Cols = 0;
	M.Nums = 0;
	M.Rows = 0;
	return OK;
}

Status PrintSMatrix(SqSMatrix M)    //矩阵的输出
{
	if (M.Rows == 0) return ERROR;
	int cnt = 0;
	for (int i = 0; i < M.Rows; i++)
	{
		for (int j = 0; j < M.Cols; j++)
		{
			if (cnt < M.Nums && M.arr[cnt].i == i && M.arr[cnt].j == j)
			{
				printf("%d  ", M.arr[cnt].v);
				cnt++;
			}
			printf("0  ");
		}
		printf("\n");
	}
	return OK;
}

Status CopySMatrix(SqSMatrix M, SqSMatrix &T)    //矩阵的拷贝
{
	if (M.Rows == 0) return ERROR;
	T.Nums = M.Nums;
	T.Rows = M.Rows;
	T.Cols = M.Cols;
	int cnt = 0;
	while (cnt < M.Nums)
	{
		T.arr[cnt].i = M.arr[cnt].i;
		T.arr[cnt].j = M.arr[cnt].j;
		T.arr[cnt].v = M.arr[cnt].v;
		cnt++;
	}
	return OK;
}

Status AddSMatrix(SqSMatrix M, SqSMatrix N, SqSMatrix& Q)    //矩阵相加
{
	if (M.Cols != N.Cols || M.Rows != N.Rows) return ERROR;
	Q.Cols = M.Cols;
	Q.Rows = M.Rows;
	int mi = 0;
	int ni = 0;
	int i = 0;
	while (mi != M.Nums && ni != N.Nums)
	{
		if (M.arr[mi].i == N.arr[ni].i && M.arr[mi].j == N.arr[ni].j)
		{
			Q.arr[i].i = M.arr[mi].i;
			Q.arr[i].j = M.arr[mi].j;
			Q.arr[i].v = M.arr[mi].v + N.arr[ni].v;
			i++;
			mi++;
			ni++;
		}
		if (M.arr[mi].i < N.arr[ni].i)
		{
			Q.arr[i].i = M.arr[mi].i;
			Q.arr[i].j = M.arr[mi].j;
			Q.arr[i].v = M.arr[mi].v;
			i++;
			mi++;
		}
		if (M.arr[mi].i == N.arr[ni].i && M.arr[mi].j < N.arr[ni].j)
		{
			Q.arr[i].i = M.arr[mi].i;
			Q.arr[i].j = M.arr[mi].j;
			Q.arr[i].v = M.arr[mi].v;
			i++;
			mi++;
		}
		else
		{
			Q.arr[i].i = N.arr[ni].i;
			Q.arr[i].j = N.arr[ni].j;
			Q.arr[i].v = N.arr[ni].v;
			i++;
			ni++;
		}
	}
	while (mi < M.Nums)
	{
		Q.arr[i].i = M.arr[mi].i;
		Q.arr[i].i = M.arr[mi].j;
		Q.arr[i].v = M.arr[mi].v;
		i++;
		mi++;
	}
	while (ni < N.Nums)
	{
		Q.arr[i].i = N.arr[ni].i;
		Q.arr[i].j = N.arr[ni].j;
		Q.arr[i].v = N.arr[ni].v;
		i++;
		ni++;
	}
	Q.Nums = i;
	return OK;
}

Status SubSMatrix(SqSMatrix M, SqSMatrix N, SqSMatrix& Q)    //矩阵相减
{
		if (M.Cols != N.Cols || M.Rows != N.Rows) return ERROR;
		Q.Cols = M.Cols;
		Q.Rows = M.Rows;
		int mi = 0;
		int ni = 0;
		int i = 0;
		while (mi != M.Nums && ni != N.Nums)
		{
			if (M.arr[mi].i == N.arr[ni].i && M.arr[mi].j == N.arr[ni].j)
			{
				Q.arr[i].i = M.arr[mi].i;
				Q.arr[i].j = M.arr[mi].j;
				Q.arr[i].v = M.arr[mi].v - N.arr[ni].v;
				i++;
				mi++;
				ni++;
			}
			if (M.arr[mi].i < N.arr[ni].i)
			{
				Q.arr[i].i = M.arr[mi].i;
				Q.arr[i].j = M.arr[mi].j;
				Q.arr[i].v = M.arr[mi].v;
				i++;
				mi++;
			}
			if (M.arr[mi].i == N.arr[ni].i && M.arr[mi].j < N.arr[ni].j)
			{
				Q.arr[i].i = M.arr[mi].i;
				Q.arr[i].j = M.arr[mi].j;
				Q.arr[i].v = M.arr[mi].v;
				i++;
				mi++;
			}
			else
			{
				Q.arr[i].i = N.arr[ni].i;
				Q.arr[i].j = N.arr[ni].j;
				Q.arr[i].v = -N.arr[ni].v;
				i++;
				ni++;
			}
		}
		while (mi < M.Nums)
		{
			Q.arr[i].i = M.arr[mi].i;
			Q.arr[i].i = M.arr[mi].j;
			Q.arr[i].v = M.arr[mi].v;
			i++;
			mi++;
		}
		while (ni < N.Nums)
		{
			Q.arr[i].i = N.arr[ni].i;
			Q.arr[i].j = N.arr[ni].j;
			Q.arr[i].v = -N.arr[ni].v;
			i++;
			ni++;
		}
		Q.Nums = i;
		return OK;
}

//三元组稀疏矩阵的转置方法——1.简单方法、2.列序遍历法、3.快速转置法

/*1.简单方法：
    把三元组表中行和列的内容互换，然后按照行号对新的三元组表中的各三元
组从小到大进行排序，就可以得到转置后的三元组表，排序算法采用经典的排序
算法，则时间复杂度为O(Nums*Nums)
*/

//2.列序遍历的转置算法
Status TransposeSMatrix(SqSMatrix A, SqSMatrix& B)
{
	//将稀疏矩阵A转置，结果放在稀疏矩阵B中
	B.Rows = A.Cols;    //B的行数等于A的列数
	B.Cols = A.Rows;    //B的列数等于A的行数
	B.Nums = A.Nums;    //B的非零元个数等于A的非零元个数

	if (A.Nums > 0)
	{
		int q = 0;
		int p = 0;
		for (int k = 0; k < A.Cols; k++)
		{
			for (p = 0; p < A.Nums; p++)
			{
				if (A.arr[p].j == k)
				{
					//若第p个三元组中元素的列号为k
					B.arr[q].i = A.arr[p].j;    //新三元组中的行号
					B.arr[q].j = A.arr[p].i;    //新三元组中的列号
					B.arr[q].v = A.arr[p].v;    //新三元组中的值
					q++;    //B.arr的当前位置增加1
				}
			}
		}
	}
	return OK;
}

//3.稀疏矩阵快速转置算法
Status FastTransposeSMatrix(SqSMatrix A, SqSMatrix& B)
{
	B.Rows = A.Cols;
	B.Cols = A.Rows;
	B.Nums = A.Nums;

	int rowStart[MAXSIZE];
	int rowNum[MAXSIZE];
	int k = 0;
	int p = 0;
	if (A.Nums > 0)
	{
		//第一步：统计A中每列非零元素个数
		for (k = 0; k < A.Cols; k++)    rowNum[k] = 0;    //rowNums数组的初始化
		for (p = 0; p < A.Nums; p++)    rowNum[A.arr[p].j]++;    //统计A中每列（即B中每行）非零元素个数
		//第二步：计算B中每行三元组的起始位置
		rowStart[0] = 0;
		for (k = 1; k < A.Cols; k++)
			rowStart[k] = rowStart[k - 1] + rowNum[k - 1];
		for (p = 0; p < A.Nums; p++)
		{
			int q = rowStart[A.arr[p].j];
			B.arr[q].i = A.arr[p].j;
			B.arr[q].j = A.arr[p].i;
			B.arr[q].v = A.arr[p].v;
			rowStart[A.arr[p].j]++;
		}
	}
	return OK;
}