您的位置：360文档中心› 数据结构C语言版 稀疏矩阵的三元组顺序表存储表示和实现

数据结构C语言版 稀疏矩阵的三元组顺序表存储表示和实现

合集下载

数据结构之稀疏矩阵稀疏矩阵的存储方式和操作分析

数据结构之稀疏矩阵稀疏矩阵的存储方式和操作分析

数据结构之稀疏矩阵稀疏矩阵的存储方式和操作分析稀疏矩阵是指矩阵中大部分元素为零的特殊矩阵。

在实际应用中，稀疏矩阵经常出现，如图像处理、网络分析和科学计算等领域。

对于稀疏矩阵的存储和操作是数据结构中的重要内容。

本文将介绍稀疏矩阵的存储方式和相关操作的分析。

一、稀疏矩阵存储方式稀疏矩阵的存储方式有多种，其中三元组顺序表和二维数组是比较常用的方法。

1. 三元组顺序表三元组顺序表是一种基于行优先存储的方式，可以将稀疏矩阵以非零元素的形式存储起来。

主要包括行号、列号和元素值三个信息。

以一个4x5的稀疏矩阵为例，其中有三个非零元素分别为A[1][2]=3, A[2][3]=4, A[3][4]=5。

可以使用三元组顺序表来存储：```行号列号元素值1 2 32 3 43 4 5```三元组顺序表的优点是可以节省存储空间，同时也方便进行矩阵的操作。

但是在进行元素的查找和修改时，效率较低。

2. 二维数组二维数组是一种常见的矩阵表示方法，可以直接使用二维数组来表示稀疏矩阵。

其中非零元素的位置用实际的值表示，其余位置用零值表示。

以同样的4x5的稀疏矩阵为例，使用二维数组存储如下：```0 0 0 0 00 0 3 0 00 0 0 4 00 0 0 0 5```二维数组的优点是简单直观，并且可以快速进行元素的查找和修改。

但当稀疏矩阵的规模较大时，会造成较高的存储资源浪费。

二、稀疏矩阵的操作分析对于稀疏矩阵的操作，主要包括矩阵的转置、相加、相乘等。

1. 转置操作稀疏矩阵的转置是指将原始矩阵的行与列对调。

对于三元组顺序表来说，转置操作主要涉及到行号和列号的交换。

而对于二维数组来说，可以直接在取值的时候将行号和列号对调即可。

2. 相加操作稀疏矩阵的相加操作是指将两个矩阵对应位置的元素相加。

对于三元组顺序表来说，可以通过遍历两个矩阵的非零元素，并将其对应位置的元素相加。

而对于二维数组来说，可以直接将对应位置的元素相加即可。

3. 相乘操作稀疏矩阵的相乘操作是指将两个矩阵相乘得到一个新的矩阵。

稀疏矩阵类（以三元组链表表示）

稀疏矩阵类（以三元组链表表示）

稀疏矩阵类（以三元组链表表⽰）这是⼀个⽤三元组链表表⽰的稀疏矩阵类。

这⾥将类与主函数放在⼀起以便于阅读，如有其他需要请⾃⾏封装。

运⾏结果及源码在下⽅给出。

注：蓝⾊下划线需要通过键盘键⼊//XL_Array.h//稀疏矩阵类（以三元组链表表⽰）#include<iostream>#include<iomanip>using namespace std;//定义三元组链表结点类型template<class T>struct B{int i; //⾮零元素所在的⾏号int j; //⾮零元素所在的列号T v; //⾮零元素值B<T> *next; //指向下⼀个结点的指针域};//三元组链表表⽰的稀疏矩阵类template<class T> //类模板，T为虚拟类型class XL_Array{private: //数据成员int mm; //稀疏矩阵⾏数int nn; //稀疏矩阵列数int tt; //稀疏矩阵中⾮零元素个数B<T> *head; //三元组链表头指针public: //成员函数XL_Array(){head=NULL;return;}//三元组链表初始化void in_XL_Array(); //以三元组形式从键盘输⼊稀疏矩阵⾮零元素void th_XL_Array(int,int,T []);//由⼀般稀疏矩阵转换void prt_XL_Array(); //按⾏输出稀疏矩阵XL_Array tran_XL_Array(); //稀疏矩阵转置XL_Array operator + (XL_Array &);//稀疏矩阵相加};//以三元组形式从键盘输⼊稀疏矩阵⾮零元素template<class T> //函数模板，T为虚拟类型void XL_Array<T>::in_XL_Array(){int k,m,n;T d;B<T> *p,*q;cout<<"输⼊函数列数⾮零元素个数：";cin>>mm>>nn>>tt;q=NULL;cout<<"输⼊⾏数列号⾮零元素值："<<endl;for (k=0;k<tt;k++) //输⼊三元组{cin>>m>>n>>d;p=new B<T>; //申请⼀个三元组结点p->i=m-1; p->j=n-1;p->v=d; p->next=NULL;if(head==NULL)head=p;else q->next=p;q=p;}return;}//由⼀般稀疏矩阵转换template<class T> //函数模板，T为虚拟类型void XL_Array<T>::th_XL_Array(int m,int n,T a[]){int t=0,p,q;B<T> *s,*k;T d;mm=m; nn=n;k=NULL;for(p=0;p<m;p++)for(q=0;q<n;q++){d=a[p*n+q];if(d!=0) //⾮零元素{s=new B<T>; //申请⼀个三元组结点s->i=p; s->j=q; s->v=d;s->next=NULL;if(head==NULL)head=s;else k->next=s;k=s;t=t+1;}}tt=t;return;}//按⾏输出稀疏矩阵template<class T> //函数模板，T为虚拟函数void XL_Array<T>::prt_XL_Array(){int k,kk;B<T> *p;p=head;for(k=0;k<mm;k++) //按⾏输出{for(kk=0;kk<nn;kk++) //输出⼀⾏if(p!=NULL){if((p->i==k)&&(p->j==kk))//输出⾮零元素{cout<<setw(8)<<p->v;p=p->next;}else cout<<setw(8)<<0;//输出0}else cout<<setw(8)<<0; //输出0cout<<endl;}return;}//稀疏矩阵转置template<class T> //函数模板，T为虚拟函数XL_Array<T> XL_Array<T>::tran_XL_Array(){XL_Array<T> at; //定义转置矩阵对象int p;B<T> *s,*k,*q;at.mm=nn; //转置矩阵⾏、列数及⾮零元素个数 at.nn=mm;at.tt=tt;k=NULL;for(p=0;p<nn;p++)for(q=head;q!=NULL;q=q->next){if(q->j==p){s=new B<T>; //申请⼀个三元组结点s->i=q->j;s->j=q->i;s->v=q->v;s->next=NULL;if(k==NULL)at.head=s;else k->next=s;k=s;}}return(at); //返回转置矩阵}//稀疏矩阵相加template<class T> //函数模板，T为虚拟函数XL_Array<T> XL_Array<T>::operator + (XL_Array<T> &b){XL_Array<T> c; //定义和矩阵对象T d;B<T> *m,*n,*q,*s;int k=0;q=NULL; //记住链尾if((mm!=b.mm)||(nn!=b.nn))cout<<"不能相加！"<<endl;else{m=head;n=b.head;while ((m!=NULL) && (n!=NULL)){if(m->i==n->i) //⾏号相同{if(m->j==n->j) //列号相同则相加{d=m->v+n->v;if(d!=0) //相加后⾮零{s=new B<T>; //申请⼀个三元组结点s->i=m->i;s->j=m->j;s->v=d;s->next=NULL;if(q==NULL)c.head=s;else q->next=s;q=s; //记住链尾k=k+1; //⾮零元素个数加1}m=m->next;n=n->next;}else if(m->j < n->j)//列号不同则复制列号⼩的⼀项{s=new B<T>; //申请⼀个三元组结点s->i=m->i;s->j=m->j;s->v=m->v;s->next=NULL;if(q==NULL)c.head=s;else q->next=s;q=s; //记住链尾k=k+1; //⾮零元素个数加1m=m->next;}else//列号不同复制另⼀项{s=new B<T>; //申请⼀个三元组结点s->i=n->i;s->j=n->j;s->v=n->v;s->next=NULL;if(q==NULL)c.head=s;else q->next=s;q=s; //记住链尾k=k+1; //⾮零元素个数加1n=n->next;}}else if(m->i<n->i) //复制矩阵中⾏号⼩的⾮零元素{s=new B<T>; //申请⼀个三元组结点s->i=m->i;s->j=m->j;s->v=m->v;s->next=NULL;if(q==NULL)c.head=s;else q->next=s;q=s; //记住链尾k=k+1; //⾮零元素个数加1m=m->next;}else//复制另⼀矩阵中本⾏的⼀个⾮零元素 {s=new B<T>; //申请⼀个三元组结点s->i=n->i;s->j=n->j;s->v=n->v;s->next=NULL;if(q==NULL)c.head=s;else q->next=s;q=s; //记住链尾k=k+1; //⾮零元素个数加1n=n->next;}}while (m!=NULL) //复制矩阵中剩余的⾮零元素{s=new B<T>; //申请⼀个三元组结点s->i=m->i;s->j=m->j;s->v=m->v;s->next=NULL;if(q==NULL)c.head=s;else q->next=s;q=s; //记住链尾k=k+1; //⾮零元素个数加1m=m->next;}while (n!=NULL) //复制另⼀矩阵中剩余的⾮零元素{s=new B<T>; //申请⼀个三元组结点s->i=n->i;s->j=n->j;s->v=n->v;s->next=NULL;if(q==NULL)c.head=s;else q->next=s;q=s; //记住链尾k=k+1; //⾮零元素个数加1n=n->next;}c.mm=mm; c.nn=nn; c.tt=k;}return(c); //返回相加结果}void main(){double a[7][8]={ {0,0,3,0,0,0,0,1},{0,0,0,0,0,0,0,0},{9,0,0,0,0,0,0,0},{0,0,0,0,7,0,0,0},{0,0,0,0,0,0,6,0},{0,0,0,2,0,3,0,0},{0,0,5,0,0,0,0,0}};XL_Array<double>x,y,z,xt,c;x.th_XL_Array(7,8,&a[0][0]);cout<<"输出稀疏矩阵x："<<endl;x.prt_XL_Array();xt=x.tran_XL_Array(); //稀疏矩阵转置cout<<"输出稀疏矩阵x的转置xt:"<<endl;xt.prt_XL_Array();y.in_XL_Array(); //以三元组形式从键盘输⼊稀疏矩阵⾮零元素 cout<<"输出稀疏矩阵y:"<<endl;y.prt_XL_Array();z=x+y; //稀疏矩阵相加cout<<"输出稀疏矩阵z=x+y:"<<endl;z.prt_XL_Array();}。

c语言 三元组表的存储结构描述

c语言 三元组表的存储结构描述

C语言三元组表的存储结构描述一、概述1. 三元组表是一种用于稀疏矩阵的存储结构，其主要用途是节省内存空间，提高数据存取效率。

2. 在C语言中，三元组表的存储结构通常采用数组来实现，具体来说，是通过定义一个结构体数组来表示稀疏矩阵。

二、结构定义3. 我们需要定义三元组表的结构体，该结构体通常由三个字段组成，分别表示稀疏矩阵的行标、列标和元素值。

4. 在C语言中，可以通过如下方式定义三元组表的结构体：```ctypedef struct{int row; // 行标int col; // 列标int value; // 元素值} Triplet;```三、存储方式5. 在C语言中，三元组表的存储方式通常采用一维数组来实现，数组中的每个元素都是一个三元组，用来表示稀疏矩阵中的一个非零元素。

6. 为了便于操作，通常还会在数组的第一个位置存储矩阵的行数、列数和非零元素的个数。

7. 以一个 3x3 的稀疏矩阵为例，其三元组表的存储结构可以表示为： ```c3 34 // 表示矩阵的行数、列数和非零元素的个数0 1 2 // 表示第一行第二列的元素值为21 0 -1 // 表示第二行第一列的元素值为-11 2 3 // 表示第二行第三列的元素值为32 2 1 // 表示第三行第三列的元素值为1```四、基本操作8. 三元组表的存储结构在C语言中通常会包含一些基本操作，以便对稀疏矩阵进行常见操作，例如转置、相加等。

9. 这些基本操作在C语言中通常会被封装成函数，例如：- create_triplet: 创建三元组表- print_triplet: 打印三元组表- transpose_triplet: 转置三元组表- add_triplet: 两个稀疏矩阵相加五、优缺点10. 三元组表的存储结构在C语言中具有一定的优点，包括节省存储空间、提高数据存取效率等。

11. 然而，其缺点在于需要额外的操作来处理稀疏矩阵，对于一般的稠密矩阵来说，可能并不适用。

数据结构C语言版稀疏矩阵的三元组顺序表存储表示和实现

数据结构C语言版稀疏矩阵的三元组顺序表存储表示和实现

typedef int ElemType;// 稀疏矩阵的三元组顺序表存储表示define MAXSIZE 100 // 非零元个数的最大值typedef struct{int i;j; // 行下标;列下标ElemType e; // 非零元素值}Triple;typedef struct{Triple dataMAXSIZE+1; // 非零元三元组表;data0未用int mu;nu;tu; // 矩阵的行数、列数和非零元个数}TSMatrix;// 创建稀疏矩阵Mint CreateSMatrixTSMatrix M{int i;m;n;ElemType e;int k;printf"请输入矩阵的行数;列数;非零元素个数：逗号\n";scanf"%d;%d;%d";&M.mu;&M.nu;&M.tu;M.data0.i=0; // 为以下比较顺序做准备fori = 1; i <= M.tu; i++{do{printf"请按行序顺序输入第%d个非零元素所在的行1～%d;""列1～%d;元素值：逗号\n"; i;M.mu;M.nu;scanf"%d;%d;%d";&m;&n;&e;k=0;// 行或列超出范围ifm < 1 || m > M.mu || n < 1 || n > M.nuk=1;ifm < M.datai-1.i || m == M.datai-1.i&& n <= M.datai-1.j // 行或列的顺序有错k=1;}whilek;M.datai.i = m; //行下标M.datai.j = n; //列下标M.datai.e = e; //该下标所对应的值}return 1;}// 销毁稀疏矩阵M;所有元素置空void DestroySMatrixTSMatrix M{M.mu=0;M.nu=0;M.tu=0;}// 输出稀疏矩阵Mvoid PrintSMatrixTSMatrix M{int i;printf"\n%d行%d列%d个非零元素..\n";M.mu;M.nu;M.tu;printf"%4s%4s%8s\n"; "行"; "列"; "元素值";fori=1;i<=M.tu;i++printf"%4d%4d%8d\n";M.datai.i;M.datai.j;M.datai.e; }// 由稀疏矩阵M复制得到Tint CopySMatrixTSMatrix M;TSMatrix T{T=M;return 1;}// AddSMatrix函数要用到int compint c1;int c2{int i;ifc1<c2i=1;else ifc1==c2i=0;elsei=-1;return i;}// 求稀疏矩阵的和Q=M+Nint AddSMatrixTSMatrix M;TSMatrix N;TSMatrix Q{Triple Mp;Me;Np;Ne;Qh;Qe;ifM.mu=N.mureturn 0;ifM.nu=N.nureturn 0;Q.mu=M.mu;Q.nu=M.nu;Mp=&M.data1; // Mp的初值指向矩阵M的非零元素首地址Np=&N.data1; // Np的初值指向矩阵N的非零元素首地址Me=&M.dataM.tu; // Me指向矩阵M的非零元素尾地址Ne=&N.dataN.tu; // Ne指向矩阵N的非零元素尾地址Qh=Qe=Q.data; // Qh、Qe的初值指向矩阵Q的非零元素首地址的前一地址whileMp <= Me && Np <= Ne{Qe++;switchcompMp->i;Np->i{case 1:Qe=Mp;Mp++;break;case 0:// M、N矩阵当前非零元素的行相等;继续比较列switchcompMp->j;Np->j{case 1:Qe=Mp;Mp++;break;case 0:Qe=Mp;Qe->e+=Np->e;ifQe->e // 元素值为0;不存入压缩矩阵Qe--;Mp++;Np++;break;case -1:Qe=Np;Np++;}break;case -1:Qe=Np;Np++;}}ifMp>Me // 矩阵M的元素全部处理完毕whileNp<=Ne{Qe++;Qe=Np;Np++;}ifNp>Ne // 矩阵N的元素全部处理完毕whileMp<=Me{Qe++;Qe=Mp;Mp++;}Q.tu=Qe-Qh; // 矩阵Q的非零元素个数return 1;}// 求稀疏矩阵的差Q=M-Nint SubtSMatrixTSMatrix M;TSMatrix N;TSMatrix Q{int i;fori=1;i<=N.tu;i++N.datai.e=-1;AddSMatrixM;N;Q;return 1;}// 求稀疏矩阵的乘积Q=MNint MultSMatrixTSMatrix M;TSMatrix N;TSMatrix Q{int i;j;h=M.mu;l=N.nu;Qn=0;// h;l分别为矩阵Q的行、列值;Qn为矩阵Q的非零元素个数;初值为0 ElemType Qe;ifM.nu=N.mureturn 0;Q.mu=M.mu;Q.nu=N.nu;Qe=ElemType mallochlsizeofElemType; // Qe为矩阵Q的临时数组// 矩阵Q的第i行j列的元素值存于Qe+i-1l+j-1中;初值为0 fori=0;i<hl;i++Qe+i=0; // 赋初值0fori=1;i<=M.tu;i++ // 矩阵元素相乘;结果累加到Qeforj=1;j<=N.tu;j++ifM.datai.j==N.dataj.iQe+M.datai.i-1l+N.dataj.j-1 +=M.datai.e N.dataj.e;fori=1;i<=M.mu;i++forj=1;j<=N.nu;j++ifQe+i-1l+j-1=0{Qn++;Q.dataQn.e=Qe+i-1l+j-1;Q.dataQn.i=i;Q.dataQn.j=j;}freeQe;Q.tu=Qn;return 1;}// 算法5.1 P99// 求稀疏矩阵M的转置矩阵T..int TransposeSMatrixTSMatrix M;TSMatrix T{int p;q;col;T.mu=M.nu;T.nu=M.mu;T.tu=M.tu;ifT.tu{q=1;forcol=1;col<=M.nu;++col //先将列转换成行forp=1;p<=M.tu;++p //再将行转换成列ifM.datap.j==col{T.dataq.i=M.datap.j;T.dataq.j=M.datap.i;T.dataq.e=M.datap.e;++q;}}return 1;}// 算法5.2 P100// 快速求稀疏矩阵M的转置矩阵T..int FastTransposeSMatrixTSMatrix M;TSMatrix T{int p;q;t;col;num;cpot;num=int mallocM.nu+1sizeofint; // 生成数组0不用cpot=int mallocM.nu+1sizeofint; // 生成数组0不用T.mu=M.nu;T.nu=M.mu;T.tu=M.tu;ifT.tu{forcol=1;col<=M.nu;++colnumcol=0; // 设初值fort=1;t<=M.tu;++t // 求M中每一列含非零元素个数++numM.datat.j;cpot1=1;// 求第col列中第一个非零元在T.data中的序号forcol=2;col<=M.nu;++colcpotcol=cpotcol-1+numcol-1;forp=1;p<=M.tu;++p{col=M.datap.j;q=cpotcol;T.dataq.i=M.datap.j;T.dataq.j=M.datap.i;T.dataq.e=M.datap.e;++cpotcol;}}freenum;freecpot;return 1;}int main{TSMatrix A;B;C;printf"创建矩阵A: ";CreateSMatrix&A;PrintSMatrixA;printf"由矩阵A复制矩阵B: ";CopySMatrixA;&B;PrintSMatrixB;DestroySMatrix&B;printf"销毁矩阵B后:\n";PrintSMatrixB;printf"重创矩阵B:注意与矩阵A的行、列数相同;这样方便后面的测试""行、列分别为%d;%d\n"; A.mu; A.nu;CreateSMatrix&B;PrintSMatrixB;printf"矩阵C1A+B: ";AddSMatrixA;B;&C;PrintSMatrixC;DestroySMatrix&C;printf"矩阵C2A-B: ";SubtSMatrixA;B;&C;PrintSMatrixC;DestroySMatrix&C;printf"矩阵C3A的转置: ";TransposeSMatrixA;&C;PrintSMatrixC;DestroySMatrix&A;DestroySMatrix&B;DestroySMatrix&C;printf"创建矩阵A2: ";CreateSMatrix&A;PrintSMatrixA;printf"创建矩阵B3:行数应与矩阵A2的列数相同=%d\n";A.nu; CreateSMatrix&B;PrintSMatrixB;printf"矩阵C5AB: ";MultSMatrixA;B;&C;PrintSMatrixC;DestroySMatrix&A;DestroySMatrix&B;DestroySMatrix&C;printf"创建矩阵A: ";CreateSMatrix&A;PrintSMatrixA;FastTransposeSMatrixA;&B;printf"矩阵BA的快速转置: ";PrintSMatrixB;DestroySMatrix&A;DestroySMatrix&B;system"pause";return 0;}/输出效果：创建矩阵A: 请输入矩阵的行数;列数;非零元素个数：逗号3;3;3请按行序顺序输入第1个非零元素所在的行1～3;列1～3;元素值：逗号1;1;1请按行序顺序输入第2个非零元素所在的行1～3;列1～3;元素值：逗号1;3;2请按行序顺序输入第3个非零元素所在的行1～3;列1～3;元素值：逗号3;3;33行3列3个非零元素..行列元素值1 1 11 3 23 3 3由矩阵A复制矩阵B:3行3列3个非零元素..行列元素值1 1 11 3 23 3 3销毁矩阵B后:0行0列0个非零元素..行列元素值重创矩阵B:注意与矩阵A的行、列数相同;这样方便后面的测试行、列分别为3;3 请输入矩阵的行数;列数;非零元素个数：逗号3;3;3请按行序顺序输入第1个非零元素所在的行1～3;列1～3;元素值：逗号1;2;1请按行序顺序输入第2个非零元素所在的行1～3;列1～3;元素值：逗号2;1;2请按行序顺序输入第3个非零元素所在的行1～3;列1～3;元素值：逗号3;1;33行3列3个非零元素..行列元素值1 2 12 1 23 1 3矩阵C1A+B:3行3列6个非零元素..行列元素值1 1 11 2 11 3 22 1 23 1 33 3 3矩阵C2A-B:3行3列6个非零元素..行列元素值1 1 11 2 -11 3 22 1 -23 1 -33 3 3矩阵C3A的转置:3行3列3个非零元素..行列元素值1 1 13 1 23 3 3创建矩阵A2: 请输入矩阵的行数;列数;非零元素个数：逗号3;3;3请按行序顺序输入第1个非零元素所在的行1～3;列1～3;元素值：逗号1;1;1请按行序顺序输入第2个非零元素所在的行1～3;列1～3;元素值：逗号1;3;2请按行序顺序输入第3个非零元素所在的行1～3;列1～3;元素值：逗号3;3;33行3列3个非零元素..行列元素值1 1 11 3 23 3 3创建矩阵B3:行数应与矩阵A2的列数相同=3请输入矩阵的行数;列数;非零元素个数：逗号3;3;2请按行序顺序输入第1个非零元素所在的行1～3;列1～3;元素值：逗号1;3;1请按行序顺序输入第2个非零元素所在的行1～3;列1～3;元素值：逗号2;2;23行3列2个非零元素..行列元素值1 3 12 2 2矩阵C5AB:3行3列1个非零元素..行列元素值1 3 1创建矩阵A: 请输入矩阵的行数;列数;非零元素个数：逗号3;3;2请按行序顺序输入第1个非零元素所在的行1～3;列1～3;元素值：逗号1;2;2请按行序顺序输入第2个非零元素所在的行1～3;列1～3;元素值：逗号3;1;23行3列2个非零元素..行列元素值1 2 23 1 2矩阵BA的快速转置:3行3列2个非零元素..行列元素值1 3 22 1 2请按任意键继续. . . /。

C语言数据结构 稀疏矩阵

C语言数据结构 稀疏矩阵

实验十稀疏矩阵#include <stdio.h>#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0#define MAXSIZE 100typedef int Status;typedef float ElemType;typedef struct{int i,j; //非零元素行下标和列下标ElemType e; //非零元素值}Triple;typedef struct{Triple data[MAXSIZE+1];//非零元三元组表，data[0]不用int mu,nu,tu; //矩阵的行数、列数和非零元素个数}TSMatrix;TSMatrix NewMatrix(int m,int n); //新建一个三元组表示的稀疏矩阵Status InsertElem(TSMatrix *M,int row,int col,ElemType e);//在三元组表示的稀疏矩阵M，第row 行，第col 列位置插入元素e//插入成功，返回OK，否则返回ERRORStatus FindElem(const TSMatrix *M,int row,int col,ElemType *e);//查找三元组表示的稀疏矩阵M中，第row 行，第col列元素，若不为0，//则用e返回其值，并返回TRUE，否则返回FALSEStatus TransposeSMatrix(const TSMatrix *M,TSMatrix *T);//采用三元组表存储表示，求稀疏矩阵M的转置矩阵TStatus FastTransposeSMatrix(const TSMatrix *M,TSMatrix *T);//利用三元组顺序表存储表示，求稀疏矩阵M的转置矩阵TStatus MultSMatrix(const TSMatrix *M,const TSMatrix *T,TSMatrix *Q);//稀疏矩阵的乘法,如果符合乘法规则，Q返回M*T结果，并返回OK,否则返回ERRORvoid PrintSMatrix(const TSMatrix *M);//打印稀疏矩阵所有元素int main() {TSMatrix M=NewMatrix(3,4);TSMatrix T;TSMatrix Q;InsertElem(&M,3,2,3.65);InsertElem(&M,2,2,2.31);printf("\nM:");PrintSMatrix(&M);FastTransposeSMatrix(&M,&T);printf("\nT(Transpose of M):");PrintSMatrix(&T);MultSMatrix(&M,&T,&Q);printf("\nM*T=");PrintSMatrix(&Q);return 0;}TSMatrix NewMatrix(int m,int n){ //新建一个三元组表示的稀疏矩阵TSMatrix M;M.mu=m;M.nu=n;M.tu=0;return M;}Status InsertElem(TSMatrix *M,int row,int col,ElemType e){ //在三元组表示的稀疏矩阵M，第row 行，第col 列位置插入元素e//插入成功，返回OK，否则返回ERRORint i,t,p;if(M->tu>=MAXSIZE){//当前三元组表已满printf("\nError:There is no space in the matrix;\n");return ERROR;}if(row>M->mu||col>M->nu||row<1||col<1)//插入位置越界，不在1~mu或1~nu之间{printf("\nError:Insert position is beyond thearrange.\n");return ERROR;}p=1; //标志新元素应该插入的位置if(M->tu==0) //插入前矩阵M没有非零元素{M->data[p].i=row;M->data[p].j=col;M->data[p].e=e;M->tu++;return OK; }for(t=1;t<=M->tu;t++)//寻找合适的插入位置if((row>=M->data[t].i)&&(col>=M->data[t].j))p++;if(row==M->data[t-1].i && col==M->data[t-1].j){//插入前，该元素已经存在M->data[t-1].e=e;return OK; }for(i=M->tu;i>=p;i--){//移动p之后的元素M->data[i+1].i=M->data[i].i;M->data[i+1].j=M->data[i].j;M->data[i+1].e=M->data[i].e;} //插入新元素M->data[p].i=row;M->data[p].j=col;M->data[p].e=e;M->tu++;return OK; }Status FindElem(const TSMatrix *M,int row,int col,ElemType *e){//查找三元组表示的稀疏矩阵M中，第row 行，第col列元素，若不为0，//则用e返回其值，并返回TRUE，否则返回FALSEint p; for(p=1;p<=M->tu;p++)if(M->data[p].i==row&&M->data[p].j==col){*e=M->data[p].e;return TRUE;}return FALSE; }Status TransposeSMatrix(const TSMatrix *M,TSMatrix *T){//采用三元组表存储表示，求稀疏矩阵M的转置矩阵Tint col,p,q;T->mu=M->nu;T->nu=M->mu; T->tu=M->tu;if(T->tu){q=1;for(col=1;col<=M->mu;col++)for(p=1;p<=M->tu;p++)if(M->data[p].j==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;q++;}}return OK; }Status FastTransposeSMatrix(const TSMatrix *M,TSMatrix *T){//利用三元组顺序表存储表示，求稀疏矩阵M的转置矩阵Tint col,t,p,q,*num,*cpot;T->mu=M->nu;T->nu=M->mu;T->tu=M->tu;if(T->tu){num=(int *)malloc(sizeof(int)*M->tu);cpot=(int *)malloc(sizeof(int)*M->tu);if(!(num&&cpot)){printf("Apply for memory error.\n");exit(0);}for(col=1;col<=M->nu;col++)num[col]=0; //求M中每一列含有非零元素的个数for(t=1;t<=M->tu;t++)++num[M->data[t].j];cpot[1]=1; //求第col列中第一个非零元素在b.data中的序号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[q].e;++cpot[col];}//for}//ifreturn OK; }Status MultSMatrix(const TSMatrix *M,const TSMatrix *T,TSMatrix *Q){//稀疏矩阵的乘法,如果符合乘法规则，Q返回M*T 结果，并返回OK,否则返回ERRORint i,j,k,p;ElemType m,t,s;if(M->nu!=T->mu){printf("Sorry,these two matrice can't multiply.\n");return ERROR; }Q->mu=M->mu;Q->nu=T->nu;Q->tu=0;p=1;for(i=1;i<=Q->mu;i++){for(j=1;j<=Q->nu;j++){s=0;for(k=1;k<=M->nu;k++){if(FALSE==FindElem(M,i,k,&m))continue;if(FALSE==FindElem(T,k,j,&t))continue;s+=m*t; }if(s!=0){//Q[i][j]非零Q->data[p].i=i;Q->data[p].j=j;Q->data[p].e=s;p++;Q->tu++;}}}return OK;}void PrintSMatrix(const TSMatrix *M) {//打印稀疏矩阵所有元素int i,j,p=1;printf("\nsize:%d %d\n",M->mu,M->nu);if(!M->tu){//0矩阵printf("%g\n",0.0);return; }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) {printf("%g\t",M->data[p].e);p++;}else{printf("%g\t",0.0);}}printf("\n");}printf("\n");}。

稀疏矩阵的存储实现

稀疏矩阵的存储实现

稀疏矩阵的存储实现Company Document number：WUUT-WUUY-WBBGB-BWYTT-1982GT课程设计任务书学生姓名：宋吉松专业班级：软件1202班指导教师：李晓红工作单位：计算机科学与技术学院题目: 稀疏矩阵的存储实现初始条件：理论：学习了《数据结构》课程，掌握了一种计算机高级语言。

实践：计算机技术系实验中心提供计算机及软件开发环境。

要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）1、系统应具备的功能：（1）实现稀疏矩阵的三元组和十字链表两种存储结构（2）实现稀疏矩阵的基本运算（3）输出结果2、数据结构设计；3、主要算法设计；4、编程及上机实现；5、撰写课程设计报告，包括：（1）设计题目；（2）摘要和关键字（中文和英文）；（3）正文，包括引言、需求分析、数据结构设计、算法设计、有关技术的讨论、设计体会等；（4）结束语；（5）参考文献。

时间安排： 2013年12月16日--25日指导教师签名：李晓红 2013年12月14日系主任（或责任教师）签名：年月日摘要本课程设计在学习数据结构的前提下，运用c语言，对稀疏矩阵进行三元组存储和十字链表存储，并完成稀疏矩阵的转置，相加，相乘等基本运算。

关键词稀疏矩阵三元组十字链表基本运算Abstract This course is designed on the premise of learning datastructures using c language, for sparse matrix triple store to store and cross-linked, and were achieved under the two storage sparse matrix transpose, add, multiply, and other basic operations.Keywords sparse matrix triples Crusaders basic operations目录引言 (1)1 需求分析稀疏矩阵三元组表和十字链表两种存储的实现 (2)稀疏矩阵转置 (2)稀疏矩阵的相加相乘 (2)输出结果 (2)2 数据结构设计三元组的结构体 (2)十字链表的结构体 (3)3算法设计三元组...3 (5)三元组的相加 (5) (8) (10)十字链表 (11)..12主函数 (13)4 设计体会 (16)5 结束语 (16)附1 参考文献 (16)附2 源代码 (17)附3 运行结果 (38)引言什么是稀疏矩阵人们无法给出确切的定义，它只是一个凭人们的直觉来了解的概念。

稀疏矩阵(C语言描述)

稀疏矩阵(C语言描述)

//矩阵减法实现主模块
{
void PRINTF(RLSMatrix*Result); Result->tu=0 ; Result->mu=A->mu ; Result->nu=A->nu ; int x=1 ; int y=1 ; int z=1 ;
while(x<=A->tu) {
if(A->data[x].i<B->data[y].i) {
void PRINTF(RLSMatrix*Result);
int ctemp[MAXRC]; int tp,p,t,arow,brow,q,ccol,i ;
Result->mu=A->mu ; Result->nu=B->nu ; Result->tu=0 ; if(A->tu*B->tu!=0) {
基本操作:
第 1 页 共 12 页
－＝数据结构试验报告＝－
系数矩阵运算器
creat( ) 操作结果:以一个二维数组创建稀疏矩阵,用三元组来存储. add(RLSMatrix M , RLSMatrix N) 初始条件:稀疏矩阵 M 与 N 的行数与列数对应相等. 操 作结果:求得一个矩阵和. jian(RLSMatrix a,RLSMatrix b) 初始条件:稀疏矩阵 M 与 N 的行数与列数对应相等. 操 作结果:求得一个矩阵差. transpose(RLSMatrix M) 初始条件:稀疏矩阵 M 存在 操作结果:求稀疏矩阵 M 的转置矩阵. value(RLSMatrix M,int m,int n) 初始条件:稀疏矩阵 M 存在. 操作结果:求出三元组存储中第 m 行第 n 列的数值. print1(RLSMatrix M) 初始条件:稀疏矩阵 M 存在. 操作结果:按矩阵的形式输出

数据结构-稀疏矩阵的三元组表存储方法

数据结构-稀疏矩阵的三元组表存储方法

0 0 -3 0 0 15
0 12 9 0 0 0 0
12 0 0 0 18 0
00 00000
9 0 0 24 0 0
M= -3 0 0 0 0 14 0 0 0 24 0 0 0 0
求解 N=
0 0 0 0 0 -7 0000 00
0 18 0 0 0 0 0
0 0 14 0 0 0
15 0 0 0 0 0
4 3 24 5 2 18
注意：
data 7 data 8
6 1 15 6 4 -7
mu=6 nu=7 tu=8
为了保存矩阵的行数、列 数和非零元素个数，还需 增设三个量：mu nu tu
3.三元组线性表的数据类型描述
#define MAXSIZE 12500 //非零元素个数的最大值
typedef struct{
稀疏矩阵的压缩存储 ———三元组表
一、什么是稀疏矩阵(sparse matrix)
如果矩阵M中的大多数元素均 为零元素，则称矩阵M为稀疏矩 阵 。一般地，当非零元素个数 只占矩阵元素总数的25%—30%, 或低于这个百分数时，我们称这样 的矩阵为稀疏矩阵。
一、什么是稀疏矩阵(sparse matrix)
3.算法描述
status TransposeSMatrix(TSMatrix a, TSMatrix *b){ (*b).mu=a.nu; (*b).nu=a.mu; (*b).tu=a.tu; if ((*b).tu) { q= 1; for (col= 1 ; col<= a.nu ; + + col) for (p= 1 ; p<= a.tu ; + +p) if (a.data[p] .j = =col) { b.data[q].i=a.data[p] .j; b.data[q].j=a.data[p] .i; b.data[q].e=a.data[p].e; ++q; } return OK;

c语言以三元顺序表表示稀疏矩阵

c语言以三元顺序表表示稀疏矩阵

C语言以三元顺序表表示稀疏矩阵1. 引言稀疏矩阵是指大部分元素为零的矩阵，通常在实际应用中占据大量存储空间。

为了高效处理稀疏矩阵，我们通常会采用三元组顺序表的方式进行表示。

本文将探讨如何使用C语言以三元顺序表表示稀疏矩阵，深入理解其原理和实现方法。

2. 稀疏矩阵的表示方法在C语言中，我们可以使用三元组顺序表来表示稀疏矩阵。

三元组顺序表包括三个部分：行号、列号和元素值。

通过这种方式，我们可以有效地压缩稀疏矩阵，节省存储空间，并且方便进行相关的运算。

3. 三元顺序表的数据结构在C语言中，我们可以使用结构体来定义三元顺序表的数据结构。

具体而言，我们可以定义一个包含行号、列号和元素值的结构体，然后通过数组来存储这些结构体，从而表示整个稀疏矩阵。

4. 如何实现C语言表示稀疏矩阵在C语言中，我们可以通过以下步骤来实现稀疏矩阵的表示：1. 定义一个结构体来存储稀疏矩阵的三元组信息。

2. 创建一个数组，用来存储这些结构体，从而表示整个稀疏矩阵。

3. 编写相关的函数，实现稀疏矩阵的压缩、展开以及相关的运算操作。

5. 样例代码下面是一段简单的C语言代码，用来表示一个稀疏矩阵，并进行相关的计算操作：```#include <stdio.h>#define MAXSIZE 12500// 定义三元组结构体typedef struct {int row;int col;int value;} Triple;// 定义稀疏矩阵typedef struct {Triple data[MAXSIZE + 1]; // 0号单元存储矩阵的行数、列数和非零元个数int mu, nu, tu; // 矩阵的行数、列数和非零元个数} TSMatrix;// 主函数int main() {// 在这里编写相关的稀疏矩阵操作return 0;}```6. 总结与展望通过本文的讨论，我们深入了解了C语言以三元顺序表表示稀疏矩阵的原理和实现方法。

稀疏矩阵的三元组表示和实现

稀疏矩阵的三元组表示和实现

稀疏矩阵的三元组表示和实现
稀疏矩阵是指其中大部分元素为0的矩阵。

为了节省存储空间和提高计算效率，常常使用三元组表示法来表示稀疏矩阵。

稀疏矩阵的三元组表示由三个数组组成，分别存储非零元素的行号、列号和值。

具体实现如下：
1. 定义一个结构体来表示稀疏矩阵的三元组，包括行号、列号和值。

```C++
struct SparseMatrix {
int row;
int col;
int value;
};
```
2. 创建一个数组，用来存储稀疏矩阵中的非零元素的三元组。

```C++
SparseMatrix sparseMatrix[maxSize]; // maxSize为稀疏矩阵中非零元素的个数
```
3. 初始化稀疏矩阵的三元组表示。

4. 对于每个非零元素，将其行号、列号和值存入稀疏矩阵的三元组数组中。

```C++
sparseMatrix[i].row = ...; // 非零元素的行号
sparseMatrix[i].col = ...; // 非零元素的列号
sparseMatrix[i].value = ...; // 非零元素的值
```
稀疏矩阵的三元组表示将只有非零元素的信息存储，从而节省了存储空间。

同时，通过遍历只包含非零元素的数组，可以高效地进行各种矩阵运算。

数据结构-稀疏矩阵的三元组表存储方法

数据结构-稀疏矩阵的三元组表存储方法

a .data 3 3 1 -3
b .data 3 2 1 12
a .data 4 3 6 14 求得 b .data 4 2 5 18
a .data 5 a .data 6 a .data 7
4 3 24
5 2 18 无!
6 1 15
b .data 5 b .data 6 b .data 7
31 9 3 4 24 4 6 -7
b .data 2 1 6 15
a .data 3 3 1 -3
b .data 3 2 1 12
a .data 4 3 6 14 求解 b .data 4 2 5 18
a .data 5 4 3 24
b .data 5 3 1 9
a .data 6 5 2 18
b .data 6 3 4 24
a .data 7 6 1 15
a .data 5 4 3 24
b .data 5
a .data 6 5 2 18
b .data 6
a .data 7 6 1 15
b .data 7
a .data 8 6 4 -7
b .data 8
a. mu=6 a. nu=7 a. tu=8 注:p=1:8,寻找 j=col 的a.data[ p]
a .data 2 1 3 9 Col=6 b .data 2 1 6 15
a .data 3 a .data 4
3 1 -3
b .data 3
3 6 14 求得 b .data 4
2 1 12 2 5 18
a .data 5 4 3 24
b .data 5 3 1 9
a .data 6 5 2 18
2.求解步骤分析：p=1:8, q的值=7

数据结构C语言版-稀疏矩阵三元组的基本操作讲解学习

数据结构C语言版-稀疏矩阵三元组的基本操作讲解学习
1.2课程名称：数据结构
1.3设计要求
学会分析研究计算机加工的数据结构的特性，以便为应用涉及的数据选择适当的逻辑结构，存储结构及其相应的算法，算法要求用C语言完成。学生独立思考解决问题为主，教师指导为辅，结合上机操作，完成指定的任务，撰写课程设计报告。要求源代码有足够的注释，能达到题目要求，并使人能看得懂你的代码。
3.2题目内容…………………………………………………………………………………...6
3.3题目分析…………………………………………………………………………………...6
4．概要设计………………………………………………………………………………….7
4.1稀疏矩阵存储结构………………………………………………………………………..7
数据结构C语言版-稀疏矩阵三元组的基本操作
数据结构
课程设计实验报告
内容名称：稀疏矩阵的基本操作
成员1：09213020-陈东
成员2：09213040-Fra bibliotek丹班级：09数31
教师：李晓翠
江苏师范大学
数学科学学院
1.序言…………………….........................................................................................................3
基于此原因，我们开设了数据结构课程设计。针对数据结构课程的特点，着眼于培养我们的实践能力。实习课程是为了加强编程能力的培养，鼓励学生使用新兴的编程语言。相信通过数据结构课程实践，无论是理论知识，还是实践动手能力，同学们都会有不同程度上的提高。
1.2课程设计的目的
巩固和深刻理解“数据结构（C语言版）”课程所讲解的C语言作为数据结构的算法的描述，掌握对数据的存储结构和算法进行描述时，尽量考虑C语言的特色。培养学生独立工作和创新思维的能力，取得设计与调试的实践经验。提高和加强计算机应用及软件开发能力。通过课程设计题目的练习，强化学生对所学知识的掌握及对问题分析和任务定义的理解，对每到题目作出了相应的逻辑分析和数据结构的选择，通过对任务的分析，为操作对象定义相应的数据结构，以过程化程序设计的思想方法为原则划分各个模块，定义数据的抽象数据类型。分模块对题目进行设计，强化学生对C语言的掌握和对数据结构的选择及掌握。通过程序的编译掌握对程序的调试方法及思想，并且让学生学会使用一些编程技巧。促使学生养成良好的编程习惯，以及让学生对书本上的知识进行了实践。算法与数据结构这门课是计算机科学中一门综合性的专业基础课

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

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

实现稀疏矩阵(采用三元组表示)的基本运算实验报告实现稀疏矩阵（采用三元组表示）的基本运算实验报告一实验题目: 实现稀疏矩阵（采用三元组表示）的基本运算二实验要求:（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中进行加法运算。

数据结构课程设计-稀疏矩阵

数据结构课程设计-稀疏矩阵

数据结构课程设计报告设计题目：稀疏矩阵专业：计算机科技院系：计算机学院姓名：xxxxxxx学号：xxxxxxxx时间：2013年9月22日目录一需求分析---------------------------------------------------------------- 31.问题描述-------------------------------------------------------------------------------------- 32.基本要求-------------------------------------------------------------------------------------- 33 实现提示-------------------------------------------------------------------------------------- 3二概要设计----------------------------------------------------------------------3三详细设计----------------------------------------------------------------------4四调试分析-------------------------------------------------------------------- 10五用户手册---------------------------------------------------------------------11一需求分析1.【问题描述】稀疏矩阵是指那些多数元素为零的矩阵。

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

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

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;}```请注意，上述代码只是一个简单示例，实际应用中可能需要根据具体需求进行优化和扩展。

数据结构C语言版-稀疏矩阵的三元组顺序表存储表示和实现

数据结构C语言版-稀疏矩阵的三元组顺序表存储表示和实现

typeｄef int EｌemTｙpｅ;// 稀疏矩阵得三元组顺序表存储表示#define ＭＡXＳIZＥ 1０0 ／/ 非零元个数得最大值tyｐedef strｕcｔ｛iｎt i,j；ﻩ／/ 行下标，列下标ﻩＥlｅmType e；// 非零元素值}Triｐle；typeｄef ｓtruct｛Triple dａta[ＭＡXＳＩＺE+1］；／/ 非零元三元组表，datａ[0］未用ﻩｉnt ｍu，ｎu，ｔｕ；ﻩﻩ/／矩阵得行数、列数与非零元个数}TＳMａtrｉx；／/ 创建稀疏矩阵Ｍint CreateSMatrｉx(TＳMatrix *M）｛ﻩinｔｉ,m，n；ﻩElemＴｙpe e;ﻩint k；printf("请输入矩阵得行数，列数，非零元素个数：(逗号）\ｎ”）;ﻩscanf（”％d，％d，％d”，＆(＊M）、mu，&（*M）、nu，＆（*M）、tu）;（＊Ｍ）、data[0]、i＝0；ﻩ// 为以下比较顺序做准备ﻩｆor（i = 1；ｉ〈＝ (＊M)、tu; i++)ﻩ｛ﻩdｏﻩﻩ{ﻩﻩﻩpｒｉntf("请按行序顺序输入第％ｄ个非零元素所在得行（１~%d），＂ﻩﻩ＂列(1～％d），元素值:（逗号)\n", i,(*M）、mu，（*M)、nｕ）；ﻩﻩscａnｆ（＂%d，%d，％d＂，＆m,＆n，＆e)；ﻩk＝０;ﻩﻩ/／行或列超出范围if(m 〈 1 ｜｜m 〉（*M)、mｕ |｜ｎ＜ 1 |｜n > （＊M)、nu）ﻩﻩk=1;ﻩﻩif（m ＜（＊M)、data［i—１］、i ｜｜ｍ＝= (＊M）、datａ［i-1]、ｉﻩﻩ&＆n <= (*M）、dａｔa［i—１]、j） // 行或列得顺序有错ﻩﻩk=1；ﻩ｝while（k)；ﻩ（＊Ｍ）、daｔa[i]、i = ｍ；／/行下标(*M)、datａ［i]、j ＝ n；//列下标（＊M）、data［i]、ｅ = e；ﻩ//该下标所对应得值｝return 1；}// 销毁稀疏矩阵M,所有元素置空voiｄ DesｔｒoyＳＭａｔrix(TSＭatｒix *Ｍ）{ﻩ（＊M）、mu=0；ﻩ（＊M)、nu=0；ﻩ（＊M）、tｕ＝０；}／/ 输出稀疏矩阵MvoｉｄPrintＳMatriｘ(TSMatrｉｘM){int i；ﻩprｉnｔf("＼n％d行%d列％ｄ个非零元素。

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

数据结构C语言版稀疏矩阵的三元组顺序表存储表示和实现.txt对的时间遇见对的人是一生幸福；对的时间遇见错的人是一场心伤；错的时间遇见对的人是一段荒唐；错的时间遇见错的人是一声叹息。

/*数据结构C语言版稀疏矩阵的三元组顺序表存储表示和实现P98编译环境：Dev-C++ 4.9.9.2日期：2011年2月8日*/typedef int ElemType;// 稀疏矩阵的三元组顺序表存储表示#define MAXSIZE 100 // 非零元个数的最大值typedef struct{int i,j; // 行下标,列下标ElemType e; // 非零元素值}Triple;typedef struct{Triple data[MAXSIZE+1]; // 非零元三元组表,data[0]未用int mu,nu,tu; // 矩阵的行数、列数和非零元个数}TSMatrix;// 创建稀疏矩阵Mint CreateSMatrix(TSMatrix *M){int i,m,n;ElemType e;int k;printf("请输入矩阵的行数,列数,非零元素个数：（逗号）\n");scanf("%d,%d,%d",&(*M).mu,&(*M).nu,&(*M).tu);(*M).data[0].i=0; // 为以下比较顺序做准备for(i = 1; i <= (*M).tu; i++){do{printf("请按行序顺序输入第%d个非零元素所在的行(1～%d),""列(1～%d),元素值：(逗号)\n", 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).data[i-1].j) // 行或列的顺序有错k=1;}while(k);(*M).data[i].i = m; //行下标(*M).data[i].j = n; //列下标(*M).data[i].e = e; //该下标所对应的值}return 1;}// 销毁稀疏矩阵M，所有元素置空void DestroySMatrix(TSMatrix *M){(*M).mu=0;(*M).nu=0;(*M).tu=0;}// 输出稀疏矩阵Mvoid PrintSMatrix(TSMatrix M){int i;printf("\n%d行%d列%d个非零元素。

\n",M.mu,M.nu,M.tu);printf("%4s%4s%8s\n", "行", "列", "元素值");for(i=1;i<=M.tu;i++)printf("%4d%4d%8d\n",M.data[i].i,M.data[i].j,M.data[i].e); }// 由稀疏矩阵M复制得到Tint CopySMatrix(TSMatrix M,TSMatrix *T){(*T)=M;return 1;}// AddSMatrix函数要用到int comp(int c1,int c2){int i;if(c1<c2)i=1;else if(c1==c2)i=0;elsei=-1;return i;}// 求稀疏矩阵的和Q=M+Nint AddSMatrix(TSMatrix M,TSMatrix N,TSMatrix *Q){Triple *Mp,*Me,*Np,*Ne,*Qh,*Qe;if(M.mu!=N.mu)return 0;if(M.nu!=N.nu)return 0;(*Q).mu=M.mu;(*Q).nu=M.nu;Mp=&M.data[1]; // Mp的初值指向矩阵M的非零元素首地址Np=&N.data[1]; // Np的初值指向矩阵N的非零元素首地址Me=&M.data[M.tu]; // Me指向矩阵M的非零元素尾地址Ne=&N.data[N.tu]; // Ne指向矩阵N的非零元素尾地址Qh=Qe=(*Q).data; // Qh、Qe的初值指向矩阵Q的非零元素首地址的前一地址while(Mp <= Me && Np <= Ne){Qe++;switch(comp(Mp->i,Np->i)){case 1:*Qe=*Mp;Mp++;break;case 0:// M、N矩阵当前非零元素的行相等,继续比较列switch(comp(Mp->j,Np->j)){case 1:*Qe=*Mp;Mp++;break;case 0:*Qe=*Mp;Qe->e+=Np->e;if(!Qe->e) // 元素值为0，不存入压缩矩阵Qe--;Mp++;Np++;break;case -1:*Qe=*Np;Np++;}break;case -1:*Qe=*Np;Np++;}}if(Mp>Me) // 矩阵M的元素全部处理完毕while(Np<=Ne){Qe++;*Qe=*Np;Np++;}if(Np>Ne) // 矩阵N的元素全部处理完毕while(Mp<=Me){Qe++;*Qe=*Mp;Mp++;}(*Q).tu=Qe-Qh; // 矩阵Q的非零元素个数return 1;}// 求稀疏矩阵的差Q=M-Nint SubtSMatrix(TSMatrix M,TSMatrix N,TSMatrix *Q){int i;for(i=1;i<=N.tu;i++)N.data[i].e*=-1;AddSMatrix(M,N,Q);return 1;}// 求稀疏矩阵的乘积Q=M*Nint MultSMatrix(TSMatrix M,TSMatrix N,TSMatrix *Q){int i,j,h=M.mu,l=N.nu,Qn=0;// h,l分别为矩阵Q的行、列值,Qn为矩阵Q的非零元素个数，初值为0 ElemType *Qe;if(M.nu!=N.mu)return 0;(*Q).mu=M.mu;(*Q).nu=N.nu;Qe=(ElemType *)malloc(h*l*sizeof(ElemType)); // Qe为矩阵Q的临时数组// 矩阵Q的第i行j列的元素值存于*(Qe+(i-1)*l+j-1)中，初值为0for(i=0;i<h*l;i++)*(Qe+i)=0; // 赋初值0for(i=1;i<=M.tu;i++) // 矩阵元素相乘，结果累加到Qefor(j=1;j<=N.tu;j++)if(M.data[i].j==N.data[j].i)*(Qe+(M.data[i].i-1)*l+N.data[j].j-1) +=M.data[i].e * N.data[j].e;for(i=1;i<=M.mu;i++)for(j=1;j<=N.nu;j++)if(*(Qe+(i-1)*l+j-1)!=0){Qn++;(*Q).data[Qn].e=*(Qe+(i-1)*l+j-1);(*Q).data[Qn].i=i;(*Q).data[Qn].j=j;}free(Qe);(*Q).tu=Qn;return 1;}// 算法5.1 P99// 求稀疏矩阵M的转置矩阵T。

int TransposeSMatrix(TSMatrix M,TSMatrix *T){int p,q,col;(*T).mu=M.nu;(*T).nu=M.mu;(*T).tu=M.tu;if((*T).tu){q=1;for(col=1;col<=M.nu;++col) //先将列转换成行for(p=1;p<=M.tu;++p) //再将行转换成列if(M.data[p].j==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;++q;}}return 1;}// 算法5.2 P100// 快速求稀疏矩阵M的转置矩阵T。

int FastTransposeSMatrix(TSMatrix M,TSMatrix *T){int p,q,t,col,*num,*cpot;num=(int *)malloc((M.nu+1)*sizeof(int)); // 生成数组（[0]不用）cpot=(int *)malloc((M.nu+1)*sizeof(int)); // 生成数组（[0]不用）(*T).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) // 求M中每一列含非零元素个数++num[M.data[t].j];cpot[1]=1;// 求第col列中第一个非零元在(*T).data中的序号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];}}free(num);free(cpot);return 1;}int main(){TSMatrix A,B,C;printf("创建矩阵A: ");CreateSMatrix(&A);PrintSMatrix(A);printf("由矩阵A复制矩阵B: ");CopySMatrix(A,&B);PrintSMatrix(B);DestroySMatrix(&B);printf("销毁矩阵B后:\n");PrintSMatrix(B);printf("重创矩阵B:(注意与矩阵A的行、列数相同，这样方便后面的测试""行、列分别为%d,%d)\n", A.mu, A.nu);CreateSMatrix(&B);PrintSMatrix(B);printf("矩阵C1(A+B): ");AddSMatrix(A,B,&C);PrintSMatrix(C);DestroySMatrix(&C);printf("矩阵C2(A-B): ");SubtSMatrix(A,B,&C);PrintSMatrix(C);DestroySMatrix(&C);printf("矩阵C3(A的转置): ");TransposeSMatrix(A,&C);PrintSMatrix(C);DestroySMatrix(&A);DestroySMatrix(&B);DestroySMatrix(&C);printf("创建矩阵A2: ");CreateSMatrix(&A);PrintSMatrix(A);printf("创建矩阵B3:(行数应与矩阵A2的列数相同=%d)\n",A.nu);CreateSMatrix(&B);PrintSMatrix(B);printf("矩阵C5(A*B): ");MultSMatrix(A,B,&C);PrintSMatrix(C);DestroySMatrix(&A);DestroySMatrix(&B);DestroySMatrix(&C);printf("创建矩阵A: ");CreateSMatrix(&A);PrintSMatrix(A);FastTransposeSMatrix(A,&B);printf("矩阵B(A的快速转置): ");PrintSMatrix(B);DestroySMatrix(&A);DestroySMatrix(&B);system("pause");return 0;}/*输出效果：创建矩阵A: 请输入矩阵的行数,列数,非零元素个数：（逗号）3,3,3请按行序顺序输入第1个非零元素所在的行(1～3),列(1～3),元素值：(逗号) 1,1,1请按行序顺序输入第2个非零元素所在的行(1～3),列(1～3),元素值：(逗号) 1,3,2请按行序顺序输入第3个非零元素所在的行(1～3),列(1～3),元素值：(逗号) 3,3,33行3列3个非零元素。

相关文档
最新文档