有关稀疏矩阵(三元数组)的基本操作(C语言)

Marshal_A

于 2022-05-28 17:19:08 发布

阅读量4.2k

点赞数 15

分类专栏：数据结构与算法文章标签：矩阵线性代数数据结构

本文链接：https://blog.csdn.net/absorb2601078490/article/details/125016780

版权

数据结构与算法专栏收录该内容

7 篇文章 8 订阅

订阅专栏

本文只有代码，介绍了有关稀疏矩阵的基本操作。

已经过调试没有很大问题。
如有错误，还请批评指正。

一、稀疏矩阵的三元组顺序表存储表示：

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

#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);//创建稀疏矩阵CreateMatrix(&M)

Status DestroySMatrix(TSMatrix* M);//销毁稀疏矩阵DestroySMatrix(&M)

void PrintSMatrix(TSMatrix M);//输出稀疏矩阵PrintSMatrix(M)

void CopySMatrix(TSMatrix M, TSMatrix* T);//拷贝稀疏矩阵CopySMatrix(M, &T)

Status AddSMatrix(TSMatrix M, TSMatrix N, TSMatrix* Q);//矩阵相加AddSMatrix(M, N, &Q)

Status SubtSMatrix(TSMatrix M, TSMatrix N, TSMatrix* Q);//矩阵相减SubtSMatrix(M, N, &Q)

Status MultSMatrix(TSMatrix M, TSMatrix N, TSMatrix* Q);//矩阵相乘MultSMatrix(M, N, &Q)

Status TranspopseSMatrix(TSMatrix M, TSMatrix* T);//转置矩阵TranspopseSMatrix(M, &T)

Status comp(int c1, int c2);//比较两数大小comp(c1, c2)

1、创建稀疏矩阵：

/*---------------------------------------------------------------------------------------
功能：创建稀疏矩阵
参数：1、稀疏矩阵指针
输出：OK、ERROR
*/
//创建稀疏矩阵CreateMatrix(&M)
Status CreateMatrix(TSMatrix* M)
{
	int i, j;
	for (i = 1; i < MAXRC + 1; i++)
		M->rpos[i] = 0;
	printf("请输入矩阵的行数，列数，非零元个数:");
	scanf("%d%d%d", &M->mu, &M->nu, &M->tu);
	for (i = 1; i <= M->tu; i++)
	{
		printf("请按行序顺序输入第i个非零元素所在的行，列，元素值：");
		scanf("%d%d%d", &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;
}

2、销毁稀疏矩阵：

/*---------------------------------------------------------------------------------------
功能：销毁稀疏矩阵
参数：1、稀疏矩阵指针
输出：OK、ERROR
*/
//销毁稀疏矩阵DestroySMatrix(&M)
Status DestroySMatrix(TSMatrix* M)
{
	M->mu = M->nu = M->tu = 0;
	return OK;
}

3、输出稀疏矩阵：

/*---------------------------------------------------------------------------------------
功能：输出稀疏矩阵
参数：1、稀疏矩阵
输出：空
*/
//输出稀疏矩阵PrintSMatrix(M)
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所指元素为当前循环在处理的元素
			{
				printf("%3d ", p->e);
				p++;
				k++;
			}
			else//p所指元素不是当前循环在处理的元素
			{
				printf("%3d ", 0);
			}
		}
		printf("\n");
	}
}

4、拷贝稀疏矩阵：

/*---------------------------------------------------------------------------------------
功能：拷贝稀疏矩阵
参数：1、稀疏矩阵 2、稀疏矩阵指针
输出：空
*/
//拷贝稀疏矩阵CopySMatrix(M, &T)
void CopySMatrix(TSMatrix M, TSMatrix* T)
{
	*T = M;
}

5、矩阵相加：

/*---------------------------------------------------------------------------------------
功能：矩阵相加
参数：1、稀疏矩阵 2、稀疏矩阵 3、稀疏矩阵指针
输出：OK、ERROR
*/
//矩阵相加AddSMatrix(M, N, &Q)
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;
			}
			  break;
		case 1:
			Q->data[++q] = N.data[n++];
			break;
		}
	}
	while (m <= M.tu)//M矩阵剩余的三元数组加入Q中
	{
		Q->data[++q] = M.data[m++];
	}
	while (n <= N.tu)//N矩阵剩余的三元数组加入Q中
	{
		Q->data[++q] = N.data[n++];
	}
	if (q > MAXSIZE)//超过矩阵最大非零个数
	{
		return ERROR;
	}
	Q->tu = q;
	return OK;
}

6、矩阵相减：

/*---------------------------------------------------------------------------------------
功能：矩阵相减
参数：1、稀疏矩阵 2、稀疏矩阵 3、稀疏矩阵指针
输出：OK、ERROR
*/
//矩阵相减SubtSMatrix(M, N, &Q)
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)
	{
		N.data[i].e *= -1;
	}
	return AddSMatrix(M, N, Q); //Q=M+(-N);
}

7、矩阵相乘：

/*---------------------------------------------------------------------------------------
功能：矩阵相乘
参数：1、稀疏矩阵 2、稀疏矩阵 3、稀疏矩阵指针
输出：OK、ERROR
*/
//矩阵相乘MultSMatrix(M, N, &Q)
Status MultSMatrix(TSMatrix M, TSMatrix N, TSMatrix* Q)
{
	int arow, brow, p, q, ccol, ctemp[MAXRC + 1], t, tp;
	if (M.nu != N.mu)//M的行数与N的列数不等
	{
		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;
}

8、转置矩阵：

/*---------------------------------------------------------------------------------------
功能：转置矩阵
参数：1、稀疏矩阵 2、稀疏矩阵指针
输出：OK、ERROR
*/
//转置矩阵TranspopseSMatrix(M, &T)
Status TranspopseSMatrix(TSMatrix M, TSMatrix* T)
{
	int p = 0, q = 1, row = 0; //q指示转置矩阵T的当前元素
	T->mu = M.nu;//列变行
	T->nu = T->mu;//行变列
	T->tu = M.tu;//非零元个数相同
	for (row = 1; row < M.nu; ++row)
	{
		for (p = 1; p <= M.tu; ++p)
		{
			if (M.data[p].j == row)//交换行和列
			{
				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;
}

9、比较两数大小：

/*---------------------------------------------------------------------------------------
功能：比较两数大小
参数：1、整数 2、整数
输出：-1、0、1
*/
//比较两数大小comp(c1, c2)
Status comp(int c1, int c2)
{
	if (c1 < c2)
	{
		return -1;
	}
	else if (c1 == c2)
	{
		return 0;
	}
	else
	{
		return 1;
	}
}

三、测试主程序：

int main()
{
	TSMatrix A, B, C, D, T;
	printf("创建稀疏矩阵A：\n");
	CreateMatrix(&A);
	printf("输出矩阵A：\n");
	PrintSMatrix(A);

	printf("输出A的转置矩阵T：\n");
	TranspopseSMatrix(A, &T);
	PrintSMatrix(T);

	printf("复制矩阵A得B，输出B：\n");
	CopySMatrix(A, &B);
	PrintSMatrix(B);

	printf("输入矩阵C：\n");
	CreateMatrix(&C);
	PrintSMatrix(C);

	printf("输出矩阵A和矩阵C的和：\n");
	AddSMatrix(A, C, &D);
	PrintSMatrix(D);

	printf("输出矩阵A和矩阵C的差：\n");
	SubtSMatrix(A, C, &D);
	PrintSMatrix(D);

	DestroySMatrix(&A);
	DestroySMatrix(&B);
	DestroySMatrix(&C);

	printf("创建稀疏矩阵A：\n");
	CreateMatrix(&A);
	PrintSMatrix(A);
	printf("创建稀疏矩阵B：\n");
	CreateMatrix(&B);
	PrintSMatrix(B);
	printf("输出矩阵A和B的乘积C:\n");
	MultSMatrix(A, B, &C);
	PrintSMatrix(C);

	system("pause");
	return 0;
}