稀疏矩阵的相加

合集下载

稀疏矩阵的求和运算

稀疏矩阵的求和运算

作业答案:针对稀疏矩阵的三种表示方法,写出两个矩阵的求和算法。

即若A, B, C为三个矩阵,求C = A + B.1.三元组顺序表三元组顺序表的C表示如下:#define MAXSIZE 12500typedef struct{int i, j; //非零元的行列下标ElemType e;}Triple;typedef union{Triple a_Data[MAXSIZE + 1]; //三元组表,a_Data[0]未用int mu, nu, tu;}TSMatrix;算法:注意:在稀疏矩阵的三元组顺序表表示中,a_Data域中的非零元排列是有序的,即以行序为主序排列,在一行中,数据元素按列序排列。

因此整个算法可以集中到如下问题:在已知A和B阵的某一行的起始位置的情况下,如何得到C的该行的内容。

如图示:C:A:B:kB kB’其中kA,kB,kC分别为矩阵A,B,C的a_Data域的当前位置。

kX到kX’的位置是矩阵X中第i行的非零元元素。

两个矩阵的加法运算转化为第i行元素的加法。

而第i行中第j元素的加法可以描述为:1.取A和B的当前元素,若列号相同,则相加,若和非零,把结果放在C中,kA,kB,kC分别移到下一个位置;若和为零,则kA,kB移到下一个位置;2.否则,若A的列号小于B,则C的元素等于A的元素,kA,kC分别移到下一个位置;3.否则,则C的元素等于B的元素,kB,kC分别移到下一个位置;程序:// 以知A和B,求矩阵C = A + B,其中矩阵采用三元组顺序表表示status MatrixAdd_TSMatrix( TSMatrix A, TSMatrix B, TSMatrix &C){// 若矩阵A和B的行列不同,返回错误!if( A.mu != B.mu || A.nu != B.nu ){return ERROR;}// 矩阵C的行列赋值C.mu = A.mu;C.nu = B.nu;kA = kB = kC = 1; // 初始化for ( i = 0; i < C.mu; i++) // 处理每一行{// 每列元素,从kA和kB开始,依次比较A和B中元素。

数据结构稀疏矩阵转置,加法

数据结构稀疏矩阵转置,加法

数据结构稀疏矩阵转置,加法《数据结构》实验报告◎实验题⽬:稀疏矩阵的转置、加法(⾏逻辑链接表)◎实验⽬的:学习使⽤三元组顺序表表⽰稀疏矩阵,并进⾏简单的运算◎实验内容:以三元组表表⽰稀疏矩阵,并进⾏稀疏矩阵的转置和加法运算。

⼀、需求分析该程序⽬的是为了⽤三元组表实现稀疏矩阵的转置和加法运算。

1、输⼊时都是以三元组表的形式输⼊;2、输出时包含两种输出形式:运算后得到的三元组表和运算后得到的矩阵;3、测试数据:(1)转置运算时输⼊三元组表:1 2 121 3 93 1 -33 6 144 3 245 2 186 1 156 4 -7得到转置后的三元组表:1 3 -31 6 152 1 122 5 183 1 93 4 244 6 -76 3 14(2)进⾏加法运算时先输⼊矩阵A(以三元组表形式):1 1 12 2 22 3 43 1 -4输⼊矩阵B(以三元组表形式):1 3 -22 3 -53 1 83 2 -6A与B的和矩阵以矩阵形式输出为:1 0 -20 2 -14 -6 0(⼆) 概要设计为了实现上述操作⾸先要定义三元组表,稀疏矩阵:typedef struct{int i,j;int e;}Triple;//三元组typedef struct{Triple data[MAXSIZE+1];int mu,nu,tu;}Matrix;//稀疏矩阵1.基本操作void CreatMatrix(Matrix *m)操作结果:创建⼀个稀疏矩阵。

void PrintMatrix(Matrix m)初始条件:矩阵m已存在。

操作结果:将矩阵m以矩阵的形式输出。

void FastTransposeMatrix(Matrix a,Matrix *b)初始条件:稀疏矩阵a已存在;操作结果:将矩阵a进⾏快速转置后存⼊b中。

void AddMatrix(Matrix a,Matrix b,Matrix *c)初始条件:稀疏矩阵a和b都已存在;操作结果:将矩阵a和b的和矩阵存⼊c中。

稀疏矩阵加法乘法

稀疏矩阵加法乘法

稀疏矩阵加法乘法稀疏矩阵是指其中大部分元素都是0的矩阵,而只有极小部分元素为非0值。

与密集矩阵相比,稀疏矩阵具有更高的压缩率以及更快的计算速度,因此在大型数据处理和机器学习等领域中得到了广泛应用。

稀疏矩阵加法和乘法是稀疏矩阵计算中最基本的两个操作。

一、稀疏矩阵的表示方法基于稀疏矩阵的特殊性质,我们通常使用三元组(TUPLES)实现稀疏矩阵的存储。

三元组存储方式将一个i * j的稀疏矩阵表示为三个一维数组,分别存储非零元素的值,行坐标和列坐标。

例如,一个矩阵:1 0 00 2 00 0 3通过三元组存储方式可以表示为:value = [1, 2, 3]row = [0, 1, 2]col = [0, 1, 2]值为1的元素位于第0行第0列,值为2的元素位于第1行第1列,值为3的元素位于第2行第2列。

二、稀疏矩阵的加法两个稀疏矩阵相加的操作可以通过对两个矩阵的三元组进行合并,对于重复的元素,则将它们的值相加。

例如,对于两个矩阵A和B:A:1 0 00 2 00 0 3B:1 0 00 2 00 0 3则可以通过以下方式对A和B进行加法操作:value = [1+1, 2+2, 3+3]row = [0, 1, 2]col = [0, 1, 2]即结果矩阵为:2 0 00 4 00 0 6三、稀疏矩阵的乘法稀疏矩阵乘法的实现比较复杂,首先需要明确一点,即两个矩阵相乘的结果不一定是稀疏矩阵。

我们可以使用两种常见的算法实现稀疏矩阵的乘法:COO算法和CSR算法。

1. COO算法COO算法也称坐标格式算法,其基本思路是将两个矩阵的三元组转换成一个三元组,然后依次进行乘法运算,最后将结果累加得到最终结果的三元组。

例如,对于两个矩阵A和B:A:1 23 4B:5 67 8则可以按照以下步骤进行乘法操作:①将矩阵A表示为三元组形式:value_A = [1,2,3,4]row_A = [0,0,1,1]col_A = [0,1,0,1]②将矩阵B表示为三元组形式:value_B = [5,6,7,8]row_B = [0,0,1,1]col_B = [0,1,0,1]③对A和B的三元组进行合并得到三元组C:value_C = [1,2,3,4,5,6,7,8]row_C = [0,0,1,1,0,0,1,1]col_C = [0,1,0,1,1,0,1,0]其中row_C和col_C表示的是C中每个元素对应的行数和列数。

稀疏矩阵的加法

稀疏矩阵的加法

稀疏矩阵的加法
哎呀,说起这稀疏矩阵的加法,咱们得好好说道说道。

四川的朋友可能觉得,这加法嘛,就跟咱们平时数数儿一样,简单得很。

不过,这稀疏矩阵的加法可就有点儿门道了。

咱先说说啥子是稀疏矩阵吧。

就像贵州的辣椒,虽然辣得让人受不了,但咱们还是喜欢吃,为啥呢?因为它有特色,不是啥子都放。

稀疏矩阵也是这样,大部分元素都是零,就像贵州的山地,看似荒芜,实则藏着不少宝贝。

那加法怎么做呢?陕西的老哥可能会说,这就像咱们和面一样,得把两块面揉在一起,才能做出好吃的面条。

稀疏矩阵的加法也是这个理儿,得把两个矩阵对应位置的元素加起来。

不过,得注意啊,如果两个矩阵的形状不一样,那可就像陕西的油泼面和臊子面,虽然都是面,但混在一起就不好吃了。

咱们再说说北京的老少爷们儿,他们可能觉得这事儿得讲究个规矩,得按部就班地来。

没错,稀疏矩阵的加法也得按规矩来,不能乱来。

得先把两个矩阵对应位置的元素都找出来,然后一个一个地加起来。

这样,结果才能准确无误。

总的来说,稀疏矩阵的加法虽然看起来简单,但实际操作起来还是得小心谨慎。

就像咱们各地的方言一样,虽然各有各的特色,但都得遵守一定的规则,才能让人听得明白,理解得透彻。

所以嘛,大家在学习稀疏矩阵的加法时,也得像对待方言一样,既要理解它的特点,又要掌握它的规则,这样才能真正学好它。

稀疏矩阵存储和操作稀疏矩阵的数据结构与算法

稀疏矩阵存储和操作稀疏矩阵的数据结构与算法

稀疏矩阵存储和操作稀疏矩阵的数据结构与算法稀疏矩阵是指具有大量零元素和少量非零元素的矩阵。

在实际场景中,由于矩阵中大部分元素为零,传统的矩阵存储方式会造成大量的存储空间的浪费以及数据操作的低效性。

因此,为了节省存储空间和提高数据操作的效率,稀疏矩阵的存储和操作需要借助于特定的数据结构和算法。

一、稀疏矩阵存储的数据结构1.1. 压缩存储方法压缩存储方法是一种常用的稀疏矩阵存储方法。

常见的压缩存储方法有三种:行压缩法(CSR)、列压缩法(CSC)和十字链表法。

1.1.1. 行压缩法(CSR)行压缩法是通过两个数组来存储稀疏矩阵的非零元素。

第一个数组存储非零元素的值,第二个数组存储非零元素在矩阵中的位置信息。

1.1.2. 列压缩法(CSC)列压缩法与行压缩法相似,只是存储方式不同。

列压缩法是通过两个数组来存储稀疏矩阵的非零元素。

第一个数组存储非零元素的值,第二个数组存储非零元素在矩阵中的位置信息。

1.1.3. 十字链表法十字链表法是一种更加灵活的稀疏矩阵存储方法。

通过使用链表的方式,将非零元素存储在链表中,并且每个非零元素还具有行和列的指针,方便进行数据操作。

1.2. 坐标存储法坐标存储法是一种简单直观的稀疏矩阵存储方法。

每个非零元素包括行列坐标和元素值,通过三元组的方式进行存储。

二、稀疏矩阵的操作算法2.1. 矩阵转置矩阵转置是指将原矩阵的行变为列,列变为行的操作。

对于稀疏矩阵,常用的转置算法为快速转置算法。

该算法通过统计每列非零元素的个数,并根据列的非零元素个数确定每个非零元素转置后的位置。

2.2. 矩阵相加矩阵相加是指将两个矩阵对应位置上的元素相加得到一个新的矩阵。

对于稀疏矩阵的相加,可以遍历两个矩阵的非零元素,对相同位置上的元素进行相加。

2.3. 矩阵相乘矩阵相乘是指将两个矩阵相乘得到一个新的矩阵。

对于稀疏矩阵的相乘,常用的算法为稀疏矩阵乘法算法。

该算法通过遍历两个矩阵的非零元素,按照矩阵乘法的规则计算得到新矩阵的非零元素。

两个稀疏矩阵三元组相加

两个稀疏矩阵三元组相加

while(A->data[pa].i==x && B->data[pb].i==x) /*行数相等时*/
{if(A->data[pa].j==B->data[pb].j) /*列数相等时*/
{sum=A->data[pa].v+B->data[pb].v; /*矩阵想加*/
if(sum) /*相加不为零时*/
typedef int DataType; /*用户自定义*/
typedef struct
{ int i,j; DataType v; }Triple;/*定义三元组结构*/
typedef struct
{ Triple data[MaxSize];/*定义可存三元组大小*/
{C-> data[c-> t].i=A-> data[k].i;
C-> data[c-> t].j=A-> data[k].j;
C-> data[c-> t++].v=A-> data[k].v;
k++;
}
if ((A-> data[k].i==B-> data[l].i)&&(A-> data[k].j> B-> data[l].j))
l++;
}
}
while (k <A-> t)//将A中剩余三元组加入C
{C-> data[c-> t].i=A-> data[k].i;
C-> data[c-> t].j=A-> data[k].j;

三元组顺序表表示的稀疏矩阵加法python

三元组顺序表表示的稀疏矩阵加法python

在Python中,三元组顺序表表示的稀疏矩阵加法是一个重要的主题。

稀疏矩阵是指大部分元素为零的矩阵,而三元组顺序表是一种压缩稀疏矩阵的方法,它将非零元素的行列坐标及对应的值存储起来,以节省空间和提高运算效率。

在本文中,我们将探讨稀疏矩阵加法在Python中的实现方法,并深入分析其原理和应用。

一、稀疏矩阵及三元组顺序表简介1. 稀疏矩阵稀疏矩阵是指大部分元素为零的矩阵,它在实际问题中的应用非常广泛,如图像处理、网络分析、物理建模等领域。

由于其大部分元素为零,传统的存储和计算方法会浪费大量的空间和时间,因此需要一种高效的表示方法。

2. 三元组顺序表三元组顺序表是一种压缩稀疏矩阵的方法,它将非零元素的行列坐标及对应的值存储起来。

比起普通的二维数组表示方法,三元组顺序表可以更加高效地存储和计算稀疏矩阵,节省空间和提高运算效率。

二、稀疏矩阵加法的原理稀疏矩阵加法是指将两个稀疏矩阵相加,得到一个新的稀疏矩阵。

在三元组顺序表表示的稀疏矩阵中,我们可以通过遍历两个矩阵的非零元素,并按照其行列坐标进行相加,得到新的稀疏矩阵。

三、Python中的实现在Python中,我们可以通过定义稀疏矩阵类和相应的加法运算方法来实现稀疏矩阵的加法。

我们需要定义稀疏矩阵的三元组顺序表表示方法,并实现相应的初始化方法和加法运算方法。

下面是一个简单的Python示例代码:```pythonclass SparseMatrix:def __init__(self, rows, cols, data):self.rows = rowsself.cols = colsself.data = datadef __add__(self, other):result = []i, j = 0, 0while i < len(self.data) and j < len(other.data):if self.data[i][0] == other.data[j][0] and self.data[i][1] == other.data[j][1]:result.append((self.data[i][0], self.data[i][1],self.data[i][2] + other.data[j][2]))i += 1j += 1elif self.data[i][0] < other.data[j][0] or (self.data[i][0] == other.data[j][0] and self.data[i][1] < other.data[j][1]):result.append((self.data[i][0], self.data[i][1],self.data[i][2]))i += 1else:result.append((other.data[j][0], other.data[j][1], other.data[j][2]))j += 1while i < len(self.data):result.append((self.data[i][0], self.data[i][1], self.data[i][2])) i += 1while j < len(other.data):result.append((other.data[j][0], other.data[j][1],other.data[j][2]))j += 1return SparseMatrix(self.rows, self.cols, result)```在上面的示例代码中,我们定义了一个SparseMatrix类,其初始化方法接受稀疏矩阵的行数、列数和三元组顺序表表示的数据。

实现稀疏矩阵的基本运算实验报告

实现稀疏矩阵的基本运算实验报告

实现稀疏矩阵的基本运算实验报告实验报告:稀疏矩阵的基本运算实验一、引言稀疏矩阵是指在矩阵中大部分元素为0的情况下,只存储非零元素及其位置信息的数据结构。

由于稀疏矩阵节省空间,可以节约存储和计算时间,因此在科学计算和大规模矩阵运算中应用广泛。

本实验旨在实现稀疏矩阵的基本运算,包括矩阵加法、矩阵乘法和转置运算,并对其效率进行测试。

二、实验方法本实验使用C++语言实现稀疏矩阵的基本运算。

首先定义一个稀疏矩阵的结构体,包括矩阵的行数、列数、非零元素个数和一个动态分配的二维数组用于存储非零元素的值和位置信息。

然后根据实验要求,分别实现矩阵的加法、乘法和转置运算的函数。

1.矩阵加法:遍历两个矩阵的非零元素,将对应位置的元素相加存入结果矩阵。

2.矩阵乘法:遍历两个矩阵的非零元素,将对应位置的元素相乘并累加,存入结果矩阵。

3.转置运算:将矩阵的行列互换,同时调整非零元素的位置信息。

最后,通过随机生成不同大小的稀疏矩阵进行实验,并记录每种运算的运行时间,分析稀疏矩阵在不同运算中的效率差异。

三、实验结果1.矩阵加法运算:对两个1000*1000的稀疏矩阵进行加法运算,耗时0.05秒。

2.矩阵乘法运算:对一个1000*1000和一个1000*100的稀疏矩阵进行乘法运算,耗时0.1秒。

四、实验结论通过实验结果可以看出,稀疏矩阵的加法运算具有较高的效率,因为只需要遍历非零元素进行相加,而对于乘法运算和转置运算,由于需要遍历较多的元素进行累加或位置调整,因此耗时较长。

在矩阵转置运算中,由于矩阵规模较大,耗时最长。

总结而言,稀疏矩阵在处理大规模矩阵运算时具有一定的优势,可以节约存储空间和计算时间。

在实践中,可以根据应用的需求选择适当的数据结构和算法,进一步提升稀疏矩阵的运算效率。

五、实验反思本实验中,由于时间和资源限制,只对较小规模的稀疏矩阵进行了测试,实际应用中可能会遇到更大规模的矩阵运算问题,因此需要进一步验证和优化。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

稀疏矩阵的相加题目: 稀疏矩阵的相加1、问题描述稀疏矩阵是指那些多数元素为零的矩阵。

利用“稀疏”特点进行存储和计算可以大大节省存储空间,提高计算效率。

实现一个能进行稀疏矩阵基本运算的运算器。

以“带行逻辑链接信息”的三元组顺序表表示稀疏矩阵,实现两个矩阵相加运算。

稀疏矩阵的输入形式采用三元组表示,而运算结果的矩阵则以通常的阵列形式列出。

2、设计2.1. 存储结构设计稀疏矩阵的行逻辑连接的顺序表存储结构表示如下:#define MAXSIZE 20 /* 非零元个数最大值*/最大值*/#defi ne MAXRC 10 /* 各行第一个非零元总数typedef struct{, 列下标*/ int i,j; /* 行下标int e; /* 非零元值*/}Triple;typedef struct { /* 行逻辑链接的顺序表*/Triple data[MAXSIZE+1]; /* 非零元三元组表,data[0] 未用*/int rpos[MAXRC+1]; /* 各行第一个非零元的位置表*/int mu,nu,tu; /* 阵的行数、列数和非零元个数*/}TSMatrix;2.2. 主要算法设计对 2 个矩阵相加的算法如下:bool AddSMatrix(TSMatrix M,TSMatrix N,TSMatrix &Q) /* 求稀疏矩阵的和Q=M+N*/{int p=1,q=1,k=1;if(M.tu==0&&N.tu==0) /* 为空矩阵的情况*/{cout<<" 该矩阵为空矩阵"<<endl;return 0;}while(pv=M.tu)/* 不为空矩阵的情况,先看M矩阵*/{if(M.data[p].i<N.data[q].i) /*M 的行比N的小,Q 取M的值*/{Q.data[k].i=M.data[p].i;Q.data[k].j=M.data[p].j;Q.data[k].e=M.data[p].e;k++;p++;}else if(M.data[p].i>N.data[q].i) /*M 的行值比N 的大取N 的值*/ {Q.data[k].i=N.data[q].i;Q.data[k].j=N.data[q].j;Q.data[k].e=N.data[q].e;k++;q++;}else /*M的行值和N—样大的情况*/{if(M.data[p].j<N.data[q].j)/*M 的列值比M的小取M的值*/{Q.data[k].i=M.data[p].i;Q.data[k].j=M.data[p].j;Q.data[k].e=M.data[p].e;k++;p++;}else if(M.data[p].j>N.data[q].j)/*M 的列值比M的大取N的值*/ {Q.data[k].i=N.data[q].i;Q.data[k].j=N.data[q].j;Q.data[k].e=N.data[q].e;k++;q++;}else /*M和N的列值相等*/{if(M.data[p].e+N.data[q].e!=O)/* 相加结果不为0 才取M值*/{Q.data[k].i=M.data[q].i;Q.data[k].j=M.data[q].j;Q.data[k].e=M.data[q].e+N.data[p].e;k++;}p++;q++;}}}while(qv=N.tu) /* 再看N矩阵,直接取N值*/{Q.data[k].i=N.data[q].i;Q.data[k].j=N.data[q].j;Q.data[k].e=N.data[q].e;k++;q++;}if(M.mu>N.mu) Q.mu=M.mu;/*Q的行和列的值取M,N的最大值*/ else Q.mu=N.mu; if(M.nu>N.nu) Q.nu=M.nu;else Q.nu=N.nu;Q.tu=k-1;cout<<" 相加成功"<<endl;return 1;}2.3. 测试用例设计采用一下 2 个稀疏矩阵进行测试: M 矩阵如下:3 0 0 50 -1 0 02 0 0 0N矩阵如下:0 21 0-2 40 03. 调试报告3.1 调试过程程序刚写完时有不少问题,像有些变量忘定义,符号错误等等,一些很低级的错误,主要是编程过程中不仔细造成的。

改掉这些错误后,程序可以运行了,但用例子进行测试时又出现错误了,运行的结果不正确。

就是矩阵相加的结果部分不正确,初步断定算法写的有问题,就对该部分进行调试,设置断点到矩阵相加函数,执行到断点,输入测试用例后,开始观察各变量的值是否正常。

刚开始就发现执行顺序有问题,才发现自己误把矩阵的三元表存储当成是数组的形式了,数组是从0 开始而三元组是从 1 开始的,初值设置有问题,于是都设为1,程序运行后与期待结果接近了. 但发现程序对于两个矩阵取同一位置时的值相加是否为0 的细节处理的不是很好,于是重新作处理,程序结果才显示正确。

3.2. 对设计和编码的讨论和分析这次设计主要包括以下几个部分: 稀疏矩阵的存储结构、矩阵的创建、矩阵的输出、矩阵相加算法的实现、操作说明书的显示部分和主函数。

其中稀疏矩阵的存储结构采用行逻辑连接的顺序表的形式。

矩阵的创建部分是通过先设置一个初值,然后将后输入的值与前一个值进行比较来进行判断输入的值是否合法来对输入值进行筛选的,取符合要求的值建立矩阵。

矩阵输出部分采用一行一行的输出方式,至到输出完为止。

矩阵相加部分算法再上面已给出,也给了详细的说明这里就不多说了。

说明书显示部分都是一些输出操作,主要是把该程序的操作发发提示给使用者,来方便使用者使用。

主函数部分通过输入操作符对程序进行操作,这些操作都是通过调用各个函数来实现的。

4. 源程序清单和运行结果4.1 程序代码如下:#include<iostream>#include<iomanip>using namespace std;/* 稀疏矩阵的三元组顺序表类型TSMatrix 的定义*/ #define MAXSIZE 20 /* 非零元个数最大值*/#define MAXRC 10typedef struct{int i,j; /* 行下标, 列下标*/int e; /* 非零元值*/}Triple;typedef struct { /* 行逻辑链接的顺序表*/Triple data[MAXSIZE+1]; /* 非零元三元组表,data[0] 未用*/int rpos[MAXRC+1]; /* 各行第一个非零元的位置表*/int mu,nu,tu; /* 阵的行数、列数和非零元个数*/ }TSMatrix;bool CreateSMatrix(TSMatrix &M) /* 创建一个稀疏矩阵*/ {int p=1,a,b,c;cout<<" 请输入矩阵的行列和非零元素个数"<<endl; cin>>M.mu>>M.nu>>M.tu;if(M.tu>MAXSIZE||M.tu<=0||M.tu>M.mu*M.nu){cout<<" 输入错误"<<endl;return 0;}while(p<=M.tu){cout<<" 请输入第"<<p<<" 个元素的三元组"<<endl;cin>>a>>b>>c;M.data[0].i=1;M.data[0].j=1;if(a<=M.mu&&b<=M.nu&&c!=0){if(a>M.data[p-1].i||(a==M.data[p-1].i&&b>=M.data[p-1].j))/* 行值比前一个大或行值等于前一个列值小于等于前一个元素*/{M.data[p].i=a;M.data[p].j=b;M.data[p].e=c;p++;cout<<" 输入成功"<<endl;}else cout<<" 输入错误"<<endl;}else cout<<" 输入错误"<<endl;}return 0;}bool PrintMatrix(TSMatrix M) /*输出一个矩阵*/ {int i,j,p=1;if(M.tu==0){cout<<" 该矩阵为空矩阵"<<endl; return 0;}for(i=1;i<=M.mu;i++){for(j=1;j<=M.nu;j++){if(i==M.data[p].i&&j==M.data[p].j) {cout<<setw(3)<<M.data[p].e;p++;else cout<<setw(3)<<0;}cout<<endl;}return 1;}bool AddSMatrix(TSMatrix M,TSMatrix N,TSMatrix &Q) /*求稀疏矩阵的和Q=M+N*/{int p=1,q=1,k=1;if(M.tu==0&&N.tu==0){cout<<" 该矩阵为空矩阵"<<endl;return 0;}while(p<=M.tu){if(M.data[p].i<N.data[q].i){Q.data[k].i=M.data[p].i;Q.data[k].j=M.data[p].j;Q.data[k].e=M.data[p].e;k++;p++;}else if(M.data[p].i>N.data[q].i){Q.data[k].i=N.data[q].i;Q.data[k].j=N.data[q].j;Q.data[k].e=N.data[q].e;k++;q++;}else{if(M.data[p].j<N.data[q].j){Q.data[k].i=M.data[p].i;Q.data[k].j=M.data[p].j;Q.data[k].e=M.data[p].e;k++;p++;}else if(M.data[p].j>N.data[q].j) {Q.data[k].i=N.data[q].i;Q.data[k].j=N.data[q].j;Q.data[k].e=N.data[q].e;k++;q++;}else{if(M.data[p].e+N.data[q].e!=0) {Q.data[k].i=M.data[q].i;Q.data[k].j=M.data[q].j;Q.data[k].e=M.data[q].e+N.data[p].e; k++;}p++;q++;}}}while(q<=N.tu){Q.data[k].i=N.data[q].i;Q.data[k].j=N.data[q].j;Q.data[k].e=N.data[q].e;k++;q++;}if(M.mu>N.mu) Q.mu=M.mu; else Q.mu=N.mu;if(M.nu>N.nu) Q.nu=M.nu;else Q.nu=N.nu;Q.tu=k-1;cout<<" 相加成功"<<endl;return 1;}void Show() /* 显示操作说明书*/ { cout<<" 操作说明书"<<endl;cout<<" 输入1 创建矩阵A"<<endl; cout<<" 输入2 创建矩阵B"<<endl;cout<<" 输入3 输出矩阵A"<<endl; cout<<" 输入4 输出矩阵B"<<endl;cout«"输入5矩阵A+B=C的计算"<<endl; cout<<" 输入6 输出矩阵C"<<endl; } int main(){int select;TSMatrix A,B,C;A.tu=0;B.tu=0;C.tu=0;Show();while(1){cout<<" 请选择你要进行的操作"<<endl; cin>>select;if(select==0)break;switch(select){case 1: CreateSMatrix(A);break;case 2: CreateSMatrix(B);break;case 3: PrintMatrix(A);break;case 4: PrintMatrix(B);break;case 5: AddSMatrix(A,B,C);break;case 6: PrintMatrix(C);break;default:cout<<" 输入错误"<<endl; break;}} return 0; }•二二gMkHKOh VKuai * s z o .-r c s x 録朗>聊39耳卿3|1|耳問2 2 —R盛葫丫滋4手耳拥3川m ffi3-2 國>姦母 笑聲3書S.薔濂f亠2 4潮前A 翔■->耳洲311191随实验结果运行正确。

相关文档
最新文档