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

合集下载

稀疏矩阵三元组快速转置(转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.三元组表是线性表的一种应用,通过它可以更好地理解线性表的存储结构。

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

  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;
相关文档
最新文档