【任务书】

题目描述：

设计并实现稀疏矩阵的三元组存储结构，并完成如下操作。

1.  稀疏矩阵显示。
   1. 根据行列值，显示元素值。
   2. 矩阵加法。
   3. 矩阵减法。
   4. 矩阵乘法。

【代码如下：】

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
using namespace std;
#define MAXSIZE 100 //元素的个数最多为100个
#define N 30 //二维数组的列数最多为30

typedef struct
{
	int x,y;//该非零元素的行下标和列下标
	int e; //该非零元素的值
}Triple;

typedef struct
{
	Triple data[MAXSIZE]; //非零元素三元组顺序表
	int mu, nu, tu; //矩阵的行数，列数和非零元素的个数
}TS;

TS CreateTriple(int m, int n) //构造一个三元组顺序表存储矩阵
{
	TS T;
	int i = -1;
	cout<<"请按行序为主序依次输入矩阵的非零元素的行号，列号和元素值，每行输入一个元素的信息："<<endl;
	printf("注意行号不能超过%d,列号不能超过%d\n", m, n);
	cout<<"输入0 0 0时结束输入！"<<endl;
	do {
		i++;
		scanf("%d%d%d", &T.data[i].x, &T.data[i].y, &T.data[i].e);
	} while (T.data[i].x > 0 && T.data[i].x <= m && T.data[i].y > 0 && T.data[i].y <= n) ;
		T.mu = m;
		T.nu = n;
		T.tu = i;
		return T;
}


void TripleToArray(TS T, int A[][N], int m, int n)//三元组顺序表转换为二维数组
{
	int i,j;
	m = T.mu;
	n = T.nu;
	for (i=0; i<m; i++) //先设所有元素均为0
	for (j=0; j<n; j++)
		A[i][j] = 0;
	for (i=0; i<T.tu; i++)//把三元组顺序表中的元素写入二维数组
		A[T.data[i].x-1][T.data[i].y-1] = T.data[i].e;
} 


void PrintArray(int H[][N], int m, int n) //输出二维数组存储矩阵
{
	int i, j;
	for (i=0; i<m; i++)
	{
		for (j=0; j<n; j++)
		printf("%4d ", H[i][j]);
		printf("\n");
	}
}


int Value(TS M,int i,int j) //计算出矩阵M的i行j列处元素的值
{
	int k = 0;
	while (k < M.tu && M.data[k].x <= i) //因为是按行序排列，故不必扫描行号比i大的元素
	{
		if (M.data[k].x == i && M.data[k].y == j)
		return M.data[k].e;
		k++;
	}
	return 0;
}


TS TransposeSMatrix(TS M)//三元组顺序表 转置矩阵
{
	int k, i, col;
	TS T;
	T.mu = M.nu;
	T.nu = M.mu;
	T.tu = M.tu;
	if (T.tu > 0)
	{
		k = 0;
		for (col=1; col<=M.nu; col++) //按照T的行序（M的列序）为主序依次排列
		for (i=0; i<M.tu; i++)//扫描M的所有元素
		if (M.data[i].y == col)
		{
			T.data[k].x = M.data[i].y;
			T.data[k].y = M.data[i].x;
			T.data[k++].e = M.data[i].e;
		}
	}
	return T;
}


TS AddSMatrix(TS A, TS B) //三元组顺序表 矩阵相加
{
	TS C;
	int i=0, j=0, k=0; //i,j,k分别是A，B，C的下标，这些下标都是从0开始的
	while (i < A.tu && j < B.tu)//循环直到A，B 中有一个结束
	{
		if ((A.data[i].x < B.data[j].x) || ((A.data[i].x == B.data[j].x) && (A.data[i].y < B.data[j].y))) //将A的元素直接放入C中
		{
			C.data[k].x = A.data[i].x;
			C.data[k].y = A.data[i].y;
			C.data[k++].e = A.data[i++].e; 
		}
	else if ((A.data[i].x > B.data[j].x) || ((A.data[i].x == B.data[j].x) && (A.data[i].y > B.data[j].y))) //将B的元素直接放入C中
	{ 
		C.data[k].x = B.data[j].x;
		C.data[k].y = B.data[j].y;
		C.data[k++].e = B.data[j++].e;
	}
	else //二者相加
	{
		C.data[k].x = A.data[i].x;
		C.data[k].y = A.data[i].y;
		C.data[k].e = A.data[i++].e + B.data[j++].e;
		if (C.data[k].e != 0) //结果值不为0时放入C中
			k++;
		}
	}
	if (i == A.tu) //A结束，若B还有元素，则将B的元素直接放入C中
	{ 
		while (j < B.tu)
		{
			C.data[k].x = B.data[j].x;
			C.data[k].y = B.data[j].y;
			C.data[k++].e = B.data[j++].e;
		}
	} 
	else //B结束，若A还有元素，则将A的元素直接放入C中
	{ 
		while (i < A.tu)
		{
			C.data[k].x = A.data[i].x;
			C.data[k].y = A.data[i].y;
			C.data[k++].e = A.data[i++].e;
		}
	}
	C.mu = A.mu;
	C.nu = A.nu;
	C.tu = k;
	return C;
}

TS SubSMatrix(TS A, TS B) //三元组顺序表 矩阵相减
{
	TS C;
	int i=0, j=0, k=0; //i,j,k分别是A，B，C的下标，这些下标都是从0开始的
	while (i < A.tu && j < B.tu)//循环直到A，B 中有一个结束
	{
		if ((A.data[i].x < B.data[j].x) || ((A.data[i].x == B.data[j].x) && (A.data[i].y < B.data[j].y))) //将A的元素直接放入C中
		{
			C.data[k].x = A.data[i].x;
			C.data[k].y = A.data[i].y;
			C.data[k++].e = A.data[i++].e; 
		}
	else if ((A.data[i].x > B.data[j].x) || ((A.data[i].x == B.data[j].x) && (A.data[i].y > B.data[j].y))) //将B的元素直接放入C中
	{ 
		C.data[k].x = B.data[j].x;
		C.data[k].y = B.data[j].y;
		C.data[k++].e = B.data[j++].e;
	}
	else //二者相减
	{
		C.data[k].x = A.data[i].x;
		C.data[k].y = A.data[i].y;
		C.data[k].e = A.data[i++].e - B.data[j++].e;
		if (C.data[k].e != 0) //结果值不为0时放入C中
			k++;
		}
	}
	if (i == A.tu) //A结束，若B还有元素，则将B的元素直接放入C中
	{ 
		while (j < B.tu)
		{
			C.data[k].x = B.data[j].x;
			C.data[k].y = B.data[j].y;
			C.data[k++].e = B.data[j++].e;
		}
	} 
	else //B结束，若A还有元素，则将A的元素直接放入C中
	{ 
		while (i < A.tu)
		{
			C.data[k].x = A.data[i].x;
			C.data[k].y = A.data[i].y;
			C.data[k++].e = A.data[i++].e;
		}
	}
	C.mu = A.mu;
	C.nu = A.nu;
	C.tu = k;
	return C;
}

TS MultSMatrix(TS A, TS B)//三元组顺序表矩阵乘法
{
	TS C;
	int i, j, k,p, s;
	C.mu = A.mu;
	C.nu = B.nu;
	C.tu = 0;
	if (A.tu * B.tu != 0)
	{
		p = 0;
		for (i=1; i<=A.mu; i++)
		{
			for (j=1; j<=B.nu; j++)
			{
				s = 0;
				for (k=1; k<=A.nu; k++)
				s += Value(A,i,k) * Value(B,k,j);
				if (s != 0)
				{
					C.data[p].x = i;
					C.data[p].y = j;
					C.data[p++].e = s;
				}
			}
		}
		C.tu = p;
	}
	return C;
}

void Menu()
{
	cout<<"*********欢迎使用稀疏多项式菜单应用***********"<<endl;
	cout<<"*********0.显示行列式*************************"<<endl;
	cout<<"*********1.根据行列找到矩阵的值***************"<<endl;
	cout<<"*********2.矩阵的转置*************************"<<endl;
	cout<<"*********3.矩阵相加***************************"<<endl;
	cout<<"*********4.矩阵相减***************************"<<endl;
	cout<<"*********5.矩阵相乘***************************"<<endl;
	cout<<"*********6.一键输出两个矩阵相加相减相乘结果***"<<endl;
	cout<<"*********7.退出程序***************************"<<endl;
	cout<<"*********请选择功能:**************************"<<endl;
}

int main()
{
	int A[N][N],B[N][N],C[N][N]; //存储矩阵的二维数组
	TS Triple1, Triple2,Triple3; //三元组顺序表
	int m,n;
	cout<<"请输入你将要进行操作的矩阵的行列数："<<endl;
	cout<<"行: ";
	cin>>m;
	cout<<"列: ";
	cin>>n;
	int q;
	char ch;
	do{
		Menu();
		cin>>q;
		switch(q)
		{	
			case 0:
				Triple1 = CreateTriple(m, n); //构造一个三元组顺序表存储矩阵
				TripleToArray(Triple1, A, m, n);//三元组顺序表转换为二维数组
				PrintArray(A, m, n);//输出矩阵行列式
				break;
			case 1:
				Triple1 = CreateTriple(m, n); //构造一个三元组顺序表存储矩阵
				TripleToArray(Triple1, A, m, n);//三元组顺序表转换为二维数组
				PrintArray(A, m, n);//输出矩阵行列式
				int i,j;
				cout<<"请输入要查找的元素值的行列值"<<endl;
				cout<<"行：";
				cin>>i;
				cout<<"列：";
				cin>>j;
				cout<<Value(Triple1,i,j)<<endl;
				break;
			case 2:
				Triple1 = CreateTriple(m, n); //构造一个三元组顺序表存储矩阵
				TripleToArray(Triple1, A, m, n);//三元组顺序表转换为二维数组
				cout<<"你输入的矩阵为："<<endl;
				PrintArray(A, m, n);//输出矩阵行列式
				Triple2=TransposeSMatrix(Triple1);
				TripleToArray(Triple2, A, m, n);//三元组顺序表转换为二维数组
				cout<<"转置矩阵为："<<endl;
				PrintArray(A, m, n);//输出矩阵行列式
				printf("\n");
				break;
			case 3:
				cout<<"请输入第一个矩阵："<<endl;
				Triple1 = CreateTriple(m, n); //构造一个三元组顺序表存储矩阵
				TripleToArray(Triple1, A, m, n);//三元组顺序表转换为二维数组
				cout<<"矩阵A为："<<endl;
				PrintArray(A, m, n);//输出矩阵行列式
				printf("\n");
				cout<<"请输入第二个矩阵："<<endl;
				Triple2 = CreateTriple(m, n); //构造一个三元组顺序表存储矩阵
				TripleToArray(Triple2, B, m, n);//三元组顺序表转换为二维数组
				cout<<"矩阵B为："<<endl;
				PrintArray(B, m, n);//输出矩阵行列式
				printf("\n");
				cout<<"\t相加为："<<endl;
				Triple3 = AddSMatrix(Triple1,Triple2);
				TripleToArray(Triple3, C, m, n);//三元组顺序表转换为二维数组
				PrintArray(C, m, n);//输出矩阵行列式
				cout<<endl;
				break;
			case 4:
				cout<<"请输入第一个矩阵："<<endl;
				Triple1 = CreateTriple(m, n); //构造一个三元组顺序表存储矩阵
				TripleToArray(Triple1, A, m, n);//三元组顺序表转换为二维数组
				cout<<"矩阵A为："<<endl;
				PrintArray(A, m, n);//输出矩阵行列式
				printf("\n");
				cout<<"请输入第二个矩阵："<<endl;
				Triple2 = CreateTriple(m, n); //构造一个三元组顺序表存储矩阵
				TripleToArray(Triple2, B, m, n);//三元组顺序表转换为二维数组
				cout<<"矩阵B为："<<endl;
				PrintArray(B, m, n);//输出矩阵行列式
				printf("\n");
				cout<<"\t相减为："<<endl;
				Triple3 = SubSMatrix(Triple1,Triple2);
				TripleToArray(Triple3, C, m, n);//三元组顺序表转换为二维数组
				PrintArray(C, m, n);//输出矩阵行列式
				cout<<endl;
				break;
			case 5:
				cout<<"请输入你将要进行操作的矩阵的行列数：(满足乘法定则，即m*n&n*k)"<<endl;
				cout<<"行: ";
				cin>>m;
				cout<<"列: ";
				cin>>n;
				cout<<"请输入第一个矩阵："<<endl;
				Triple1 = CreateTriple(m, n); //构造一个三元组顺序表存储矩阵
				TripleToArray(Triple1, A, m, n);//三元组顺序表转换为二维数组
				cout<<"矩阵A为："<<endl;
				PrintArray(A, m, n);//输出矩阵行列式
				printf("\n");
				cout<<"请输入第二个矩阵：(满足乘法定则，即m*n&n*k)"<<endl;
				cout<<"行: ";
				int k,q;
				cin>>k;
				if(k!=n){cout<<"输入有误!";exit(0);}
				cout<<"列: ";
				cin>>q;
				Triple2 = CreateTriple(k, q); //构造一个三元组顺序表存储矩阵
				TripleToArray(Triple2, B, k, q);//三元组顺序表转换为二维数组
				cout<<"矩阵B为："<<endl;
				PrintArray(B, k, q);//输出矩阵行列式
				printf("\n");
				cout<<"\t相乘为："<<endl;
				Triple3 = MultSMatrix(Triple1,Triple2);
				TripleToArray(Triple3, C, m, q);//三元组顺序表转换为二维数组
				PrintArray(C, m, q);//输出矩阵行列式
				cout<<endl;
				break;
			case 6:
				cout<<"如果要进行一键加减乘功能,请重新输入行列值，使其相等！"<<endl;
				cout<<"行: ";
				cin>>m;
				cout<<"列: ";
				cin>>n;
				if(m!=n){cout<<"输入有误！";exit(0);}
				cout<<"请输入第一个矩阵："<<endl;
				Triple1 = CreateTriple(m, n); //构造一个三元组顺序表存储矩阵
				TripleToArray(Triple1, A, m, n);//三元组顺序表转换为二维数组
				cout<<"矩阵A为："<<endl;
				PrintArray(A, m, n);//输出矩阵行列式
				printf("\n");
				cout<<"请输入第二个矩阵："<<endl;
				Triple2 = CreateTriple(m, n); //构造一个三元组顺序表存储矩阵
				TripleToArray(Triple2, B, m, n);//三元组顺序表转换为二维数组
				cout<<"矩阵B为："<<endl;
				PrintArray(B, m, n);//输出矩阵行列式
				printf("\n");
				cout<<"\t相加为："<<endl;
				Triple3 = AddSMatrix(Triple1,Triple2);
				TripleToArray(Triple3, C, m, n);//三元组顺序表转换为二维数组
				PrintArray(C, m, n);//输出矩阵行列式
				cout<<endl;
				cout<<"\t相减为："<<endl;
				Triple3 = SubSMatrix(Triple1,Triple2);
				TripleToArray(Triple3, C, m, n);//三元组顺序表转换为二维数组
				PrintArray(C, m, n);//输出矩阵行列式
				cout<<endl;
				cout<<"\t相乘为："<<endl;
				Triple3 = MultSMatrix(Triple1,Triple2);
				TripleToArray(Triple3, C, m, n);//三元组顺序表转换为二维数组
				PrintArray(C, m, n);//输出矩阵行列式
				cout<<endl;
				break;
			case 7:
				cout<<"谢谢使用！"<<endl;
				exit(0);
				break;
		}
		cout<<endl;
		cout<<"是否继续：(Y/N)"<<endl;
		cin>>ch;
		if(ch=='N'||ch=='n') exit(0);
	}while(ch=='Y'||ch=='y');
	return 0;
}

【后记】

    如果有误或者需要讲解的私戳或评论，谢谢。