(完整word版)当稀疏矩阵A和B均以三元组表作为存储结构时

合集下载

用三元组表示稀疏矩阵的乘法

用三元组表示稀疏矩阵的乘法

图5.17给出了一个矩阵相乘的例子。当矩阵M、N是稀疏 矩阵时,我们可以采用三元组表的表示形式来实现矩阵的相 乘。
3 0 0 5
0 2
1 0
M 0 1 0 0 N
2 0 0 0
2 4
0 0
0 6
Q 1 0
0 4
图5.17 Q=M×N
图5.18 矩阵M、N、Q的三元组表
{
OLink * row_head, *col_head; /* 行、 列链表的头指针向量 */
int m, n, len; /* 稀疏矩阵的行数、 列数、 非零元素的个数 */
}CrossList;
CreateCrossList (CrossList * M) {/* 采用十字链表存储结构, 创建稀疏矩阵M */ scanf(&m, &n, &t); /* 输入M的行数, 列数和非零元素的个数 */ M->m=m; M->n=n; M->len=t; If(!(M->row_head=(OLink * )malloc((m+1)sizeof(OLink)))) exit(OVERFLOW); If(!(M->col_head=(OLink * )malloc((n+1)sizeof(OLink)))) exit(OVERFLOW); M->row_head[ ]=M->col_head[ ]=NULL;
}TriSparMatrix;
具体算法如下:
该算法的时间主要耗费在乘法运算及累加上,其时间复杂度为O (A.len×B.n)。当A.len 接近于A.m×A.n时,该算法时间复杂度接近于 经典算法的时间复杂度O(A.m×A.n×B.n)。

三元组表示稀疏矩阵

三元组表示稀疏矩阵

三元组表示稀疏矩阵本节介绍稀疏矩阵三元序列表的压缩存储方式。

通过《矩阵的压缩存储》一节我们知道,稀疏矩阵的压缩存储,至少需要存储以下信息:•矩阵中各非 0 元素的值,以及所在矩阵中的行标和列标;•矩阵的总行数和总列数;图 1 稀疏矩阵示意图例如,图 1 是一个稀疏矩阵,若对其进行压缩存储,矩阵中各非 0 元素的存储状态如图 2 所示:图 2 稀疏矩阵的压缩存储示意图在图2的数组中,存储了一个三元组(即一组三个部分的数据),分别表示组中的数据(行标签、列标签和元素值)。

注意,这里矩阵的行和列标签都是从1开始的。

C 语言中,三元组需要用结构体实现,如下所示://三元组结构体typedef struct {int i,j;//行标i,列标jint data;//元素值}triple;由于稀疏矩阵中非 0 元素有多个,因此需要建立 triple 数组存储各个元素的三元组。

除此之外,考虑到还要存储矩阵的总行数和总列数,因此可以采用以下结构表示整个稀疏矩阵:#define number 20//矩阵的结构表示typedef struct {triple data[number];//存储该矩阵中所有非0元素的三元组int n,m,num;//n和m分别记录矩阵的行数和列数,num 记录矩阵中所有的非0元素的个数}TSMatrix;可以看到,TSMatrix 是一个结构体,其包含一个三元组数组,以及用于存储矩阵总行数、总列数和非 0 元素个数的变量。

假设采用 TSMatrix 结构体存储图 1 中的稀疏矩阵,其 C 语言实现代码应该为:#include<stdio.h>#define number 3typedef struct {int i,j;int data;}triple;typedef struct {triple data[number];int n,m,num;}TSMatrix;//输出存储的稀疏矩阵void display(TSMatrix M);int main() {TSMatrix M;M.m=3;M.n=3;M.num=3;M.data[0].i=1;M.data[0].j=1;M.data[0].data=1;M.data[1].i=2;M.data[1].j=3;M.data[1].data=5;M.data[2].i=3;M.data[2].j=1;M.data[2].data=3;display(M);return 0;}void display(TSMatrix M){for(int i=1;i<=M.n;i++){for(int j=1;j<=M.m;j++){int value =0;for(int k=0;k<M.num;k++){if(i == M.data[k].i && j ==M.data[k].j){printf("%d ",M.data[k].data); value =1;break;}}if(value == 0)printf("0 ");}printf("\n");}}输出结果为:1 0 00 0 53 0 0。

实验5稀疏矩阵三元组表的操作1

实验5稀疏矩阵三元组表的操作1

实验五稀疏矩阵三元组表的操作科目:数据结构实验和课程设计班级: 10信管姓名:徐杨学号:2010110450 实验目的:会定义稀疏矩阵的三元组表。

熟悉C语言程序的基本结构,掌握程序中的用户头文件、文件之间的相互关系及各自的作用。

熟悉对稀疏矩阵的三元组表的一些基本操作和具体的函数定义。

熟悉C语言操作环境的使用以及多文件程序的输入、编辑、调试和运行的全过程。

实验要求:认真阅读和掌握本实验内容所给的全部程序。

保存和输出程序运行结果,并结合程序进行分析。

按照你对稀疏矩阵的三元组表操作的需要,编写程序代码然后运行,给出运行结果。

实验设备:每人一台安装VC6.0编写软件的计算机,公用打印机。

注意事项:要在硬盘上建立好自己的工作目录,专门用来存储自己所做的实验程序及相关数据,以后每次做实验最好仍采用这个目录。

认真编写算法及运行结果,针对本实验的具体算法,认真写出算法分析。

一、实验步骤:#include<iostream.h>//稀疏矩阵三元组表的操作#define maxsize 64#define M#define Ntypedef int elemtype;struct node{int r,c;elemtype d;};struct ts{int rows,cols,nums;node data[maxsize];};void create(ts &a);//稀疏矩阵三元组表的建立void disp(ts a);//显示稀疏矩阵三元组表的内容void trants(ts a,ts &at); //求稀疏矩阵的转置void add(ts a,ts b,ts &c);//求两稀疏矩阵的和void main(){ts a;create(a); //稀疏矩阵三元组表的建立disp(a); //显示稀疏矩阵三元组表的内容ts at;trants(a,at); //求稀疏矩阵的转置disp(at); //显示转置矩阵的内容ts b;create(b);disp(b); //稀疏矩阵三元组表的建立ts c;add(a,b,c); //求两稀疏矩阵的和disp(c); //显示两稀疏矩阵和的内容}void create(ts &a) //稀疏矩阵三元组表的建立{ cout<<"建立稀疏矩阵三元组表:"<<endl;cout<<"稀疏矩阵的行数为:";cin>>a.rows;cout<<"稀疏矩阵列的数为:";cin>>a.cols;cout<<"稀疏矩阵中非零的元素个数为:";cin>>a.nums;cout<<"稀疏矩阵的三元组表为:"<<endl;for(int i=0;i<a.nums;i++){cin>>a.data[i].r>>a.data[i].c>>a.data[i].d;}}void disp(ts a) //显示稀疏矩阵三元组表的内容{ int i;cout<<"显示稀疏矩阵三元组表:"<<endl;if(a.nums<=0) return;cout<<"行数为:"<<a.rows<<" "<<"列数为:"<<a.cols<<" "<<"元素个数为:"<<" "<<a.nums<<endl;cout<<"------------------------"<<endl;for(i=0;i<a.nums;i++)cout<<a.data[i].r<<" "<<a.data[i].c <<" "<<a.data[i].d <<endl;}void trants(ts a,ts &at)//求稀疏矩阵的转置{ int p,q=0,v;at.rows=a.cols;at.cols=a.rows;at.nums=a.nums;if(a.nums!=0){ for(v=0;v<a.cols;v++)for(p=0;p<a.nums;p++)if(a.data[p].c==v){at.data[q].r=a.data[p].c;at.data[q].c=a.data[p].r;at.data[q].d=a.data[p].d;q++;}}cout<<"转置后的稀疏矩阵:"<<endl;}void add(ts a,ts b,ts &c) //求两稀疏矩阵的和{int i=0,j=0,k=0;elemtype v;if (a.rows!=b.rows||a.cols!=b.cols)c.rows=a.rows;c.cols=a.cols;while (i<a.nums&&j<b.nums){if(a.data[i].r==b.data[j].r){if(c.data[i].c<b.data[j].c){c.data[k].r=a.data[i].r;c.data[k].c=a.data[i].c;c.data[k].d=a.data[i].d;k++;i++;}else if(a.data[i].c>b.data[j].c){c.data[k].r=b.data[j].r;c.data[k].c=b.data[j].c;c.data[k].d=b.data[j].d;k++;j++;}else{v=a.data[i].d+b.data[j].d;if(v!=0){c.data[k].r=a.data[i].r;c.data[k].c=a.data[i].c;c.data[k].d=v;k++;}i++;j++;}}else if(a.data[i].r<b.data[j].r){c.data[k].r=a.data[i].r;c.data[k].c=a.data[i].c;c.data[k].d=a.data[i].d;k++;i++;}else{c.data[k].r=b.data[j].r;c.data[k].c=b.data[j].c;c.data[k].d=b.data[j].d;k++;j++;}c.nums=k;}cout<<"两个稀疏矩阵求和后元素的个数为:"<<c.nums<<endl; }二、运行结果:三、算法分析:。

java稀疏矩阵的三元组存储

java稀疏矩阵的三元组存储

=====实习报告三“稀疏矩阵的三元组存储”演示程序======(一)、程序的功能和特点1. 程序功能:建立稀疏矩阵的三元组存储,可以键盘输入所要存储的稀疏矩阵,能将输入的稀疏矩阵显示输出。

2. 程序特点:采用java面向对象语言,将三元组和稀疏矩阵用类进行封装。

能方便的储存稀疏,方便的显示稀疏矩阵。

(二)、程序的算法设计算法一:“显示输出稀疏矩阵”算法:1.【逻辑结构与存储结构设计】逻辑结构:线性结构。

存储结构:顺序存储结构。

数组采用三元组顺序存储方法存储该表。

2.【基本操作设计】3.【算法设计】i j v1 1 1 152 1 4 223 1 6 -154 2 2 115 2 3 36 3 4 67 5 1 91 三元组表15 0 0 22 0 -150 11 3 0 0 00 0 0 60 00 0 0 00 091 0 0 00 00 0 0 00 0稀疏矩阵A=开始输出命令输出该稀疏矩阵的行数和列数。

利用for循环按先行后列顺序输出矩阵循环访问稀疏矩阵的每一个元素,通过行号和列号找到稀疏矩阵的在三元组表中是否有存储,若有则输出其值,若没有则输出0.文字说明:(1).首先输出稀疏矩阵的行数和列数。

(2).在通过for 循环依次访问该稀疏矩阵的每一个元素,比较行号和列号,如果行号和列号和三元组所存储的相同,则输出其值;(3).如果不相同或三元数组没有储存则该元素值为零; (4).输出结束。

4.【高级语言代码】 //显示输出稀疏矩阵 void display(){ int i,j,k;System.out .println("稀疏矩阵的行数 "+Rows ); System.out .println("稀疏矩阵的列数 "+Cols ); //按先行后列顺序输出矩阵 for (i=0;i<Rows ;i++) { for (j=0;j<Cols ;j++) {for (k=0;k<Terms ;k++) //查三元组表if (i==smArray [k].row &&j==smArray [k].col ){ System.out .print(smArray [k].value +" "); break ; //打断k 循环 }if (k==Terms ) System.out .print("0.0 "); }System.out .println(); //换行 } }(三)、程序中类的设计“Trituple ”类:1.【逻辑结构与存储结构】 逻辑结构:线性结构。

稀疏矩阵及其压缩存储方法

稀疏矩阵及其压缩存储方法

稀疏矩阵及其压缩存储方法1.基本概念稀疏矩阵(SparseMatrix):是矩阵中的一种特殊情况,其非零元素的个数远小于零元素的个数。

设m行n列的矩阵含t个非零元素,则称以二维数组表示高阶的稀疏矩阵时,会产生零值元素占的空间很大且进行了很多和零值的运算的问题。

特殊矩阵:值相同的元素或0元素在矩阵中的分布有一定的规律。

如下三角阵、三对角阵、稀疏矩阵。

压缩存储:为多个值相同的元素只分配一个存储空间;对0元素不分配空间。

目的是节省大量存储空间。

n x n的矩阵一般需要n2个存储单元,当为对称矩阵时需要n(1+n)/2个单元。

2.三元组顺序表——压缩存储稀疏矩阵方法之一(顺序存储结构)三元组顺序表又称有序的双下标法,对矩阵中的每个非零元素用三个域分别表示其所在的行号、列号和元素值。

它的特点是,非零元在表中按行序有序存储,因此便于进行依行顺序处理的矩阵运算。

当矩阵中的非0元素少于1/3时即可节省存储空间。

(1)稀疏矩阵的三元组顺序表存储表示方法#define MAXSIZE 12500 // 假设非零元个数的最大值为12500typedef struct {int i, j; // 该非零元的行下标和列下标ElemType e; //非零元素的值} Triple; // 三元组类型typedef union { //共用体Triple data[MAXSIZE + 1]; // 非零元三元组表,data[0]未用int mu, nu, tu; // 矩阵的行数、列数和非零元个数} TSMatrix; // 稀疏矩阵类型(2)求转置矩阵的操作◆用常规的二维数组表示时的算法for (col=1; col<=nu; ++col)for (row=1; row<=mu; ++row)T[col][row] = M[row][col];其时间复杂度为: O(mu×nu)◆用三元组顺序表表示时的快速转置算法Status FastTransposeSMatrix(TSMatrix M, TSMatrix &T) {// 采用三元组顺序表存储表示,求稀疏矩阵M的转置矩阵TT.mu = M.nu; T.nu = M.mu; T.tu = M.tu;if (T.tu) {for (col=1; col<=M.nu; ++col) num[col] = 0;for (t=1; t<=M.tu; ++t) ++num[M.data[t].j];// 求M 中每一列所含非零元的个数cpot[1] = 1;for (col=2; col<=M.nu; ++col) cpot[col] = cpot[col-1] + num[col-1];// 求M 中每一列的第一个非零元在b.data 中的序号for (p=1; p<=M.tu; ++p) { // 转置矩阵元素col = M.data[p].j; q = cpot[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; ++cpot[col];} // for} // ifreturn OK;} // FastTransposeSMatrix其时间复杂度为: O(mu +nu)3.行逻辑联接的顺序表——压缩存储稀疏矩阵方法之二(链接存储结构)行逻辑联接的顺序表:稀疏矩阵中为了随机存取任意一行的非0元素,需要知道每一行的第一个非0元素在三元组表中的位置,因此将上述快速转置算法中指示行信息的辅助数组cpot 固定在稀疏矩阵的存储结构中,让每一行对应一个单链表,每个单链表都有一个表头指针,这种“带行链接信息”的三元组表即称为行逻辑联接的顺序表。

三元组表示稀疏矩阵的转置(一般算法和快速算法)

三元组表示稀疏矩阵的转置(一般算法和快速算法)

一、设计要求1.1 问题描述稀疏矩阵是指那些多数元素为零的矩阵。

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

求一个稀疏矩阵A的转置矩阵B。

1.2需求分析(1)以“带行逻辑链接信息”的三元组顺序表表示稀疏矩阵,实现稀疏矩阵的转置运算。

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

(3)首先提示用户输入矩阵的行数、列数、非零元个数,再采用三元组表示方法输入矩阵,然后进行转置运算,该系统可以采用两种方法,一种为一般算法,另一种为快速转置算法。

(4)程序需要给出菜单项,用户按照菜单提示进行相应的操作。

二、概要设计2.1存储结构设计采用“带行逻辑链接信息”的三元组顺序表表示矩阵的存储结构。

三元组定义为:typedef struct{int i;//非零元的行下标int j;//非零元的列下标ElemType e; //非零元素值}Triple;矩阵定义为:Typedef struct{Triple data[MAXSIZE+1]; //非零元三元组表int rpos[MAXRC+1]; //各行第一个非零元的位置表int mu,nu,tu; //矩阵的行数、列数和非零元个数}RLSMatrix;例如有矩阵A,它与其三元组表的对应关系如图2.2 系统功能设计本系统通过菜单提示用户首先选择稀疏矩阵转置方法,然后提示用户采用三元组表示法输入数据创建一个稀疏矩阵,再进行矩阵的转置操作,并以通常的阵列形式输出结果。

主要实现以下功能。

(1)创建稀疏矩阵。

采用带行逻辑连接信息的三元组表表示法,提示用户输入矩阵的行数、列数、非零元个数以及各非零元所在的行、列、值。

(2)矩阵转置。

<1>采用一般算法进行矩阵的转置操作,再以阵列形式输出转置矩阵B。

<2>采用快速转置的方法完成此操作,并以阵列形式输出转置矩阵B。

三、模块设计3.1 模块设计程序包括两个模块:主程序模块、矩阵运算模块。

数据结构授课教案-第5章

在PASCAL、C语言中,数组就是按行优先顺序存储的。
⑵列优先顺序——将数组元素按列向量排列,第j+1个列向量紧接在第j个列向量之后。
在FORTRAN语言中,数组就是按列优先顺序存储的。以行为主序:
LOC(aij)=LOC(a00)+(i*n+j)*l
以列为主序:
LOC(aij)=LOC(a00)+(j*m+n)*l
2)写元素操作
操作方法根据其存储结构决定
5.2数组的顺序表示和实现
数组一旦建立,结构中的元素个数和元素间的关系就不再发生变化。因此,一般都是采用顺序存储的方法来表示数组。
由于计算机的内存结构是一维的,因此用一维内存来表示多维数组,就有次序约定的问题。
通常有两种顺序存储方式:
⑴行优先顺序——将数组元素按行排列,第i+1个行向量紧接在第i个行向量后面。
不失一般性,以行序为主序存储其下三角的元素。
例:5阶对称方阵及它的压缩存储
一般地,设对称矩阵A的下三角部分以行为主序顺序存储到一个向量SA[n(n+1)/2]中,
则sa[k]和aij之间的下标对应关系为:
k=i(i-1)/2+j-1当i>=j
j(j-1)/2+i-1当i<j
2、三角矩阵
形下图的矩阵称为三角矩阵,其中c为某个常数。其中(a)为上三角矩阵:主对角线以下均为同一个常数;(b)为下三角矩阵,主对角线以上为同一个常数;在大多数情况下,三角矩阵常数为零。
C = (e) C中只有一个元素e,表长为1;
D = (A,B,C,f ) D的表长为4,它的前三个元素A,B,C广义表,第四个是单元素;
E=( a ,E )递归表.

实现稀疏矩阵(采用三元组表示)的基本运算实验报告

实现稀疏矩阵(采用三元组表示)的基本运算实验报告一实验题目: 实现稀疏矩阵(采用三元组表示)的基本运算二实验要求:(1)生成如下两个稀疏矩阵的三元组 a 和 b;(上机实验指导 P92 )(2)输出 a 转置矩阵的三元组;(3)输出a + b 的三元组;(4)输出 a * b 的三元组;三实验内容:稀疏矩阵的抽象数据类型:ADT SparseMatrix {数据对象:D={aij| i = 1,2,3,….,m; j =1,2,3,……,n;ai,j∈ElemSet,m和n分别称为矩阵的行数和列数}数据关系: R={ Row , Col }Row ={<ai,j ,ai,j+1> | 1≤i≤m , 1≤j ≤n-1}Col ={<a i,j , a i+1,j >| 1≤i≤m-1,1≤j ≤n}基本操作:CreateSMatrix(&M)操作结果:创建稀疏矩阵 M PrintSMatrix(M)初始条件:稀疏矩阵M已经存在操作结果:打印矩阵M DestroySMatrix(&M)初始条件:稀疏矩阵M已经存在操作结果:销毁矩阵M CopySMatrix(M, &T)初始条件:稀疏矩阵M已经存在操作结果:复制矩阵M到TAddSMatrix(M, N, &Q)初始条件:稀疏矩阵M、N已经存在操作结果:求矩阵的和Q=M+NSubSMatrix(M, N, &Q)初始条件:稀疏矩阵M、N已经存在操作结果:求矩阵的差Q=M-N TransposeSMatrix(M, & T)初始条件:稀疏矩阵M已经存在操作结果:求矩阵M的转置T MultSMatrix(M, N, &Q)初始条件:稀疏矩阵M已经存在操作结果:求矩阵的积Q=M*N}ADT SparseMatrix存储结构的定义#define N 4typedef int ElemType;#define MaxSize 100 =i;[].c=j;[].d=A[i][j];++;}}}void DispMat(TSMatrix t){int i;if <=0)return;printf("\t%d\t%d\t%d\n",,,;printf("\t------------------\n");for (i=0;i<;i++)printf("\t%d\t%d\t%d\n",[i].r,[i].c,[i].d); }解题思路:1.转置矩阵:只要判定原矩阵有值,那么只要遍历一遍原矩阵,把原来矩阵中非0元素行列变换一下赋值到新的矩阵中即可。

第11讲 稀疏矩阵


1 1 2 3 3
2 5 2 1 4
14 -5 -7 36 28
1 2 2 4 5
3 1 2 3 1
36 14 -7 28 -5
a.data
b.data
Status TransposeSMatrix(TSMatrix M, TSMatrix &T){ //采用三元组表存储稀疏矩阵 求稀疏矩阵M的转置矩阵T 采用三元组表存储稀疏矩阵, //采用三元组表存储稀疏矩阵,求稀疏矩阵M的转置矩阵T mu=M.nu; nu=M.mu; tu=M.tu; //互换行列数 T.mu=M.nu; T.nu=M.mu; T.tu=M.tu; //互换行列数 (T. if (T.tu) { q=1 q=1; for(col=1 col<=M.nu; //每一列分别处理 for(col=1;col<=M.nu; ++col) //每一列分别处理 for(p=1 p<=M.tu; //按行扫描三元组表 for(p=1; p<=M.tu; ++p) //按行扫描三元组表 if(M.data[p]. if(M.data[p].j= =col) { T.data[q].i=M.data[p].j; data[q].i=M.data[p]. data[q].j=M.data[p]. T.data[q].j=M.data[p].i; data[q].e=M.data[p]. T.data[q].e=M.data[p].e; ++q } } OK; return OK; } //TransposeSMatrix
解决问题的原则: 解决问题的原则:
尽可能少存或不存零值元素 尽可能减少没有实际意义的运算 运算方便 即: 尽可能快地找到下标值(i,j)对应的非零值元 尽可能快地找到下标值(i,j)对应的非零值元 (i 尽可能快地找到同一行或同一列的非零值元

稀疏矩阵的三元组表的类型定义

稀疏矩阵的三元组表是一个用于存储非零元素的数据结构,它由三个部分组成:行号、列号和非零元素值。

每个非零元素都用一个三元组来表示,这些三元组按照某种顺序(通常是行优先或列优先)存储在一个线性表中。

这个线性表就是稀疏矩阵的三元组表。

在类型定义上,稀疏矩阵的三元组表可以看作是一个包含多个三元组的数组或列表,其中每个三元组都是一个包含三个元素的子数组或子列表。

这三个元素分别是非零元素的行号、列号和非零元素值。

在存储结构上,稀疏矩阵的三元组表通常采用顺序存储结构,即按照某种顺序将三元组存储在一个连续的存储空间中。

这种存储结构有利于快速访问和修改非零元素,并且可以节省存储空间。

总之,稀疏矩阵的三元组表是一种用于存储稀疏矩阵中非零元素的数据结构,它由多个三元组组成,每个三元组包含非零元素的行号、列号和非零元素值。

这些三元组按照某种顺序存储在一个线性表中,通常采用顺序存储结构。

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

当稀疏矩阵A和B均以三元组表作为存储结构时,试写出矩阵相加的算法,其结果存放在
三元组表C中。

解:
矩阵相加就是将两个矩阵中同一位置的元素值相加。由于两个稀疏矩阵的非零元素按三
元组表形式存放,在建立新的三元组表C时,为了使三元组元素仍按行优先排列,所以每
次插入的三元组不一定是A的,按照矩阵元素的行列去找A中的三元组,若有,则加入C,
同时,这个元素如果在B中也有,则加上B的这个元素值,否则这个值就不变;如果A中没
有,则找B,有则插入C,无则查找下一个矩阵元素。

#define MaxSize 10 //用户自定义
typedef int DataType; //用户自定义
typedef struct
{ //定义三元组
int i,j;
DataType v;
}TriTupleNode;

typedef struct
{ //定义三元组表
TriTupleNode data[MaxSize];
int m,n,t;//矩阵行,列及三元组表长度
}TriTupleTable;

//以下为矩阵加算法
void AddTriTuple( TriTupleTable *A, TriTupleTable *B, TriTupleTable *C)
{//三元组表表示的稀疏矩阵A,B相加
int k,l;
DataType temp;
C-> m=A-> m;//矩阵行数
C-> n=A-> n;//矩阵列数
C-> t=0; //三元组表长度
k=0; l=0;
while (k t&&l t)
{if((A-> data[k].i==B-> data[l].i)&&(A-> data[k].j==B-> data[l].j))
{temp=A-> data[k].v+B-> data[l].v;
if (!temp)//相加不为零,加入C
{C-> data[c-> t].i=A-> data[k].i;
C-> data[c-> t].j=A-> data[k].j;
C-> data[c-> t++].v=temp;
}
k++;l++;
}
if ((A-> data[k].i==B-> data[l].i)&&(A-> data[k].j data[l].j))
||(A-> data[k].i data[l].i)//将A中三元组加入C
{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))
||(A-> data[k].i> B-> data[l].i)//将B中三元组加入C
{C-> data[c-> t].i=B-> data[l].i;
C-> data[c-> t].j=B-> data[l].j;
C-> data[c-> t++].v=B-> data[l].v;
l++;
}
}
while (k t)//将A中剩余三元组加入C
{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++;
}
while (l t)//将B中剩余三元组加入C
{C-> data[c-> t].i=B-> data[l].i;
C-> data[c-> t].j=B-> data[l].j;
C-> data[c-> t++].v=B-> data[l].v;
l++;
}
}

相关文档
最新文档