利用三元组表对稀疏矩阵实现加法减法及转置

合集下载

稀疏矩阵三元组快速转置(转poklau123写的很清楚)

稀疏矩阵三元组快速转置(转poklau123写的很清楚)

稀疏矩阵三元组快速转置(转poklau123写的很清楚)关于稀疏矩阵的快速转置法,⾸先得明⽩其是通过对三元表进⾏转置。

如果误以为是对矩阵进⾏转置,毫⽆疑问就算你想破脑袋也想不出个所以然,别陷⼊死胡同了!对于⼀个三元表,⾏为i,列为j,值为v。

需将其i与j的值对调才能得到新的三元表,但是如果直接进⾏转换,得到的新的三元表的顺序是混乱的,不符合三元表的规则。

所以,课本⾸先介绍了⼀个⽤扫描来转置的算法(这个算法⽐较容易,在这⾥我就不说了),但是这个转置算法的时间复杂度太⾼,于是就有了接下来的快速转置算法。

要你对⼀个三元表进⾏步骤最少的转置,你可能会想,如果知道三元表中每⼀项在转置后的新的三元表中的位置,然后直接放进去,岂不是极⼤的缩⼩了时间复杂度?没错!快速转置法正是基于这种思想⽽设计的。

那么如何知道三元表中某⼀项的位置呢?在课本98页的a.data这个三元表可以看到,j为列号,在转置后即为新的三元表的⾏号,三元表正是按照⾏序进⾏排列的,⽽j=1有2个、j=2有2个、j=3有2个、j=4有1个、j=6有1个。

根据这些数据按照从⼩到⼤排列,j=1的项在新的三元表中应占据第1、2位,j=2的项在新的三元表中应占据第3、4位,j=3的项在新的三元表中应占据第5、6位,j=4应占据第7位,j=6应占据第8位。

接下来就轻松多了,转置的时候直接从第⼀项读起,读取其j值,⽐如课本中a.data这个三元表的第⼀项的j值为2,因为j=2占据第3、4位,所以应该从第三位开始放,接下来如果读取的某⼀项的j值也是2,就放在第4位。

因为j=2的项只有两个,所以第5位绝对不会被j=2的项占据,第5、6项本来就是留给j=3的。

再⽐如当读到j=6的那项时,第8位是留给它的,就可以直接放进第8位了。

这样,读取每⼀项,都能在三元表中找到相应的位置,这就是稀疏矩阵快速转置的原理。

当然,上⾯只是快速转置的原理,要实现它,就要设计算法来实现了。

三元组顺序结构实现稀疏矩阵相加,行序优先(Java语言描述)

三元组顺序结构实现稀疏矩阵相加,行序优先(Java语言描述)

三元组顺序结构实现稀疏矩阵相加,⾏序优先(Java语⾔描述)不⽤⼗字链表也可以稀疏矩阵相加时间复杂度最坏情况达到O(tuA + tuB);思路⽐较简单就不赘述了,代码如下:三元组:package ⾏逻辑链接的顺序表实现稀疏矩阵的相乘;public class Triple<T> {int row,col;T v;public Triple(){}public Triple(int row,int col, T v){this.row = row;this.col = col;this.v = v;}}构建矩阵存储结构:package ⾏逻辑链接的顺序表实现稀疏矩阵的相乘;public class Mat {final int MAXSIZE = 10;int mu,nu,tu;int rpos[] = new int[MAXSIZE + 1];//各⾏第⼀个⾮零元的位置表Triple<Integer> data[] = new Triple[MAXSIZE + 1];//Java不⽀持泛型数组public Mat(int mu,int nu,int tu){this.mu = mu;this.nu = nu;this.tu = tu;for(int i=1; i<=MAXSIZE; i++)data[i] = new Triple();}//三元组矩阵的输出public void display(){int i,j,k,m,n,count = 0;for(i=1; i<=mu; i++){for(j=1; j<=nu; j++){for(k=1; k<=tu; k++){if(i==data[k].row && j==data[k].col){System.out.print(data[k].v + " ");count = -1;break;}}if(count != -1)System.out.print("0 ");count = 0;}System.out.println();}}}相加:package ⾏逻辑链接的顺序表实现稀疏矩阵的相乘;import java.util.*;public class AddMat {public static void main(String[] args) {/** @author 王旭* @time 2014/10/14/23:50**/Scanner scan = new Scanner(System.in);int muA,nuA,tuA,muB,nuB,tuB;System.out.println("请输⼊A矩阵的⾏,列,⾮零元的个数:");muA = scan.nextInt();nuA = scan.nextInt();tuA = scan.nextInt();Mat A = new Mat(muA,nuA,tuA);System.out.println("请输⼊A矩阵的三元组:");for(int i=1; i<=tuA; i++){A.data[i].row = scan.nextInt();A.data[i].col = scan.nextInt();A.data[i].v = scan.nextInt();}System.out.println("A矩阵为:");A.display();System.out.println("请输⼊B矩阵的⾏,列,⾮零元的个数:");muB = scan.nextInt();nuB = scan.nextInt();tuB = scan.nextInt();Mat B = new Mat(muB,nuB,tuB);System.out.println("请输⼊B矩阵的三元组:");for(int i=1; i<=tuB; i++){B.data[i].row = scan.nextInt();B.data[i].col = scan.nextInt();B.data[i].v = scan.nextInt();}System.out.println("B矩阵为:");B.display();Mat C = new Mat(muA,nuA,1);add(A,B,C);System.out.println("相加后的矩阵C为:");C.display();}public static void add(Mat A, Mat B, Mat C){int k,l,temp;//C = new Mat(A.mu,A.nu,1);k = 1;l = 1;while(k<A.tu && l<B.tu){if((A.data[k].row == B.data[l].row) && (A.data[k].col == B.data[l].col)){temp = A.data[k].v + B.data[l].v;if(temp != 0){C.data[C.tu].row = A.data[k].row;C.data[C.tu].col = A.data[k].col;C.data[C.tu].v = temp;C.tu++;}k++;l++;}if(( (A.data[k].row == B.data[l].row) && (A.data[k].col < B.data[l].col) ) || (A.data[k].row<B.data[l].row)){ C.data[C.tu].row = A.data[k].row;C.data[C.tu].col = A.data[k].col;C.data[C.tu].v = A.data[k].v;C.tu++;k++;}if(( (B.data[l].row == A.data[k].row) && (B.data[l].col < A.data[k].col) ) || (B.data[l].row<A.data[k].row)){ C.data[C.tu].row = B.data[l].row;C.data[C.tu].col = B.data[l].col;C.data[C.tu].v = B.data[l].v;C.tu++;l++;}}}}。

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

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

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

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

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中。

三元组实现稀疏矩阵加减乘

三元组实现稀疏矩阵加减乘

#include<stdio.h>#include<stdlib.h>#define MAXSIZE 12500//三元组结构typedef struct {int i,j; //矩阵行下标和列下标int e; //值}Triple;//矩阵结构typedef struct{Triple data[MAXSIZE+1];int rpos[MAXSIZE+1]; //这是存放各行第一非零元在矩阵中的位置int mu,nu,tu; //矩阵的行数、列数、非零元个数}Matrix;void Init(Matrix* M);void Add(Matrix* M,Matrix* T,Matrix* G);void Jian(Matrix* M,Matrix* T,Matrix* G);void Cheng(Matrix* M,Matrix* T,Matrix* G);void Cheng(Matrix* M,Matrix* T,Matrix* G);void PrintMatrix(Matrix* M);//2、初始化矩阵void Init(Matrix* M){int i;if(M->mu < 1 || M->nu < 1 || M->tu > M->mu*M->nu){printf("出错!\n"); //如果矩阵的行数、列数不符合要求,打印出错}for(i=1;i<=M->tu;i++) //data[0]不用{printf("第%d个非零元的行号:",i); //以下为数据初始化scanf("%d",&M->data[i].i);printf("第%d个非零元的列号:",i);scanf("%d",&M->data[i].j);printf("第%d个非零元的元素值:",i);scanf("%d",&M->data[i].e);}printf("\n");printf("您创建的矩阵如下:\n");PrintMatrix(M);}//3、矩阵相加void Add(Matrix* M,Matrix* T,Matrix* G){G->mu = M->mu; //因为加减运算必须维数相等,所以M、T行、列数相等,初始化第三方矩阵的行、列数。

实验四稀疏矩阵三元组下转置

实验四稀疏矩阵三元组下转置

实验四、稀疏矩阵三元组下转置一、实验内容将稀疏矩阵中的每个非零元素aij表示为(i, j, v),即(行号,列号,非零元素值).称为三元组表示法。

用结构类型来描述三元组。

将稀疏矩阵的非零元素对应的三元组所构成的集合,按行优先的顺序排列成一个线性表。

在稀疏矩阵用三元组顺序表存储结构下,实现稀疏矩阵转置,得到其转置矩阵的三元组顺序表存储表示。

要求:1)采用转置算法Ⅰ:直接取,顺序存2)采用转置算法Ⅱ:顺序取,直接存。

要使用两个辅助一维数组,分别先计算出原矩阵每一列的非零元个数以及每一列的第一个非零元在转置矩阵的三元组顺序表中的存储位置。

二、实验目的1. 掌握稀疏矩阵的三元组顺序表存储结构;2. 掌握稀疏矩阵转置算法Ⅰ;3. 掌握稀疏矩阵转置算法Ⅱ三、实验代码//文件:SparseMatrix.htemplate <class T>struct element{int row, col; //行数、列数T item; //元素值};const int MaxTerm=100;template <class T>class SparseMatrix{ public:SparseMatrix(){};SparseMatrix(int intmu,int intnu,int inttu,element<T> datatemp[]);//有参构造函数,初始化稀疏矩阵~SparseMatrix(){}; //析构函数,释放存储空间element<T> GetMatrix(int intnumber);//输出下标对应的数组元素void Prt();//显示三元组顺序表void Trans1(SparseMatrix<T> &B);//直接取、顺序存的矩阵转置算法void Trans2(SparseMatrix<T> A, SparseMatrix<T> &B);//顺序取、直接存的矩阵转置算法private:element<T> data[MaxTerm]; //矩阵非零元素int mu, nu, tu; //行数、列数、非零元个数};// 文件:SparseMatrix.cpp#include "SparseMatrix.h" //引用三元组顺序表的头文件#include <string> //引用string库函数的头文件using namespace std;//指出后续的所有的程序语句都在名字空间std内/*前置条件:三元组顺序表不存在输入:三元组顺序表的行数(intmu)、列数(intnu)、非零元个数(inttu)、初始三元组(datatemp[])功能:三元组顺序表的初始化输出:无后置条件:建立一个三元组顺序表*/template <class T>SparseMatrix<T>::SparseMatrix(int intmu,int intnu,int inttu,element<T> datatemp[]){if (inttu >MaxTerm ) throw "构造函数的初始化参数不正确";mu = intmu;nu = intnu;tu = inttu;for(int i=0;i<inttu;i++){data[i] = datatemp[i];}}/*前置条件:三元组顺序表已存在输入:下标(intnumber)功能:读取这组下标对应的数组元素输出:对应元素后置条件:三元组顺序表不变*/template <class T>element<T> SparseMatrix<T>::GetMatrix(int intnumber){if(intnumber>=tu || intnumber < 0) throw "输入位置不正确";return data[i];}/*前置条件:无输入:无功能:显示三元组顺序表输出:无后置条件:建立一个三元组顺序表*/template <class T>void SparseMatrix<T>::Prt(){for(int i=0;i<tu;i++){cout<<data[i].row<<" "<<data[i].col<<" "<<data[i].item<<"\n";}}/*前置条件:无输入:待转置的源三元组顺序表(A)和目标三元组顺序表(B)的引用功能:对三元组顺序表进行转置输出:无后置条件:三元组顺序表A的转置结果放在了B中*/template <class T>void SparseMatrix<T>::Trans1(SparseMatrix<T> &B){int pb,pa;B.mu=this->nu; B.nu=this->mu; B.tu=this->tu;//设置行数、列数、非零元素个数 if (B.tu>0) //有非零元素则转换{pb = 0;for (int col=0; col<this->nu; col++) //依次考察每一列 for (pa=0; pa<this->tu; pa++) //在A中扫描整个三元组表if (this->data[pa].col==col ) //处理col列元素{B.data[pb].row= this->data[pa].col ;B.data[pb].col= this->data[pa].row ;B.data[pb].item= this->data[pa].item;pb++;}}}/*前置条件:无输入:待转置的源三元组顺序表(A)和目标三元组顺序表(B)的引用功能:对三元组顺序表进行转置输出:无后置条件:三元组顺序表A的转置结果放在了B中*/template <class T>void SparseMatrix<T>::Trans2(SparseMatrix<T> A, SparseMatrix<T> &B){int i,j,k,num[MaxTerm],cpot[MaxTerm];B.mu=A.nu; B.nu=A.mu; B.tu=A.tu;//设置行数、列数、元素个数if (B.tu>0) //有非零元素则转换{for (i=0; i<A.nu; i++) num[i]=0; //A中每一列非零元素的个数初始化为0 for (i=0; i<A.tu; i++)//求矩阵A中每一列非零元素的个数{ j= A.data[i].col; //取三元组的列号num[j]++;}cpot[0]=0; //A中第0列第一个非零元素在B中的位置为0for (i=1; i<A.nu; i++) //求A中每一列第一个非零元素在B中的下标cpot[i]= cpot[i-1]+num[i-1];for (i=0; i<A.tu; i++)//扫描三元组表A{j=A.data[i].col; //当前三元组的列号k=cpot[j]; //当前三元组在B中的下标B.data[k].row= A.data[i].col ;B.data[k].col= A.data[i].row ;B.data[k].item= A.data[i].item;cpot[j]++; //预置同一列的下一个三元组的下标}}}//文件:SparseMatrixMain.cpp#include <iostream> //引用输入输出流库函数的头文件#include "SparseMatrix.cpp" ////引用广义表的成员函数文件#include <string> //引用string库函数的头文件using namespace std; //指出后续的所有的程序语句都在名字空间std内int main(){try{//建立一个element<int>类型的数组(A)element<int> A[7]={{0,0,15},{0,3,22},{0,5,-15},{1,1,11},{1,2,3},{2,3,6},{4,0,91}};SparseMatrix<int> sparsematrixB;//构造三元组顺序表来存储转置后的三元组顺序表 SparseMatrix<int> sparsematrixA(5,6,7,A);//构造三元组顺序表cout<<"原三元组顺序表如下:"<<"\n";sparsematrixA.Prt();//显示三元组顺序表sparsematrixA.Trans1(sparsematrixB);cout<<"使用直接取、顺序存转置算法转置后的三元组顺序表如下:"<<"\n";sparsematrixB.Prt();//显示三元组顺序表sparsematrixA.Trans2(sparsematrixA,sparsematrixB);cout<<"使用顺序取、直接存转置算法转置后的三元组顺序表如下:"<<"\n";sparsematrixB.Prt();//显示三元组顺序表}catch(char* e){ cout<<e; }return 0;}四、调试和运行结果在完成算法的程序实现后,用任意的一组数据来加以测试运行,对运行结果加以分析,检查运行结果是否正确。

稀疏矩阵的存储和快速转置实验报告

稀疏矩阵的存储和快速转置实验报告

福建工程学院课程设计课程:数据结构题目:稀疏矩阵的快速转置专业:运算机类班级:座号:姓名:2021年6月25日实验题目:稀疏矩阵的快速转置一、要解决的问题利用三元组表存储稀疏矩阵,利用快速转置算法进行转置,并输出转置之前和以后的三元组表和矩阵。

二、算法大体思想描述:由于稀疏矩阵的非零元素较少,零元素较多,因此只需存储其非零元素。

因此能够成立一个三元组表,别离保存稀疏矩阵的非零元素的行号、列号和元素值。

对稀疏矩阵进行快速转置是能够引入两个向量num[n+1],cpot[n+1],别离标记矩阵中第col列的非零元素个数和第一个非零元素在转置后的矩阵的位置;再扫描三元组表,找到非零元素,直接对其在转置后的矩阵所在的位置上进行修改,以节省时刻。

三、详细设计⒈元素类型,结点类型typedef struct {int i,j;int e;}Triple;typedef struct{Triple data[MAXSIZE+1];int mu,nu,tu;} Tsmatrix;2.对抽象数据类型中的部份大体操作的伪码算法如下:Tsmatrix * creatarray(Tsmatrix *M){ int m,n,p=1;int c;printf("please input the array A:\n");for(m=1;m<=a;m++)for(n=1;n<=b;n++){ scanf("%d",&c);if(c!=0){ M->data[p].e=c;M->data[p].i=m;M->data[p].j=n;p++;}}M->tu=p; M->mu=a; M->nu=b;printf("yuan lai san yuan zu de biao shi wei :\n\n");for(m=1;m<=M->tu;m++)printf("%3d%3d%3d\t",M->data[m].i,M->data[m].j,M->data[m].e);printf("\n");return M;}/*三元组快速转置*/Tsmatrix * fasttrans(Tsmatrix *M,Tsmatrix *T){ int p,col,q,t,m;int num[100];int cpot[100];T->mu=M->nu; T->nu=M->mu; T->tu=M->tu;if(T->tu!=0){for(col=1;col<=M->nu;col++) num[col]=0;for(t=1;t<=M->tu;t++) ++num[M->data[t].j];cpot[1]=1;for(col=2;col<=M->nu;col++) cpot[col]=cpot[col-1]+num[col-1];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];}}printf("\n\nzhuan zhi hou de san yuan zu biao shi wei :\n\n");for(m=1;m<=T->tu;m++)printf("%3d%3d%3d\t",T->data[m].i,T->data[m].j,T->data[m].e);printf("\n");return T;}/*输出三元组函数*/void print(Tsmatrix *T,int x,int y){ int m,n,p=1;int d;for(m=1;m<=x;m++){ printf("\n");for(n=1;n<=y;n++){ if(T->data[p].i==m&&T->data[p].j==n){ d=T->data[p].e;p++;}else d=0;printf("%6d",d);}}}}3.主函数和其他函数的伪码算法void main(){ Tsmatrix *M,*T;M=(Tsmatrix *)malloc(sizeof(Tsmatrix));T=(Tsmatrix *)malloc(sizeof(Tsmatrix));printf("please input array's row and col:\n");scanf("%d%d",&a,&b); /*输入行列数*/ M=creatarray(M); /*创建稀疏矩阵*/printf("you had creat the array:\n");print(M,a,b); /*输出创建好的三元组*/T=fasttrans(M,T); /*将三元组转置*/printf("the trans array is:\n");print(T,b,a);getch();}4、模块结构及功能}四、源程序清单:#include<>#define MAXSIZE 100typedef struct {int i,j;int e;}Triple;typedef struct{Triple data[MAXSIZE+1];int mu,nu,tu;} Tsmatrix;int a,b; /*概念全局变量数组的行数a和列数b*//*用数组创建三元组*/Tsmatrix * creatarray(Tsmatrix *M){ int m,n,p=1;int c;printf("please input the array A:\n");for(m=1;m<=a;m++)for(n=1;n<=b;n++){ scanf("%d",&c);if(c!=0){ M->data[p].e=c;M->data[p].i=m;M->data[p].j=n;p++;}}M->tu=p; M->mu=a; M->nu=b;printf("yuan lai san yuan zu de biao shi wei :\n\n");for(m=1;m<M->tu;m++)printf("%3d%3d%3d\t",M->data[m].i,M->data[m].j,M->data[m].e);printf("\n");return M;}/*三元组快速转置*/Tsmatrix * fasttrans(Tsmatrix *M,Tsmatrix *T){ int p,col,q,t,m;int num[100];int cpot[100];T->mu=M->nu; T->nu=M->mu; T->tu=M->tu;if(T->tu!=0){for(col=1;col<=M->nu;col++) num[col]=0;for(t=1;t<=M->tu;t++) ++num[M->data[t].j];cpot[1]=1;for(col=2;col<=M->nu;col++) cpot[col]=cpot[col-1]+num[col-1];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];}}printf("\n\nzhuan zhi hou de san yuan zu biao shi wei :\n\n");for(m=1;m<T->tu;m++)printf("%3d%3d%3d\t",T->data[m].i,T->data[m].j,T->data[m].e);printf("\n");return T;}/*输出三元组函数*/void print(Tsmatrix *T,int x,int y){ int m,n,p=1;int d;for(m=1;m<=x;m++){ printf("\n");for(n=1;n<=y;n++){ if(T->data[p].i==m&&T->data[p].j==n){ d=T->data[p].e;p++;}else d=0;printf("%6d",d);}}}void main(){ Tsmatrix *M,*T;M=(Tsmatrix *)malloc(sizeof(Tsmatrix));T=(Tsmatrix *)malloc(sizeof(Tsmatrix));printf("please input array's row and col:\n");scanf("%d%d",&a,&b); /*输入行列数*/M=creatarray(M);printf("you had creat the array:\n");print(M,a,b);T=fasttrans(M,T);printf("the trans array is:\n");print(T,b,a);getch();}五、测试数据及测试结果:(1)我输入的稀疏矩阵为:(2)回车显示的结果是:六、课程设计总结及心得体会:通过本次课程设计,我对有关稀疏矩阵及其三元组表的知识做了温习和巩固。

稀疏矩阵三元组实现矩阵转置算法实验报告

稀疏矩阵三元组实现矩阵转置算法实验报告

稀疏矩阵三元组实现矩阵转置算法实验报告实验三稀疏矩阵的三元组表示实现矩阵转置算法学院专业班学号姓名一.实习目的1.掌握稀疏矩阵的三元组顺序表存储表示;2.掌握稀疏矩阵三元组表示的传统转置算法的实现;3.掌握稀疏矩阵三元组表示的快速转置算法的实现;二.实习内容1.稀疏矩阵的按三元组形式输入,即按行序输入非零元的行号、列号、值,实现传统转置算法,输出按通常的阵列形式输出。

2.稀疏矩阵的按三元组形式输入,即按行序输入非零元的行号、列号、值,实现快速转置算法,输出按通常的阵列形式输出。

三.实验步骤1.三元组的定义#define MAX_SIZE 100 // 非零元个数的最大值struct Triple{int i,j; // 行下标,列下标ElemType e; // 非零元素值};struct TSMatrix{struct Triple data[MAX_SIZE+1]; // 非零元三元组表,data[0]未用int mu,nu,tu; // 矩阵的行数、列数和非零元个数};2.创建稀疏矩阵M (按三元组形式输入,即按行序输入非零元的行号、列号、值)3. 编写三元组传统转置函数。

4. 编写三元组快速转置函数。

4. .主函数(1)程序代码#include "stdio.h"#include "stdlib.h"#define MAX_SIZE 100 // 非零元个数的最大值typedef int ElemType;struct Triple{int i,j; // 行下标,列下标ElemType e; // 非零元素值};struct TSMatrix{struct Triple data[MAX_SIZE+1]; // 非零元三元组表,data[0]未用int mu,nu,tu; // 矩阵的行数、列数和非零元个数};int CreateSMatrix(TSMatrix &M){ // 创建稀疏矩阵Mint i,m,n;ElemType e;int k;printf("请输入矩阵的行数,列数,非零元素数:");scanf("%d,%d,%d",&M.mu,&M.nu,&M.tu);if(M.tu>MAX_SIZE)return -1;M.data[0].i=0; // 为以下比较顺序做准备for(i=1;i<=M.tu;i++){do{printf("请按行序顺序输入第%d个非零元素所在的行(1~%d),列(1~%d),元素值:",i,M.mu,M.nu);scanf("%d,%d,%d",&m,&n,&e);//输入非零元的行号、列号、元素值k=0;if(m<1||m>M.mu||n<1||n>M.nu)// 行或列超出范围k=1;if(m<M.data[i-1].i||m==M.data[i-1].i&&n<=M.d ata[i-1].j) // 行或列的顺序有错k=1;}while(k);M.data[i].i =m; // 将m,n,e 填入MM.data[i].j =n;M.data[i].e =e;}return 1;}void PrintSMatrix(TSMatrix M){ // 按矩阵形式输出Mint i,j,k=1;Triple *p=M.data;p++; // p指向第1个非零元素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所指元素的值p++; // p指向下一个元素k++; // 计数器+1}else // p所指元素不是当前处理元素printf("%3d",0); // 输出0printf("\n");}}void TransposeSMatrix(TSMatrix M,TSMatrix &T){ // 求稀疏矩阵M的转置矩阵T。

试验二利用三元组表实现矩阵相加

试验二利用三元组表实现矩阵相加

实验二利用三元组表实现矩阵相加一、预备知识1.稀疏矩阵的三元组表压缩存储结构2.稀疏矩阵的三元组表表示方法下的相加算法二、实验目的1.掌握稀疏矩阵的三元组表存储结构的实现2.实现稀疏矩阵的三元组表表示下的相加算法三、实验内容1.编写程序,实现利用三元组表进行两个稀疏矩阵相加的算法。

要求:(1)随机产生两个可相加的稀疏矩阵(二维);(2)将产生的稀疏矩阵用两个三元组表的顺序存储结构存储;(3)将两稀疏矩阵相加的结果存储在第三个三元组表中。

2.沿用实验一编写的操作菜单进行上述的操作。

四、实验说明1.三元组表的类型定义#define MAXSIZE 1000//非零元素个数的最大值typedef struct{int row,col;//非零元素的行下标和列下标ElemType e;//非零元素的值} Triple;typedef struct{Triple data[MAXSIZE+1];//非零元素的三元组表,data[0]未用int mu,nu,tu;//矩阵的行数、列数和非零元素个数} TSMatrix;五、注意问题1.首先应输入矩阵的行数和列数,并判别给出的两个矩阵的行、列数对于所要求作的运算是否相匹配。

可设矩阵的行数和列数均不超过20。

2.程序可以对三元组的输入顺序加以限制,例如,按行优先,以便提高计算效率。

3.在用三元组表示稀疏矩阵时,相加或相减所得结果矩阵应该另生成,相加结果矩阵也可用二维数组存放。

4.三元组表是线性表的一种应用,通过它可以更好地理解线性表的存储结构。

同时矩阵又是图的重要的存储方式,所以这个实验对更好地掌握线性表对将来对图的理解都有极大的帮助。

三元组顺序表表示的稀疏矩阵加法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类,其初始化方法接受稀疏矩阵的行数、列数和三元组顺序表表示的数据。

三元组实现稀疏矩阵加减乘

三元组实现稀疏矩阵加减乘

#include<stdio.h>#include<stdlib.h> #define MAXSIZE 12500 // 三元组结构typedef structinti,j;int e; }Triple;{//矩阵行下标和列下标//值typedef struct {Triple data[MAXSIZE+1];int rpos[MAXSIZE+1]; // 这是存放各行第一非零元在矩阵中的位置int mu,nu,tu; // 矩阵的行数、列数、非零元个数}Matrix;void Init(Matrix* M);void Add(Matrix* M,Matrix* T,Matrix* G);void Jian(Matrix* M,Matrix* T,Matrix* G);void Cheng(Matrix* M,Matrix* T,Matrix* G);void Cheng(Matrix* M,Matrix* T,Matrix* G); void PrintMatrix(Matrix* M);//2、初始化矩阵void Init(Matrix* M){int i;if(M->mu < 1 || M->nu < 1 || M->tu > M->mu*M->nu){printf(" 出错!\n"); //如果矩阵的行数、列数不符合要求,打印出错} for(i=1;i<=M->tu;i++) //data[0] 不用{printf(“第%d个非零元的行号:“,i); //以下为数据初始化scanf("%d",&M->data[i].i);printf(“第%d个非零元的列号:",i); scanf("%d",&M->data[i].j); printf(”第%d个非零元的元素值:",i); scanf("%d",&M->data[i].e);}printf("\n");printf(" 您创建的矩阵如下:\n"); PrintMatrix(M);} //3、矩阵相加void Add(Matrix* M,Matrix* T,Matrix* G) {G->mu = M->mu;的行、列数。

三元组压缩存储结构的稀疏矩阵的运算快速转置

三元组压缩存储结构的稀疏矩阵的运算快速转置

三元组压缩存储结构的稀疏矩阵的运算快速转置在计算机科学和数学领域中,稀疏矩阵是一种在大部分元素为零的矩阵。

由于其大部分元素为零,因此在存储和运算时存在着一些挑战。

为了解决这一问题,人们提出了三元组压缩存储结构,这种存储结构能够有效地压缩稀疏矩阵,并且能够实现快速的运算转置。

1.稀疏矩阵稀疏矩阵是一种大部分元素为零的矩阵,与之相对应的是稠密矩阵,其大部分元素为非零值。

稀疏矩阵通常在图像处理、文本处理、网络分析等领域中得到广泛应用。

然而,由于大部分元素为零,传统的存储方式会导致存储空间的浪费。

人们提出了三元组压缩存储结构,以解决稀疏矩阵存储的问题。

2.三元组压缩存储结构三元组压缩存储结构是一种用于表示稀疏矩阵的存储格式。

它采用三个数组来分别存储矩阵的非零元素的行坐标、列坐标和数值。

由于只需存储非零元素的信息,因此能够有效地压缩存储空间。

三元组压缩存储结构还能够实现快速的随机访问,这是由于它将矩阵的元素位置和数值分开存储,使得在进行运算时能够更为高效。

3.稀疏矩阵的运算稀疏矩阵的运算是对稀疏矩阵进行加法、减法、乘法等操作的过程。

在进行稀疏矩阵的运算时,三元组压缩存储结构能够显著提高计算效率。

这是由于在进行运算时,只需考虑非零元素,而无需考虑大量的零元素,从而减少了计算的复杂度。

4.稀疏矩阵的快速转置稀疏矩阵的转置是将矩阵的行和列交换,同时保持非零元素的位置和数值不变。

在传统的存储方式下,稀疏矩阵的转置操作相对复杂且耗时。

然而,采用三元组压缩存储结构后,稀疏矩阵的快速转置变得十分简便。

通过交换三元组中的行坐标和列坐标,即可完成稀疏矩阵的快速转置操作。

5.个人观点和理解我认为三元组压缩存储结构的出现,极大地解决了稀疏矩阵在存储和运算中的效率问题。

通过将矩阵的非零元素信息进行压缩存储,不仅节省了存储空间,同时也提高了计算效率。

在实际应用中,三元组压缩存储结构能够更好地满足对存储空间和计算效率有较高要求的场景,为稀疏矩阵的处理提供了更为便利和高效的途径。

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

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

实现稀疏矩阵(采用三元组表示)的基本运算实验报告实现稀疏矩阵(采用三元组表示)的基本运算实验报告一实验题目: 实现稀疏矩阵(采用三元组表示)的基本运算二实验要求:(1)生成如下两个稀疏矩阵的三元组a 和 b;(上机实验指导 P92 )(2)输出 a 转置矩阵的三元组;(3)输出a + b 的三元组;(4)输出 a * b 的三元组;三实验内容:3.1 稀疏矩阵的抽象数据类型: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+N SubSMatrix(M, N, &Q)初始条件:稀疏矩阵M、N已经存在操作结果:求矩阵的差Q=M-N TransposeSMatrix(M, & T)初始条件:稀疏矩阵M已经存在操作结果:求矩阵M的转置T MultSMatrix(M, N, &Q)初始条件:稀疏矩阵M已经存在操作结果:求矩阵的积Q=M*N }ADT SparseMatrix3.2存储结构的定义#define N 4typedef int ElemType;#define MaxSize 100 //矩阵中非零元素最多个数typedef struct{ int r; //行号int c; //列号ElemType d; //元素值} TupNode; //三元组定义typedef struct{ int rows; //行数值int cols; //列数值int nums; //非零元素个数TupNode data[MaxSize];} TSMatrix; //三元组顺序表定义3.3基本操作实现:void CreatMat(TSMatrix &t,ElemType A[N][N]){int i,j;t.rows=N;t.cols=N;t.nums=0;for (i=0;i<N;i++){for (j=0;j<N;j++)if (A[i][j]!=0){t.data[t.nums].r=i;t.data[t.nu ms].c=j;t.data[t.nums].d=A[i][j];t.nums++;}}}void DispMat(TSMatrix t){int i;if (t.nums<=0)return;printf("\t%d\t%d\t%d\n",t.rows ,t.cols,t.nums);printf("\t------------------\n ");for (i=0;i<t.nums;i++)printf("\t%d\t%d\t%d\n",t.data[i] .r,t.data[i].c,t.data[i].d);3.4解题思路:1.转置矩阵:只要判定原矩阵有值,那么只要遍历一遍原矩阵,把原来矩阵中非0元素行列变换一下赋值到新的矩阵中即可。

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

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

三元组顺序表表示的稀疏矩阵加法三元组顺序表表示的稀疏矩阵加法引言:稀疏矩阵是指在矩阵中大部分元素为零的情况下,只有很少非零元素的矩阵。

由于矩阵运算的复杂性,对于大型稀疏矩阵,使用传统的矩阵加法算法会消耗大量的时间和内存资源。

因此,为了高效地进行稀疏矩阵的加法运算,可以使用三元组顺序表来表示稀疏矩阵,并通过特定的算法来实现加法操作。

本文将介绍三元组顺序表和稀疏矩阵加法,并逐步回答以下问题:1. 什么是三元组顺序表?2. 什么是稀疏矩阵加法?3. 如何使用三元组顺序表进行稀疏矩阵加法操作?一、什么是三元组顺序表?三元组顺序表是一种用来高效表示稀疏矩阵的数据结构。

在三元组顺序表中,每个非零元素用一个三元组表示,包括元素的行号、列号和值。

同时,三元组顺序表中还包含两个整数,分别表示矩阵的行数和列数。

例如,如果有一个3x3的稀疏矩阵如下:1 0 20 4 03 0 5使用三元组顺序表来表示这个矩阵,可以得到如下的三元组:(0, 0, 1), (0, 2, 2), (1, 1, 4), (2, 0, 3), (2, 2, 5)二、什么是稀疏矩阵加法?稀疏矩阵加法是指对两个稀疏矩阵进行加法运算的操作。

对于给定的两个稀疏矩阵A和B,稀疏矩阵加法的结果矩阵C的每个元素等于矩阵A和B中对应位置的元素之和。

三、使用三元组顺序表进行稀疏矩阵加法操作的步骤为了实现稀疏矩阵加法,可以按照以下步骤进行:1. 定义一个存储稀疏矩阵的三元组顺序表:使用一个结构体将矩阵的行、列和非零元素存储起来。

2. 输入矩阵A和B的维度:获取矩阵A和B的行数和列数,以及非零元素的个数。

3. 输入矩阵A和B的非零元素:获取矩阵A和B的非零元素的行号、列号和值,并将其存储到三元组顺序表中。

4. 对三元组顺序表进行排序:根据三元组的行号和列号进行排序,以便后续的加法运算。

5. 进行稀疏矩阵加法运算:从头开始遍历三元组顺序表,依次取出每个三元组,根据其行号和列号在结果矩阵C中进行加法运算。

稀疏矩阵的加减法

稀疏矩阵的加减法

《数据结构》课程设计报告书题目:稀疏矩阵的加减法专业:计算机科学与技术学号:学生姓名:指导教师:完成日期:2016-06-20稀疏矩阵的加减法运算1.题目描述假设稀疏矩阵A和B(m行n列)都采用三元组表示,编写程序计算C=A+B,D=A-B,矩阵C和D也采用三元组表示。

编写程序实现,并输出结果。

2.预备知识①函数模块调用关系②三元组中抽象数据类型定义③三元组表的赋值操作④三元组和稀疏矩阵之间的转换3.问题分析该程序主要实现以下功能:(1)用三元组存储方式创建稀疏矩阵;(2)用三元组存储方式进行稀疏矩阵的加法;(3)用三元组存储方式进行稀疏矩阵的减法;程序流程和设计思想可以用以下流程图来描述:图1.程序运行流程图4.数据结构设计抽象数据类型定义三元组中抽象数据类型定义①typedef struct //三元组表中元素类型的定义{int i,j;int e;}Triple;②typedef struct{a)Triple data[MAX+1]; //存放非零元素的数组,行优先b)int row,nu,tu;}Matrix; //三元组表类型名③InitMatrix(A); //初始化④AddMatrix(A,B,C);//矩阵相加⑤SubMatrix(A,B,C);//矩阵相减5.模块设计①void InitMatrix(Matrix &M) //初始化三元组矩阵{int num=0;M=*(Matrix *)malloc(sizeof(Matrix)); //为三元组申请内存printf("请输入矩阵的行、列和非零元素个数:\n");scanf("%d %d",&M.row,&M.nu); //输入矩阵的行、列和非零元素个数printf("请输入矩阵的非零元值:\n");scanf("%d",&num);getchar();M.tu=num;for(int i=1;i<=M.tu;i++) //输入三元组{printf("请输入第%d个非零元值:\n",i);scanf("%d%d%d",&M.data[i].i,&M.data[i].j,&M.data[i].e);getchar();}}②void AddMatrix(Matrix A,Matrix B,Matrix &C) //将A,B的值相加放到C上{C=*(Matrix *)malloc(sizeof(Matrix)); //为三元组C申请内存int i=1,j=1,k=1;int v;if(A.row!=B.row||A.nu!=B.nu) //判断A、B的行列数是否相等printf("error!\n");else{C.row=A.row; //把A的行数赋给CC.nu=A.nu; //把A的列数赋给Cwhile(i<=A.tu&&j<=B.tu){if(A.data[i].i==B.data[j].i) //如果三元组A的行下标与B的行下标相等{if(A.data[i].j<B.data[j].j)//如果三元组A的列下标小于B的行下标{C.data[k].i=A.data[i].i;//把当前三元组A行下标i插入三元组CC.data[k].j=A.data[i].j;//把当前三元组A下列标j插入三元组CC.data[k].e=A.data[i].e;//把当前三元组A下标i对于的数值e插入三元组Ck++;i++;}else if(A.data[i].j>B.data[j].j)//如果三元组A的列下标大于B的行下标{C.data[k].i=B.data[j].i;C.data[k].j=B.data[j].j;C.data[k].e=B.data[j].e;k++;j++;}else //如果三元组A的列下标等于B的行下标{v=A.data[i].e+B.data[j].e;if(v!=0){C.data[k].i=A.data[i].i; //把当前三元组A行下标i插入三元组CC.data[k].j=A.data[i].j; //把当前三元组A下列标j插入三元组CC.data[k].e=v; //把三元组A-B下标i对于的数值v 插入三元组Ck++;}i++;j++;}}else if(A.data[i].i<B.data[j].i) //如果三元组A的行下标小于B的行下标{C.data[k].i=A.data[i].i; //把当前三元组A行下标i插入三元组CC.data[k].j=A.data[i].j; //把当前三元组A下列标j插入三元组CC.data[k].e=A.data[i].e; //把当前三元组A下标i对于的数值e插入三元组Ck++;i++;}else{C.data[k].i=B.data[j].i;//把当前三元组B下行标i插入三元组CC.data[k].j=B.data[j].j;//把当前三元组B下列标j插入三元组CC.data[k].e=B.data[j].e;//把当前三元组B下标i对于的数值e插入三元组Ck++;j++;}}while(i<=A.tu){C.data[k].i=A.data[i].i;//把当前三元组A下行标i插入三元组CC.data[k].j=A.data[i].j;//把当前三元组A下列标j插入三元组CC.data[k].e=A.data[i].e;//把当前三元组A下标i对于的数值e插入三元组Ck++;i++;}while(j<=B.tu){C.data[k].i=B.data[j].i;//把当前三元组B下行标i插入三元组CC.data[k].j=B.data[j].j;//把当前三元组B下列标j插入三元组CC.data[k].e=B.data[j].e;//把当前三元组B下标i对于的数值e插入三元组Ck++;j++;}C.tu=k-1;}}③void SubMatrix(Matrix A,Matrix B,Matrix &C){C=*(Matrix *)malloc(sizeof(Matrix));int i=1,j=1,k=1;int v;if(A.row!=B.row||A.nu!=B.nu) //判断A、B的行列数是否相等printf("error!\n");else{C.row=A.row;C.nu=A.nu;while(i<=A.tu&&j<=B.tu){if(A.data[i].i==B.data[j].i){if(A.data[i].j<B.data[j].j){C.data[k].i=A.data[i].i;//把当前三元组A下行标i插入三元组CC.data[k].j=A.data[i].j;//把当前三元组A下列标j插入三元组CC.data[k].e=A.data[i].e;//把当前三元组A下标i对于的数值e插入三元组Ck++;i++;}else if(A.data[i].j>B.data[j].j){C.data[k].i=B.data[j].i;//把当前三元组B下行标i插入三元组CC.data[k].j=B.data[j].j;//把当前三元组B下列标j插入三元组CC.data[k].e=B.data[j].e;//把当前三元组B下标i对于的数值e插入三元组Ck++;j++;}else{v=A.data[i].e-B.data[j].e;if(v!=0){C.data[k].i=A.data[i].i;//把当前三元组A下行标i插入三元组CC.data[k].j=A.data[i].j;//把当前三元组A下列标j插入三元组CC.data[k].e=v; //把三元组A-B下标i对于的数值v插入三元组Ck++;}i++;j++;}}else if(A.data[i].i<B.data[j].i){C.data[k].i=A.data[i].i;//把当前三元组A下行标i插入三元组CC.data[k].j=A.data[i].j;//把当前三元组A下列标j插入三元组CC.data[k].e=A.data[i].e;//把当前三元组A下标i对于的数值e插入三元组Ck++;i++;}else{C.data[k].i=B.data[j].i;//把当前三元组B下行标i插入三元组CC.data[k].j=B.data[j].j;//把当前三元组B下列标j插入三元组CC.data[k].e=B.data[j].e;//把当前三元组B下标i对于的数值e插入三元组Ck++;j++;}}while(i<=A.tu){C.data[k].i=A.data[i].i;//把当前三元组A下行标i插入三元组CC.data[k].j=A.data[i].j;//把当前三元组A下列标j插入三元组CC.data[k].e=A.data[i].e;//把当前三元组A下标i对于的数值e插入三元组Ck++;i++;}while(j<=B.tu){C.data[k].i=B.data[j].i;//把当前三元组B下行标i插入三元组CC.data[k].j=B.data[j].j;//把当前三元组B下列标j插入三元组CC.data[k].e=B.data[j].e;//把当前三元组B下标i对于的数值e插入三元组Ck++;j++;}C.tu=k-1;}}④void ShowMatrix(Matrix M) //输出三元组矩阵{printf("\n\n矩阵信息:\n");printf("row:%d nu:%d tu:%d\n",M.row,M.nu,M.tu);printf(" i j k\n");for(int i=1;i<=M.tu;i++){printf(" %d, %d, %d,\n",M.data[i].i,M.data[i].j,M.data[i].e); //输出三元组}}⑤int main(){char x=' ';cout<<"\t ┏****************************************┓"<<endl;cout<<"\t ┃请选择相应的功能:┃"<<endl;cout<<"\t ┃----------------------------------------┃"<<endl;cout<<"\t ┃ 1. 求两个矩阵相加和┃"<<endl;cout<<"\t ┃----------------------------------------┃"<<endl;cout<<"\t ┃ 2. 求两个矩阵相减差┃"<<endl;cout<<"\t ┃----------------------------------------┃"<<endl;cout<<"\t ┃0. 退出系统┃"<<endl;cout<<"\t ┗━━━━━━━━━━━━━━━━━━━━┛"<<endl; int flag=1;while(flag){printf("请选择相应的功能:");int s;scanf("%d",&s);getchar();//输入menu编号switch(s){case 1:{Matrix A,B,C;printf("请输入第一个矩阵:\n");InitMatrix(A); //初始化printf("请输入第二个矩阵:\n");InitMatrix(B); //初始化printf("矩阵的和为:\n");AddMatrix(A,B,C);ShowMatrix(C);//输出三元组表break;}case 2:{Matrix A,B,C;printf("请输入第一个矩阵:\n");InitMatrix(A);//初始化printf("请输入第二个矩阵:\n");InitMatrix(B);//初始化printf("矩阵的差为:\n");SubMatrix(A,B,C);ShowMatrix(C);//输出三元组表break;}case 0:flag=0;break;}}}6.运行界面及运算结果图5-1图5-2图5-3图5-4附录:#include<stdio.h>#include<stdlib.h>#include<iostream>using namespace std;#define MAX 1000//三元组typedef struct //三元组表中元素类型的定义{int i,j;int e;}Triple;typedef struct{Triple data[MAX+1]; //存放非零元素的数组,行优先int row,nu,tu;}Matrix; //三元组表类型名void InitMatrix(Matrix &M) //初始化三元组矩阵{int num=0;M=*(Matrix *)malloc(sizeof(Matrix)); //为三元组申请内存printf("请输入矩阵的行、列和非零元素个数:\n");scanf("%d %d",&M.row,&M.nu); //输入矩阵的行、列和非零元素个数printf("请输入矩阵的非零元值:\n");scanf("%d",&num);getchar();M.tu=num;for(int i=1;i<=M.tu;i++) //输入三元组{printf("请输入第%d个非零元值:\n",i);scanf("%d%d%d",&M.data[i].i,&M.data[i].j,&M.data[i].e);getchar();}}void ShowMatrix(Matrix M) //输出三元组矩阵{printf("\n\n矩阵信息:\n");printf("row:%d nu:%d tu:%d\n",M.row,M.nu,M.tu);printf(" i j k\n");for(int i=1;i<=M.tu;i++){printf(" %d, %d, %d,\n",M.data[i].i,M.data[i].j,M.data[i].e); //输出三元组}}void AddMatrix(Matrix A,Matrix B,Matrix &C) //将A,B的值相加放到C上{C=*(Matrix *)malloc(sizeof(Matrix)); //为三元组C申请内存int i=1,j=1,k=1;int v;if(A.row!=B.row||A.nu!=B.nu) //判断A、B的行列数是否相等printf("error!\n");else{C.row=A.row; //把A的行数赋给CC.nu=A.nu; //把A的列数赋给Cwhile(i<=A.tu&&j<=B.tu){if(A.data[i].i==B.data[j].i) //如果三元组A的行下标与B的行下标相等{if(A.data[i].j<B.data[j].j)//如果三元组A的列下标小于B的行下标{C.data[k].i=A.data[i].i;//把当前三元组A行下标i插入三元组CC.data[k].j=A.data[i].j;//把当前三元组A下列标j插入三元组CC.data[k].e=A.data[i].e;//把当前三元组A下标i对于的数值e插入三元组Ck++;i++;}else if(A.data[i].j>B.data[j].j)//如果三元组A的列下标大于B的行下标{C.data[k].i=B.data[j].i;C.data[k].j=B.data[j].j;C.data[k].e=B.data[j].e;k++;j++;}else //如果三元组A的列下标等于B的行下标{v=A.data[i].e+B.data[j].e;if(v!=0){C.data[k].i=A.data[i].i; //把当前三元组A行下标i插入三元组CC.data[k].j=A.data[i].j; //把当前三元组A下列标j插入三元组CC.data[k].e=v; //把三元组A-B下标i对于的数值v插入三元组Ck++;}i++;j++;}}else if(A.data[i].i<B.data[j].i) //如果三元组A的行下标小于B的行下标{C.data[k].i=A.data[i].i; //把当前三元组A行下标i插入三元组CC.data[k].j=A.data[i].j; //把当前三元组A下列标j插入三元组CC.data[k].e=A.data[i].e; //把当前三元组A下标i对于的数值e插入三元组Ck++;i++;}else{C.data[k].i=B.data[j].i;//把当前三元组B下行标i插入三元组CC.data[k].j=B.data[j].j;//把当前三元组B下列标j插入三元组CC.data[k].e=B.data[j].e;//把当前三元组B下标i对于的数值e插入三元组Ck++;j++;}}while(i<=A.tu){C.data[k].i=A.data[i].i;//把当前三元组A下行标i插入三元组CC.data[k].j=A.data[i].j;//把当前三元组A下列标j插入三元组CC.data[k].e=A.data[i].e;//把当前三元组A下标i对于的数值e插入三元组Ck++;i++;}while(j<=B.tu){C.data[k].i=B.data[j].i;//把当前三元组B下行标i插入三元组CC.data[k].j=B.data[j].j;//把当前三元组B下列标j插入三元组CC.data[k].e=B.data[j].e;//把当前三元组B下标i对于的数值e插入三元组Ck++;j++;}C.tu=k-1;}}void SubMatrix(Matrix A,Matrix B,Matrix &C){C=*(Matrix *)malloc(sizeof(Matrix));int i=1,j=1,k=1;int v;if(A.row!=B.row||A.nu!=B.nu) //判断A、B的行列数是否相等printf("error!\n");else{C.row=A.row;C.nu=A.nu;while(i<=A.tu&&j<=B.tu){if(A.data[i].i==B.data[j].i){if(A.data[i].j<B.data[j].j){C.data[k].i=A.data[i].i;//把当前三元组A下行标i插入三元组CC.data[k].j=A.data[i].j;//把当前三元组A下列标j插入三元组CC.data[k].e=A.data[i].e;//把当前三元组A下标i对于的数值e插入三元组Ck++;i++;}else if(A.data[i].j>B.data[j].j){C.data[k].i=B.data[j].i;//把当前三元组B下行标i插入三元组CC.data[k].j=B.data[j].j;//把当前三元组B下列标j插入三元组CC.data[k].e=B.data[j].e;//把当前三元组B下标i对于的数值e插入三元组Ck++;j++;}else{v=A.data[i].e-B.data[j].e;if(v!=0){C.data[k].i=A.data[i].i;//把当前三元组A下行标i插入三元组CC.data[k].j=A.data[i].j;//把当前三元组A下列标j插入三元组CC.data[k].e=v; //把三元组A-B下标i对于的数值v插入三元组Ck++;}i++;j++;}}else if(A.data[i].i<B.data[j].i){C.data[k].i=A.data[i].i;//把当前三元组A下行标i插入三元组CC.data[k].j=A.data[i].j;//把当前三元组A下列标j插入三元组CC.data[k].e=A.data[i].e;//把当前三元组A下标i对于的数值e插入三元组Ck++;i++;}else{C.data[k].i=B.data[j].i;//把当前三元组B下行标i插入三元组CC.data[k].j=B.data[j].j;//把当前三元组B下列标j插入三元组CC.data[k].e=B.data[j].e;//把当前三元组B下标i对于的数值e插入三元组Ck++;j++;}}while(i<=A.tu){C.data[k].i=A.data[i].i;//把当前三元组A下行标i插入三元组CC.data[k].j=A.data[i].j;//把当前三元组A下列标j插入三元组CC.data[k].e=A.data[i].e;//把当前三元组A下标i对于的数值e插入三元组Ck++;i++;}while(j<=B.tu){C.data[k].i=B.data[j].i;//把当前三元组B下行标i插入三元组CC.data[k].j=B.data[j].j;//把当前三元组B下列标j插入三元组CC.data[k].e=B.data[j].e;//把当前三元组B下标i对于的数值e插入三元组Ck++;j++;}C.tu=k-1;}}int main(){char x=' ';cout<<"\t ┏****************************************┓"<<endl;cout<<"\t ┃请选择相应的功能:┃"<<endl;cout<<"\t ┃----------------------------------------┃"<<endl;cout<<"\t ┃ 1. 求两个矩阵相加和┃"<<endl;cout<<"\t ┃----------------------------------------┃"<<endl;cout<<"\t ┃ 2. 求两个矩阵相减差┃"<<endl;cout<<"\t ┃----------------------------------------┃"<<endl;cout<<"\t ┃0. 退出系统┃"<<endl;cout<<"\t ┗━━━━━━━━━━━━━━━━━━━━┛"<<endl;int flag=1;while(flag){printf("请选择相应的功能:");int s;scanf("%d",&s);getchar();//输入menu编号switch(s){case 1:{Matrix A,B,C;printf("请输入第一个矩阵:\n");InitMatrix(A); //初始化printf("请输入第二个矩阵:\n");InitMatrix(B); //初始化printf("矩阵的和为:\n");AddMatrix(A,B,C);ShowMatrix(C);//输出三元组表break;}case 2:{Matrix A,B,C;printf("请输入第一个矩阵:\n");InitMatrix(A);//初始化printf("请输入第二个矩阵:\n");InitMatrix(B);//初始化printf("矩阵的差为:\n");SubMatrix(A,B,C);ShowMatrix(C);//输出三元组表break;}case 0:flag=0;break;}}}。

三元组表示稀疏矩阵转置

三元组表示稀疏矩阵转置

三元组表示稀疏矩阵转置
随着时代的进步,互联网已经深入到了我们的各个层面,其成功的关键之一就
在于数据处理技术。

稀疏矩阵转置是构成这一技术的基础之一,主要目的是改变二维矩阵的行和列。

这里要介绍的是一种特殊的“三元组表示稀疏矩阵转置”技术,它可以更加高效地将变换后的矩阵存储在硬盘上以便以后可以重用。

三元组表示稀疏矩阵转置处理的思路是,首先,将需要转置的稀疏矩阵以一个“非零元素”列表的形式读入,记为(row,col,data),其中row表示该非零元素所
处的行数,col表示列数,data表示该非零元素的值;然后,根据row和col的值,计算变换后的稀疏矩阵的最终坐标依次给出(col,row);最后,将所有非零元素的
坐标以及对应的值,按照升序排序,用“三元组表示形式”写入硬盘中以作备份。

三元组表示稀疏矩阵转置也是一种特殊的“非零元素”列表构建技术。

它把矩
阵转换成一系列索引型(index type)的非零元素数据,这既可以更加有效地把变换后的矩阵存储起来,也可以有效地提高运算效率,避免无谓的存储和消耗。

从长远来看,三元组表示稀疏矩阵转置无疑是一种重要的数据技术,它的成功
不仅取决于它的有效简便度,而且取决于它有助于改善计算处理效率,提高输出效果,从而使数据技术更为可靠,有助于推动信息革命更大范围的发展。

c语言稀疏矩阵应用代码实现三元组,十字链表下的稀疏矩阵的加、转、乘的实现。

c语言稀疏矩阵应用代码实现三元组,十字链表下的稀疏矩阵的加、转、乘的实现。

c语言稀疏矩阵应用代码实现三元组,十字链表下的稀疏矩阵的加、转、乘的实现。

在C语言中,实现稀疏矩阵的加法、转置和乘法涉及复杂的数据结构和算法。

其中,常用的表示稀疏矩阵的两种数据结构是三元组和十字链表。

下面我将为您提供一个简单的示例代码,用C语言实现稀疏矩阵的加法、转置和乘法操作,使用三元组表示法来表示稀疏矩阵。

首先,我们需要定义表示稀疏矩阵的三元组结构体:```c#include<stdio.h>#define MAX_SIZE100typedef struct{int row;int col;int value;}Element;typedef struct{int rows;int cols;int num_elements;Element data[MAX_SIZE];}SparseMatrix;```接下来,我们实现稀疏矩阵的加法、转置和乘法函数:```c#include<stdbool.h>//加法函数SparseMatrix addSparseMatrix(SparseMatrix matrix1,SparseMatrix matrix2){ SparseMatrix result;result.rows=matrix1.rows;result.cols=matrix1.cols;result.num_elements=0;int i=0,j=0;while(i<matrix1.num_elements&&j<matrix2.num_elements){if(matrix1.data[i].row<matrix2.data[j].row||(matrix1.data[i].row==matrix2.data[j].row&&matrix1.data[i].col<matrix2.data[j].col)){ result.data[result.num_elements++]=matrix1.data[i++];}else if(matrix1.data[i].row>matrix2.data[j].row||(matrix1.data[i].row==matrix2.data[j].row&&matrix1.data[i].col>matrix2.data[j].col)){ result.data[result.num_elements++]=matrix2.data[j++];}else{Element element;element.row=matrix1.data[i].row;element.col=matrix1.data[i].col;element.value=matrix1.data[i].value+matrix2.data[j].value;if(element.value!=0){result.data[result.num_elements++]=element;}i++;j++;}}while(i<matrix1.num_elements){result.data[result.num_elements++]=matrix1.data[i++];}while(j<matrix2.num_elements){result.data[result.num_elements++]=matrix2.data[j++];}return result;}//转置函数SparseMatrix transposeSparseMatrix(SparseMatrix matrix){ SparseMatrix result;result.rows=matrix.cols;result.cols=matrix.rows;result.num_elements=matrix.num_elements;int count[matrix.cols];int index[matrix.cols];for(int i=0;i<matrix.cols;i++){count[i]=0;}for(int i=0;i<matrix.num_elements;i++){count[matrix.data[i].col]++;}index[0]=0;for(int i=1;i<matrix.cols;i++){index[i]=index[i-1]+count[i-1];}for(int i=0;i<matrix.num_elements;i++){int j=index[matrix.data[i].col];result.data[j].row=matrix.data[i].col;result.data[j].col=matrix.data[i].row;result.data[j].value=matrix.data[i].value;index[matrix.data[i].col]++;}return result;}//乘法函数SparseMatrix multiplySparseMatrix(SparseMatrix matrix1,SparseMatrix matrix2){ SparseMatrix result;if(matrix1.cols!=matrix2.rows){result.rows=0;result.cols=0;result.num_elements=0;return result;}result.rows=matrix1.rows;result.cols=matrix2.cols;result.num_elements=0;bool visited[matrix2.cols];for(int i=0;i<matrix2.cols;i++){visited[i]=false;}for(int i=0;i<matrix1.num_elements;i++){for(int j=0;j<matrix2.num_elements;j++){if(matrix1.data[i].col==matrix2.data[j].row){Element element;element.row=matrix1.data[i].row;element.col=matrix2.data[j].col;element.value=matrix1.data[i].value*matrix2.data[j].value; result.data[result.num_elements++]=element;visited[matrix2.data[j].col]=true;}}}for(int i=0;i<matrix2.cols;i++){if(!visited[i]){for(int j=0;j<matrix1.rows;j++){Element element;element.row=j;element.col=i;element.value=0;result.data[result.num_elements++]=element;}}}return result;}```请注意,上述代码只是一个简单示例,实际应用中可能需要根据具体需求进行优化和扩展。

三元组结构实现稀疏矩阵转置算法的分析

三元组结构实现稀疏矩阵转置算法的分析

三元组结构实现稀疏矩阵转置算法的分析文章简要叙述了稀疏矩阵压缩存储的三元组表示法及其基于此种结构的矩阵的转置运算。

探讨了基于三元组结构的矩阵转置算法的具体实现方法及其时空复杂度的问题。

【关键词】稀疏矩阵压缩存储三元组转置算法在一些特殊矩阵中,如对称矩阵和上下三角矩阵,非零元素一般都有明显的规律,从而都可以压缩到一维数组里面,然而,实际应用中经常会遇到这样一些矩阵,它们非零元素少,且分布不均匀,且没有明显的规律,称之为稀疏矩阵。

按照压缩存储的思想,只需存储矩阵中的非零元素。

为了便于存取和检索,一般在存储的时候必须带有合适的辅助信息,即同时记录下它所在的行列的位置等等。

在实际应用中,一般我们采取的是用三元组和十字链表两种表示方法来实现稀疏矩阵的存储及其运算。

稀疏矩阵在数值计算、电力系统的潮流计算、天气预报、工程分析计算等方面都有着大量的应用,不少实际问题都可以转化为对稀疏矩阵的计算问题。

了解稀疏矩阵的各种操作变得尤为重要。

1 基本概念设矩阵中有t个非零元素,若t远远小于矩阵元素的总数,则称该矩阵为稀疏矩阵。

通常,在m×n 的矩阵中,存在t个非零元素。

设δ= t/(m*n),则称δ为矩阵的稀疏因子,一般认为当δ≤0.05时为稀疏矩阵。

在存储稀疏矩阵时,为了节约存储单元,很自然的压缩方法就是只存储非零元素,但由于非零元素的分布一般是没有规律的,因此在存储非零元素的同时,还必须存储相应的辅助信息,才能准确迅速确定一个非零元素是矩阵中的哪一个元素。

最简单的办法就是将非零元素的值和它所在的行列号作为一个结点存放到一起,于是矩阵中的每一个非零元素就由一个三元组(i,j,aij)唯一确定。

显然,稀疏矩阵的压缩存储方法会让其失去随机存取功能。

2 三元组表示稀疏矩阵转置算法的实现用三元组来表示非零元素时稀疏矩阵的压缩存储方法的具体数据类型说明如下:三元组表示的稀疏矩阵,如何实现转置算法呢?矩阵的转置是基本的矩阵运算,对于一个m×n 的矩阵M,它的转置N是一个n×m 的矩阵,且有N(i,j)=M(j,i)。

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

存储表示的稀疏矩阵 M 和 N 的差,结果赋给矩阵 Q if((M.mu&lt;=0)||(M.nu&lt;=0)||(M.tu&lt;=0)||(N.mu&lt;=0)||(N.nu&lt;=0)||(N.tu&lt;=0)) return ERROR; if(M.mu!=N.mu||M.nu!=N.nu) return ERROR; Q.mu=M.mu; Q.nu=M.nu; Q.tu=0; int x=0,y=0; for(int i=1;i&lt;=Q.mu;i++){ for(int j=1;j&lt;=Q.nu;j++){ for(int p=1;p&lt;=M.tu;p++){ if((i==M.data[p].i)&amp;&amp;(j==M.data[p].j)){ x=M.data[p].e; break; } else x=0; }//for p for(int q=1;q&lt;=N.tu;q++){ if((i==N.data[q].i)&amp;&amp;(j==N.data[q].j)){ y=N.data[q].e; break; }
CreateSMatrix(N);//创建稀疏矩阵 N PrintSMatrix(N);//显示稀疏矩阵 N AddSMatrix(M,N,Q);//将稀疏矩阵 M 与 N 的和存入矩阵 Q 中 cout&lt;&lt;&quot;加法结果:&quot;; PrintSMatrix(Q);//显示矩阵 Q break; case 2: CreateSMatrix(M);//创建稀疏矩阵 M PrintSMatrix(M);//显示稀疏矩阵 M CreateSMatrix(N);//创建稀疏矩阵 N PrintSMatrix(N);//显示稀疏矩阵 N SubSMatrix(M,N,Q);//将稀疏矩阵 M 与 N 的差存入矩阵 Q 中 cout&lt;&lt;&quot;减法结果:&quot;; PrintSMatrix(Q);//显示矩阵 Q break; case 3: CreateSMatrix(M);//创建稀疏矩阵 M PrintSMatrix(M);//显示稀疏矩阵 M FastTransposeSMatrix(M,T);//将稀疏矩阵 M 转置,结果存入矩阵 T 中 cout&lt;&lt;&quot;转置矩
if((i==N.data[q].i)&amp;&amp;(j==N.data[q].j)){ y=N.data[q].e; break; } else y=0; }//for q if((x+y)!=0){ Q.data[Q.tu+1].i=i; Q.data[Q.tu+1].j=j; Q.data[Q.tu+1].e=x+y; Q.tu++; }//if }//for j }//for i return OK; } int SubSMatrix(TSMatrix M,TSMatrix N,TSMatrix &amp;Q){ //求采用三元组顺序表

阵:&quot;; PrintSMatrix(T);//显示稀疏矩阵 T break; case 4: return 0; default: system (&quot;CLS&quot;); cout&lt;&lt;&quot;\n*输入错误,请重新输入*\n&quot;&lt;&lt;endl; break; } cout&lt;&lt;&quot;1. 矩阵加法运算 \n2. 矩阵减法运算 \n3. 矩阵转置运算 \n4. 退出 \n 请输入 1~4:&quot;; } }
M.nu=0; M.tu=0; return OK; } int PrintSMatrix(TSMatrix M){ //输出采用三元组顺序表存储表示的稀疏矩阵 M if((M.mu&lt;=0)||(M.nu&lt;=0)||(M.tu&lt;=0)) return ERROR; cout&lt;&lt;endl; for(int row=1;row&lt;=M.mu;row++){ for(int col=1;col&lt;=M.nu;col++){ for(int i=1;i&lt;=M.tu;i++){ if((M.data[i].i==row)&amp;&amp;(M.data[i].j==col)){ cout&lt;&lt;M.data[i].e&lt;&lt;&quot; &quot;; goto loop; }//if }//for i cout&lt;&lt;&quot;0&quot;&lt;&lt;&quot; &quot;; loop:; }//for col cout&lt;&lt;endl; }//for row return OK; } int AddSMatrix(TSMatrix M,TSMatrix N,TSMatrix &amp;Q){ //求采用三元组顺序表存储表示的稀疏矩阵 M 和 N 的和,,结果赋给矩阵 Q if((M.mu&lt;=0)||(M.nu&lt;=0)||(M.tu&lt;=0)||(N.mu&lt;=0)||(N.nu&lt;=0)||(N.tu&lt;=0)) return ERROR; if(M.mu!=N.mu||M.nu!=N.nu) return ERROR; Q.mu=M.mu; Q.nu=M.nu; Q.tu=0; int x=0,y=0; for(int i=1;i&lt;=Q.mu;i++){ for(int j=1;j&lt;=Q.nu;j++){ for(int p=1;p&lt;=M.tu;p++){ if((i==M.data[p].i)&amp;&amp;(j==M.data[p].j)){ x=M.data[p].e; break; } else x=0; }//for p for(int q=1;q&lt;=N.tu;q++){
else y=0; }//for q if((x-y)!=0){ Q.data[Q.tu+1].i=i; Q.data[Q.tu+1].j=j; Q.data[Q.tu+1].e=x-y; Q.tu++; }//if }//for j }//for i return OK; } int FastTransposeSMatrix(TSMatrix M,TSMatrix &amp;T){ //采用三元组顺序表存储表示,求稀疏矩阵 M 的转职矩阵 T T.mu=M.nu; T.nu=M.mu; T.tu=M.tu; if(T.tu){ int num[M.nu],cpot[M.nu]; for(int col=1;col&lt;=M.nu;col++) num[col]=0; for(int t=1;t&lt;=M.tu;t++) num[M.data[t].j]++;//求 M 中每一列含有非零元个数 cpot[1]=1;//求第 col 列中第一个非零元在 b.data 中的序号 for(int col=2;col&lt;=M.nu;col++) cpot[col]=cpot[col-1]+num[col-1]; for(int p=1,q=1,col;p&lt;=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 p }//if T.tu return OK; } int main(){ system (&quot;CLS&quot;); TSMatrix M,N,T,Q;//声明 M、N、T、Q 为稀疏矩阵 cout&lt;&lt;&quot;1. 矩阵加法运算 \n2. 矩阵减法运算 \n3. 矩阵转置运算 \n4. 退出 \n 请输入 1~4:&quot;; int i; while(cin&gt;&gt;i){ switch(i){ case 1: CreateSMatrix(M);//创建稀疏矩阵 M PrintSMatrix(M);//显示稀疏矩阵 M
利用三元组表对稀疏矩阵实现加法、减法及转置运算
#include &lt;iostream&gt; #define MAXSIZE 12500//假设非零元个数的最大值为 12500 #define OK 1 #define ERROR 0 using namespace std; typedef int ElemType;//定义 ElemType 的类型 typedef struct{ int i,j;//该非零元的行下表和列下表 ElemType e; }Triple; typedef struct{ Triple data[MAXSIZE+1];//非零元三元组表 int mu,nu,tu;//矩阵的行数、列数和非零元个数 }TSMatrix; int CreateSMatrix(TSMatrix &amp;M){ //采用三元组顺序表存储表示,创建稀疏矩阵 M cout&lt;&lt;&quot;请输入稀疏矩阵的行数、列数和非零元个数:&quot;&lt;&lt;endl; cin&gt;&gt;M.mu&gt;&gt;M.nu&gt;&gt;M.tu; if((M.mu&lt;=0)||(M.nu&lt;=0)||(M.tu&lt;=0)||(M.tu&gt;M.mu*M.nu)) //判断行值、列值、元素个数是否合法 return ERROR; for(int i=1;i&lt;=M.tu;i++){//输入稀疏矩阵元素 cout&lt;&lt;&quot;请输入元素坐标及大小:&quot;&lt;&lt;endl; cin&gt;&gt;M.data[i].i&gt;&gt;M.data[i].j&gt;&gt;M.data[i].e; if((M.data[i].i&lt;=0)||(M.data[i].j&lt;=0)){ cout&lt;&lt;&quot;输入错误,请重新输入&quot;&lt;&lt;endl; cin&gt;&gt;M.data[i].i&gt;&gt;M.data[i].j&gt;&gt;M.data[i].e; }//if }//for i return OK; } int DestroySMatrix(TSMatrix &amp;M){ //清除采用三元组顺序表存储表示的稀疏矩阵 M for(int i=1;i&lt;=M.tu;i++){ M.data[i].i=0; M.data[i].j=0; M.data[i].e=0; }//for i M.mu=0;
相关文档
最新文档