数据结构课程设计稀疏矩阵转置源程序代码

合集下载

数据结构 系数矩阵的表示和转置

数据结构 系数矩阵的表示和转置

实验四稀疏矩阵的表示和转置实验人:学号:时间:一、实验目的1.掌握稀疏矩阵的三元组顺序表存储结构2.掌握稀疏矩阵的转置算法。

二、实验内容采用三元组表存储表示,求稀疏矩阵M的转置矩阵T。

(算法5.1)三、实验步骤:1.构建稀疏矩阵M。

2.求稀疏矩阵M的转置矩阵T。

3.输出稀疏矩阵M和稀疏矩阵T。

四、算法说明五、测试结果六、分析与探讨七、附录:源代码源代码列在附录中,要求程序风格清晰易理解,有充分的注释。

有意义的注释行不少于30%。

#include"stdio.h"#include"stdlib.h"#define P 4#define N 5#define MAXSIZE 100typedef int ElementType;typedef struct{int row,col;ElementType e;}Triple;typedef struct{Triple data[MAXSIZE+1];int m,n,len;}TSMatrix;void InitMatrix(int A[P+1][N+1])//初始化矩阵{int i,j;printf("请输入一个4行5列的矩阵:\n");for(i=1;i<=P;i++){for(j=1;j<=N;j++){scanf("%d",&A[i][j]);}}for(i=1;i<P+1;i++){for(j=1;j<N+1;j++){printf("%d\t",A[i][j]);}printf("\n");}printf("\n");}TSMatrix MatrixToTriple(int A[P+1][N+1],TSMatrix M)//将一般的矩阵转换成三元组形式的{int r,c,k=0;for(r=1;r<=P;r++){for(c=1;c<=N;c++){if(A[r][c]!=0){k++;M.data[k].row=r;M.data[k].col=c;M.data[k].e=A[r][c];//一个小小的错误,将A[r][c]写成A[c][r],导致调了5个多小时} //调程序一定要认真啊(⊙o⊙)!}}M.m=P;M.n=N;M.len=k;return M;}TSMatrix FastTransposeTSMatrix(TSMatrix A,TSMatrix B){//稀疏矩阵的快速转置算法int lie,t,p,q;int num[MAXSIZE],position[MAXSIZE];B.len=A.len;B.m=A.n;B.n=A.m;if(B.len){for(lie=1;lie<=A.n;lie++){num[lie]=0;}for(t=1;t<=A.len;t++){num[A.data[t].col]++;}position[1]=1;for(lie=2;lie<=A.n;lie++){position[lie]=position[lie-1]+num[lie-1];}for(p=1;p<=A.len;p++){lie=A.data[p].col;q=position[lie];B.data[q].row=A.data[p].col;B.data[q].col=A.data[p].row;B.data[q].e=A.data[p].e;position[lie]++;}}return B;}void printMatrix(TSMatrix M){int B[N+1][P+1]={0};int i,j,k=1;for(i=1;i<N+1;i++){for(j=1;j<P+1;j++){if(i==M.data[k].row && j==M.data[k].col){B[i][j]=M.data[k].e;k++;}}}printf("稀疏矩阵转换成一般矩阵后,再进行打印:\n"); for(i=1;i<N+1;i++){for(j=1;j<P+1;j++){printf("%4d\t",B[i][j]);}printf("\n");}}void main(){int A[P+1][N+1]={0};TSMatrix M={{0},0,0,0},T={{0},0,0,0};InitMatrix(A);M=MatrixToTriple(A,M);T=FastTransposeTSMatrix(M,T);printMatrix(T);}。

数据结构实验2稀疏矩阵的建立与转置

数据结构实验2稀疏矩阵的建立与转置

实验2 稀疏矩阵的建立与转置(一)实验目的掌握特殊矩阵的存储和操作算法。

(二)问题描述实现用三元组保存稀疏矩阵并实现矩阵转置的算法。

(三)实验步骤1. 定义稀疏矩阵的三元组形式的存储结构。

2. 实现三元组矩阵的传统转置算法(pp99 的算法5.1)。

3. 实现三元组矩阵的快速转置算法。

4. 输入矩阵非零元素,测试自己完成的算法。

(四)程序流程图(五)参考代码#include <malloc.h>#include <stdio.h>#define MAXLEN 40typedef struct{ int i, j;int v;}NODE;typedef struct{ int m, n, t;NODE data[MAXLEN];}SPMA TRIX;SPMA TRIX transpose(SPMA TRIX a){/*稀疏矩阵(三元组存储结构)转置算法*/int p, q, col;SPMA TRIX b;b.m=a.n; b.n=a.m; b.t=a.t;if(a.t!=0){q = 1;for (col=1; col<=a.n; col++) //访问b三元组的每一行for (p=1; p<=a.t; p++) //访问a三元组的每一行if(a.data[p].j==col) //如果b三元组的行对应a数组的列,就进行转置{ b.data[q].j=a.data[p].i;b.data[q].i=a.data[p].j;b.data[q].v=a.data[p].v;q++;}}return b;}void printmatrix(SPMA TRIX c){/*稀疏矩阵(三元组存储结构)显示*/int n,i;n=c.t;for(i=1;i<=n;i++)printf("[%d]行号=%d 列号=%d 元素值=%d\n",i,c.data[i].i,c.data[i].j,c.data[i].v);}void main(){ SPMA TRIX a;SPMA TRIX b;int i,j,r,c,t,n;n=1;printf("\n\n输入矩阵行号数: ");scanf("%d",&r);printf("\n\n输入矩阵列号数: ");scanf("%d",&c);a.m=r; a.n=c;printf("\n\n");for(i=0;i<r;i++) /*输入矩阵元素值*/for(j=0;j<c;j++){printf("输入元素[%d,%d]值: ",i+1,j+1);scanf("%d",&t);if(t!=0) {a.data[n].i=i+1; /*非零元素存入稀疏矩阵三元组存储结构中*/a.data[n].j=j+1; a.data[n].v=t; n=n+1;}}n=n-1; a.t=n; /*a.t中为稀疏矩阵非零元素个数*/printf("\n\n稀疏矩阵三元组表示: \n\n");printmatrix(a); /*稀疏矩阵(三元组存储结构)转置*/b=transpose(a);printf("\n\n转置后稀疏矩阵三元组表示: \n\n");printmatrix(b);printf("\n\n");}(六)运行结果(七)心得体会掌握了特殊矩阵的存储和操作原理,编写了用三元组保存稀疏矩阵并实现矩阵转置的算法。

数据结构稀疏矩阵的转置

数据结构稀疏矩阵的转置

#include <stdio.h>#define N 101typedef struct{int row, col, value;}Triple;typedef struct{int rn;//行int cn;//列int tn;Triple data[N];}TMatix;void Transpore(TMatix stu1,TMatix stu2){int i, j;int col, q, p;printf("请输入数组的行数和列数:\n");scanf("%d%d", &stu1.rn, &);printf("请输入非零元素的个数:\n");scanf("%d", &stu1.tn);for(i = 0; i < stu1.tn; i++){printf("第%d个元素在第几行\n:", i+1);scanf("%d", &stu1.data[i].row);printf("第%d个元素在第几列\n:", i+1);scanf("%d", &stu1.data[i].col);printf("第%d个元素的大小\n:", i+1);scanf("%d", &stu1.data[i].value);}printf("-------- 三元组-----------\n");printf("行数:%d\n", stu1.rn);printf("列数:%d\n",);printf("非零元素个数:%d\n",stu1.tn);printf("行\t列\t大小\n");for(i = 0; i < stu1.tn; i++){printf("%d\t %d\t %d\n", stu1.data[i].row,stu1.data[i].col,stu1.data[i].value);}stu2.rn = ; = stu1.rn;stu2.tn = stu1.tn;if(stu2.tn){q = 0;for(col = 1; col <= ; ++col){for(p = 0; p <= stu1.tn; ++p){if(stu1.data[p].col == col){stu2.data[q].row = stu1.data[p].col;stu2.data[q].col = stu1.data[p].row;stu2.data[q].value = stu1.data[p].value;++q;}}}}printf("------ 转置三元组---------\n");printf("行数:%d\n", stu2.rn);printf("列数:%d\n",);printf("非零元素个数:%d\n",stu2.tn);printf("行\t列\t大小\n");for(i = 0; i < stu2.tn; i++){printf("%d\t %d\t %d\n", stu2.data[i].row,stu2.data[i].col,stu2.data[i].value);}}void Add(TMatix stu1, TMatix stu2, TMatix stu3){int i, j, c = 0 ;printf("构建第一个三元组:\n");printf("请输入数组的行数和列数:\n");scanf("%d%d", &stu1.rn, &);printf("请输入非零元素的个数:\n");scanf("%d", &stu1.tn);for(i = 0; i < stu1.tn; i++){printf("第%d个元素在第几行\n:", i+1);scanf("%d", &stu1.data[i].row);printf("第%d个元素在第几列\n:", i+1);scanf("%d", &stu1.data[i].col);printf("第%d个元素的大小\n:", i+1);scanf("%d", &stu1.data[i].value);}printf("-------- 三元组-----------\n");printf("行数:%d\n", stu1.rn);printf("列数:%d\n",);printf("非零元素个数:%d\n",stu1.tn);printf("行\t列\t大小\n");for(i = 0; i < stu1.tn; i++){printf("%d\t %d\t %d\n", stu1.data[i].row,stu1.data[i].col,stu1.data[i].value); }printf("构建第二个三元组:\n");printf("请输入数组的行数和列数:\n");scanf("%d%d", &stu2.rn, &);printf("请输入非零元素的个数:\n");scanf("%d", &stu2.tn);for(i = 0; i < stu2.tn; i++){printf("第%d个元素在第几行\n:", i+1);scanf("%d", &stu2.data[i].row);printf("第%d个元素在第几列\n:", i+1);scanf("%d", &stu2.data[i].col);printf("第%d个元素的大小\n:", i+1);scanf("%d", &stu2.data[i].value);}printf("-------- 三元组-----------\n");printf("行数:%d\n", stu2.rn);printf("列数:%d\n",);printf("非零元素个数:%d\n",stu2.tn);printf("行\t列\t大小\n");for(i = 0; i < stu2.tn; i++){printf("%d\t %d\t %d\n", stu2.data[i].row,stu2.data[i].col,stu2.data[i].value); }if(stu1.rn != stu2.rn || != )printf("两个矩阵行列数不相等,不能相加\n");else if(stu1.tn == 0 || stu2.tn == 0)printf("矩阵为零矩阵\n");else{int i = -1;int t1 = 0, t2 = 0;//初始化矩阵的行列数和非零元素个数stu3.rn = stu1.rn; = ;stu3.tn = 0;while(t1 < stu1.tn && t2 < stu2.tn){i++;stu3.tn++;if(stu1.data[t1].row == stu2.data[t2].row){if(stu1.data[t1].col == stu2.data[t2].col){stu3.data[i].row = stu1.data[t1].row;stu3.data[i].col = stu1.data[t1].col;stu3.data[i].value = stu1.data[t1].value + stu1.data[t2].value;t1++;t2++;}else if(stu1.data[t1].col < stu2.data[t2].col){stu3.data[i].row = stu1.data[t1].row;stu3.data[i].col = stu1.data[t1].col;stu3.data[i].value = stu1.data[t1].value;t1++;}else{stu3.data[i].row = stu2.data[t2].row;stu3.data[i].col = stu2.data[t2].col;stu3.data[i].value = stu2.data[t2].value;t2++;}}else if(stu1.data[t1].row < stu2.data[t2].row){stu3.data[i].row = stu1.data[t1].row;stu3.data[i].col = stu1.data[t1].col;stu3.data[i].value = stu1.data[t1].value;t1++;}else{stu3.data[i].row = stu2.data[t2].row;stu3.data[i].col = stu2.data[t2].col;stu3.data[i].value = stu2.data[t2].value;t2++;}}if(t2 < stu2.tn){while(t2 < stu2.tn){stu3.tn++;i++;stu3.data[i].row = stu2.data[t2].row;stu3.data[i].col = stu2.data[t2].col;stu3.data[i].value = stu2.data[t2].value;t2++;}}else if(t1 < stu1.tn){while(t1 < stu1.tn){stu3.tn++;i++;stu3.data[i].row = stu1.data[t1].row;stu3.data[i].col = stu1.data[t1].col;stu3.data[i].value = stu1.data[t1].value;t1++;}}printf("-------- 加的得三元组-----------\n");printf("行数:%d\n", stu3.rn);printf("列数:%d\n",);printf("非零元素个数:%d\n",stu3.tn);printf("行\t列\t大小\n");for(i = 0; i < stu3.tn; i++){printf("%d\t %d\t %d\n", stu3.data[i].row,stu3.data[i].col,stu3.data[i].value); }}void main(){int a;TMatix stu1;TMatix stu2;TMatix stu3;do{printf("------------------------------\n");printf("| 1. 三元组的转置|\n");printf("| 2. 三元组的加法|\n");printf("| 0. 退出|\n");printf(" ----------------------------\n");printf("请输入你的选择:\n");scanf("%d", &a);switch(a){case 1:Transpore(stu1, stu2);break;case 2:Add(stu1, stu2, stu3);break;default:printf("输入不符合要求,请重新输入:\n");break;}}while(a != 0);}。

数据结构课程设计之稀疏矩阵运算器

数据结构课程设计之稀疏矩阵运算器

数据结构课程设计之稀疏矩阵运算器#include#include#define maxsize 200typedef struct{int i,j;//i为非零元素在行,j为非零元所在列int e;//非零元}Tripe;typedef struct{Tripe data[maxsize];int h,l,total;//稀疏矩阵的行数列数及非零元个数}TSMatrix;void Creat(TSMatrix &M){//创建一个稀疏矩阵int a,b,c,x;scanf("%d,%d,%d",&M.h,&M.l,&M.total);for(x=1;x<=M.total;x++){printf("请输入第%d个稀疏矩阵的非零元素所在的行数列数用逗号隔开输完按回车键:\",x);scanf("%d,%d,%d",&a,&b,&c);M.data[x].i=a;M.data[x].j=b;M.data[x].e=c;}}void Print(TSMatrix &S){//输出稀疏矩阵int x;int c,b,a[maxsize][maxsize];for(c=1;c<=S.h;c++)for(b=1;b<=S.l;b++)a[c][b]=0;//全部初始化为零for(x=1;x<=S.total;x++){a[S.data[x].i][S.data[x].j]+=S.data[x].e;//在矩阵的相应位置附上非零元素}for(c=1;c<=S.h;c++)for(b=1;b<=S.l;b++){printf("%4d",a[c][b]);if(b==S.l)printf("\");}}void Add(TSMatrix T,TSMatrix V,TSMatrix &M){//加法运算int p=1,q=1;int b=1;if(T.h!=V.h||T.l!=V.l){printf("两矩阵行数或列数不同无法进行相加:\"); exit(0);}while(p<=T.total&&q<=V.total){if(T.data[p].i==V.data[q].i){if(T.data[p].j==V.data[q].j){M.data[b].i=T.data[p].i;M.data[b].e=T.data[p].e+V.data[q].e; p++;b++;q++;}else if(T.data[p].j<v.data[q].j)< p=""> {M.data[b].i=T.data[p].i;M.data[b].j=T.data[p].j;M.data[b].e=T.data[p].e;b++;p++;}else if(T.data[p].j>V.data[q].j){M.data[b].i=V.data[q].i;M.data[b].j=V.data[q].j;M.data[b].e=V.data[q].e;b++;q++;}}else if(T.data[p].i<v.data[q].i)< p=""> {M.data[b].i=T.data[p].i;M.data[b].j=T.data[p].j;M.data[b].e=T.data[p].e;b++;p++;}else if(T.data[p].i>V.data[q].i){M.data[b].i=V.data[q].i;M.data[b].j=V.data[q].j;b++;q++;}}//下面两个循环是把上面循环中未处理的数据添加到M中while(p<=T.total){M.data[b].i=T.data[p].i;M.data[b].j=T.data[p].j;M.data[b].e=T.data[p].e;b++;p++;}while(q<=V.total){M.data[b].i=V.data[q].i;M.data[b].j=V.data[q].j;M.data[b].e=V.data[q].e;b++;q++;}M.h=T.h;M.l=T.l;M.total=b-1; //b最后要减一,因为上面处理最后一个数时b也增加1了}void TransposTSMtrix(TSMatrix A,TSMatrix &B) //完成矩阵的转置,一次快速定位法{int j,t,p,q;int num[maxsize],position[maxsize];//num矩阵某列非零元个数,positionB.h=A.l;B.l=A.h;B.total=A.total;if(B.total){for(j=1;j<=A.l;j++)num[j]=0;for(t=1;t<=A.total;t++)num[A.data[t].j]++;position[1]=1;for(j=2;j<=A.l;j++)position[j]=position[j-1]+num[j-1];for(p=1;p<=A.total;p++){j=A.data[p].j;q=position[j];B.data[q].i=A.data[p].j;B.data[q].j=A.data[p].i;B.data[q].e=A.data[p].e;position[j]++;}}}void Jiansmatrix(TSMatrix M,TSMatrix N,TSMatrix &T){ int m=1,n=1,t=1;if(M.h!=N.h||M.l!=N.l){printf("两矩阵行数或列数不同无法进行相减");exit(0);} T.h=M.h;T.l=M.l;while(m<=M.total&&n<=N.total){{if(M.data[m].i==N.data[n].i)if(M.data[m].j==N.data[n].j){if(M.data[m].e==N.data[n].e){T.data[t].i=M.data[m].i;T.data[t].j=M.data[m].j;m++;n++;}else{T.data[t].e=M.data[m].e-N.data[n].e; T.data[t].i=M.data[m].i;T.data[t].j=M.data[m].j;t++;m++;n++;}}else if(M.data[m].j<n.data[n].j)< p=""> {T.data[t].e=M.data[m].e;T.data[t].i=M.data[m].i;T.data[t].j=M.data[m].j;t++;m++;}else if(M.data[m].j>N.data[n].j){T.data[t].e=0-N.data[n].e;T.data[t].i=N.data[n].i;T.data[t].j=N.data[n].j;t++;n++;}else{if(M.data[m].i<n.data[n].i)< p=""> {T.data[t].i=M.data[m].i;T.data[t].j=M.data[m].j;T.data[t].e=M.data[m].e;t++;m++;}else {T.data[t].e=0-N.data[n].e;T.data[t].i=N.data[n].i;T.data[t].j=N.data[n].j;t++;n++;}}}}while(M.total==(m-1)&&n<=N.total) {T.data[t].i=N.data[n].i;T.data[t].j=N.data[n].j;T.data[t].e=N.data[n].e;t++;n++;}while(N.total==(n-1)&&m<=M.total) {T.data[t].i=M.data[m].i;T.data[t].j=M.data[m].j;T.data[t].e=M.data[m].e;t++;m++;}T.total=t-1;}void Multsmatrix(TSMatrix M,TSMatrix N,TSMatrix &T) { int p,q,Qn=0;int a[200][200];if(M.l!=N.h){printf("两矩阵无法相乘");exit(0);}T.h=M.h;T.l=N.l;for(p=1;p<=M.h;p++)for(q=1;q<=N.l;q++)a[p][q]=0;for(p=1;p<=M.total;p++)for(q=1;q<=N.total;q++)if(M.data[p].j==N.data[q].i){a[M.data[p].i][N.data[q].j]+=M.data[p].e*N.data[q].e;}for(p=1;p<=M.h;p++)for(q=1;q<=N.l;q++)if(a[p][q]!=0){Qn++;T.data[Qn].e=a[p][q];T.data[Qn].i=p;T.data[Qn].j=q;}T.total=Qn;}void main(){TSMatrix ts1,ts2,ts3;int choice;do{printf("1.矩阵的转置!\");printf("2.两个矩阵相加!\");printf("3.两个矩阵相减!\");printf("4.两个矩阵相乘!\");printf("5.退出程序!\");printf("请输入您的选择:\");scanf("%d",&choice);switch(choice){case 1:printf("请输入矩阵的行和列及非零元个数用逗号隔开:\"); Creat(ts1);Print(ts1);TransposTSMtrix(ts1,ts2);printf("转置后的矩阵为:\");Print(ts2);break;case 2:printf("请输入第一个矩阵的行和列及非零元个数用逗号隔开:\"); Creat(ts1);printf("第一个矩阵为:\");Print(ts1);printf("请输入第二个矩阵的行和列及非零元个数用逗号隔开:\"); Creat(ts2);printf("第二个矩阵为:\");Print(ts2);Add(ts1,ts2,ts3);printf("以上两个矩阵相加后为:\");Print(ts3);break;case 3:printf("请输入第一个矩阵的行和列及非零元个数用逗号隔开:\"); Creat(ts1);printf("第一个矩阵为:\");Print(ts1);printf("请输入第二个矩阵的行和列及非零元个数用逗号隔开:\"); Creat(ts2);printf("第二个矩阵为:\");Print(ts2);Jiansmatrix(ts1,ts2,ts3);printf("以上两个矩阵相减后为:\");Print(ts3);break;case 4:printf("请输入第一个矩阵的行和列及非零元个数用逗号隔开:\"); Creat(ts1);printf("第一个矩阵为:\");Print(ts1);printf("请输入第二个矩阵的行和列及非零元个数用逗号隔开:\"); Creat(ts2);printf("第二个矩阵为:\");Print(ts2);Multsmatrix(ts1,ts2,ts3);printf("以上两个矩阵相乘后为:\");Print(ts3);break;case 5:exit(0);break;}}while(choice!=0); scanf("%d",&choice); }</n.data[n].i)<></n.data[n].j)<></v.data[q].i)<></v.data[q].j)<>。

c++实现:十字链表转置

c++实现:十字链表转置

数据结构实验报告实验题目:基于十字链表的稀疏矩阵转置实验内容及要求:编写程序,从字符文件读入三个正整数m, n, t以及t个三元组(i, j, e)建立稀疏矩阵的十字链表存储结构。

其中,m、n分别表示矩阵行数和列数;i, j为非零元素行号和列号。

编写算法,实现矩阵转置,输出转置后的三元组到另一字符文件中,检查你的转置结果是否正确。

要求转置时不得新建元素结点(但允许新建行头/列头结点数组以及删除行头/列头结点数组,转置前后,总头结点不允许改变)。

实验目的:掌握稀疏矩阵的十字链表存储结构。

数据结构设计简要描述:建立十字链表存储从文件中读取的三元组,进行转置后,再存入新建的空十字链表中输出。

算法设计简要描述:创建空十字链表,以插入结点的方式依次将从文件中读取的三元组存储于十字链表中;转置以行为主序,检测到三元组则断开原十字链表行、列结点,将此三元组插入新十字链表中,依次循环,直到原十字链表变空,进行空间销毁。

输入/输出设计简要描述:从Mytext1.txt文件中读入三个正整数m, n, t以及t个三元组(i, j, e),输出在屏幕上,进行转置后,输出转置后三元组在屏幕上,并且保存在文件Mytext2.txt中。

编程语言说明:使用Visual C++编程;主要代码采用C++语言实现。

主要函数说明:init(int m,int n) //创建空十字链表insert(OLink h,int i,int j,int e) //向十字链表插入结点Delete(OLink h) //销毁十字链表Trans(OLink h) //转置TransInsert(OLink hh,OLink p) //转置过程中在各行各列插入结点程序测试简要报告:(1)测试实例1程序输入:Mytext1.txt文件数据程序输出:Mytext2.txt文件存储、转置前和转置后数据(2)测试实例1程序输入:Mytext1.txt文件数据程序输出:Mytext2.txt文件存储、转置前和转置后数据(3)测试实例1程序输入:Mytext1.txt文件数据程序输出:Mytext2.txt文件存储、转置前和转置后数据源程序代码:#include "stdafx.h" #include <iostream> #include <iomanip> #include <fstream> using namespace std;//定义十字链表结构体typedef struct node{ int i,j;int e;struct node *right,*down;}OLNode,*OLink;//创建空十字链表OLink init(int m,int n){OLink h,row,col;int i,j;h=new OLNode;h->i =m; h->j =n;h->right =NULL; h->down =NULL;row=h->down =new OLNode[m];if(!h->down )return NULL;for(i=0;i<m;i++){row[i].i =i;row[i].right =&row[i];}col=h->right =new OLNode[n];if(!h->right )return NULL;for(j=0;j<n;j++){col[j].j =j;col[j].down =&col[j];}return h;}//销毁十字链表void Delete(OLink h){int m,n,k;OLink pr1,pr2,p1,p2;m=h->i ;n=h->j ;for(k=0;k<m;k++){pr1=&h->down[k] ;p1=pr1->right ;while(p1!=&h->down[k]){pr2=&h->right[p1->j];while(p2!=p1){pr2=p2;p2=p2->down;}pr1->right =p1->right ;pr2->down =p1->down ;delete p1;p1=pr1->right ;}}delete [] h->down ;delete [] h->right ;delete h;}//向十字链表插入结点void insert(OLink h,int i,int j,int e){ int m,n;m=h->i ;n=h->j ;if(i<0||i>=m||j>=n) return;OLink s,pr,p;s=new OLNode;if(!s) return;s->i =i;s->j =j;s->e =e;//连接横向循环链表pr=&h->down[i];p=pr->right;while(p!=&h->down[i]&&j>p->j){pr=p;p=p->right;}pr->right=s;s->right=p;//连接纵向循环链表pr=&h->right[j];p=pr->down;pr=p;p=p->down;}pr->down=s;s->down =p;return;}//转置过程中在各行各列插入结点void TransInsert(OLink hh,OLink p){OLink pr,pp;//横向链表插入pr=&hh->down[p->i];pp=pr->right ;while(pp!=&hh->down[p->i]&&p->j >pp->j){ pr=pp;pp=pp->right;}pr->right=p;p->right =pp;//纵向链表插入pr=&hh->right[p->j];pp=pr->down ;while(pp!=&hh->right[p->j]&&p->i >pp->i){ pr=pp;pp=pp->down;}pr->down=p;p->down=pp;}//转置OLink Trans(OLink h){int m,n,k,a;OLink hh,pr1,p1,pr2,p2;m=h->j ;n=h->i ;hh->i=m;hh->j=n;//进行转置放置for(k=0;k<n;k++){pr1=&h->down[k] ;p1=pr1->right ;while(p1!=&h->down[k]){pr2=&h->right[p1->j];p2=pr2->down;while(p2!=p1){pr2=p2;p2=p2->down;}pr1->right =p1->right ;pr2->down =p1->down ;a=p1->i ;p1->i=p1->j ;p1->j=a;TransInsert(hh,p1);p1=pr1->right ;}}//销毁原有的行、列头结点delete [] h->down ;delete [] h->right ;delete h;h=hh;return h;}//主函数调用void main(){int m,n,t,i,j,e,k;OLink h,pr,p;ifstream in("Mytext1.txt");ofstream out("Mytext2.txt");in>>m>>n>>t;cout<<"Mytext1.txt中的三元组:"<<endl;for(k=0;k<t;k++){in>>i>>j>>e;insert(h,i,j,e);cout<<i<<""<<j<<""<<e<<""<<endl;}cout<<endl<<"Mytext1.txt中三元组转置后(存放于Mytext2.txt):"<<endl;h=Trans(h);//按行顺序输出十字链表for(k=0;k<h->i;k++){pr=&h->down[k];p=pr->right ;while(p!=&h->down[k]){cout<<p->i<<""<<p->j<<""<<p->e<<""<<endl;out<<p->i<<""<<p->j<<""<<p->e<<""<<endl;pr=p;p=p->right ;}}//关闭文件、销毁申请空间in.close();out.close();Delete(h);cout<<endl;}。

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

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

稀疏矩阵应用摘要本课程设计主要实现在三元组存储结构与十字链表存储结构下输入稀疏矩阵,并对稀疏矩阵进行转置,相加,相乘操作,最后输出运算后的结果。

在程序设计中,考虑到方法的难易程度,采用了先用三元组实现稀疏矩阵的输入,输出,及其转置,相加,相乘操作的方法,再在十字链表下实现。

程序通过调试运行,结果与预期一样,初步实现了设计目标。

关键词程序设计;稀疏矩阵;三元组;十字链表1 引言1.1课程设计任务本课程设计主要实现在三元组存储结构与十字链表存储结构下输入稀疏矩阵,并对稀疏矩阵进行转置,相加,相乘操作,最后输出运算后的结果。

稀疏矩阵采用三元组和十字链表表示,并在两种不同的存储结构下,求两个具有相同行列数的稀疏矩阵A和B的相加矩阵C,并输出C;求出A的转置矩阵D,输出D;求两个稀疏矩阵A和B的相乘矩阵E,并输出E。

1.2课程设计性质数据结构课程设计是重要地实践性教学环节。

在进行了程序设计语言课和《数据结构》课程教学的基础上,设计实现相关的数据结构经典问题,有助于加深对数据结构课程的认识。

本课程设计是数据结构中的一个关于稀疏矩阵的算法的实现,包括在三元组和十字链表下存储稀疏矩阵,并对输入的稀疏矩阵进行转置,相加,相乘等操作,最后把运算结果输出。

此课程设计要求对数组存储结构和链表存储结构非常熟悉,并能熟练使用它们。

1.3课程设计目的其目的是让我们在学习完C、数据结构等课程基础上,掌握多维数组的逻辑结构和存储结构、掌握稀疏矩阵的压缩存储及转置,相加,相乘等基本操作,并用不同的方法输出结果,进一步掌握设计、实现较大系统的完整过程,包括系统分析、编码设计、系统集成、以及调试分析,熟练掌握数据结构的选择、设计、实现以及操作方法,为进一步的应用开发打好基础。

2需求分析2.1设计函数建立稀疏矩阵及初始化值和输出稀疏矩阵的值本模块要求设计函数建立稀疏矩阵并初始化,包括在三元组结构下和十字链表结构下。

首先要定义两种不同的结构体类型,在创建稀疏矩阵时,需要设计两个不同的函数分别在三元组和十字链表下创建稀疏矩阵,在输入出现错误时,能够对错误进行判别处理,初始化稀疏矩阵都为空值,特别注意在十字链表下,对变量进行动态的地址分配。

【数据结构算法】实验4 稀疏矩阵基本操作-链接结构(附源代码)

【数据结构算法】实验4 稀疏矩阵基本操作-链接结构(附源代码)

浙江大学城市学院实验报告课程名称数据结构与算法实验项目名称实验四稀疏矩阵的基本操作--用链接存储结构实验成绩指导老师(签名)日期一.实验目的和要求1.了解稀疏矩阵的三元组线性表存储方法。

2.掌握稀疏矩阵采用链式存储结构时基本操作的实现。

二. 实验内容1.编写稀疏矩阵采用带行指针向量的链接存储结构时基本操作的实现函数。

基本操作包括:①初始化稀疏矩阵;②输入稀疏矩阵;③输出稀疏矩阵;④稀疏矩阵的转置运算。

要求把稀疏矩阵的存储结构定义及基本操作实现函数存放在头文件LinkMatrix.h中,主函数main() 存放在主文件test7_2.cpp中,在主函数中通过调用LinkMatrix.h中的函数进行测试。

2.选做:编写稀疏矩阵的相乘运算实现函数,要求把该函数添加到头文件LinkMatrix.h中,并在主文件test7_2.cpp中添加相应语句进行测试。

3.填写实验报告,实验报告文件取名为report4.doc。

4.上传实验报告文件report4.doc与源程序文件LinkMatrix.h及test7_2.cpp到Ftp服务器上你自己的文件夹下。

三. 函数的功能说明及算法思路包括每个函数的功能说明,及一些重要函数的算法实现思路函数:void InitMatrix(LMatrix &M)功能:初始化稀疏矩阵思路:将稀疏矩阵的行、列、元素个数均置为0,元素指针数组全部置为NULL函数:void InputMatrix(LMatrix &M, int m, int n)功能:输入稀疏矩阵思路:以行、列、值的方式输入稀疏矩阵的每个元素函数:void OutputMatrix(LMatrix M)功能:输出稀疏矩阵思路:以行、列、值的方式输出稀疏矩阵的每个元素函数:void MyTranspose(LMatrix & M)功能:稀疏矩阵的转置运算思路:主要是通过添加一个指针数组,对M进行一次遍历,完全使用其原有的空间来进行转置。

数据结构实验之稀疏矩阵的转置

数据结构实验之稀疏矩阵的转置

实验六:稀疏矩阵的转置[实验题目]改编教材中一维数组类,增加成员函数Array1D<T> & operator +(Array1D<T>& c2);,可以做求和运算,并在主程序里输入完两个长度相同的一维数组之后,调用这个成员函数求和。

完善教材中稀疏矩阵,调试转置运算,并编写出两个重定义的流操作运算,并自行编写主程序验证输出两个三元组,稀疏矩阵转置是否成功。

[概要分析]对一个稀疏矩阵,写成行三元组形式,对行三元组扫描一次即可定位,而关键是找到每列(0,1,…,n-1)首个非0元素的位置,在新的三元组转置,记在k数组中。

分别建立SeqTriple.cpp、SeqTriple.h、TsteSeqTripleMain.cpp。

[详细设计]1.类的结构2.核心代码(1)转置思路:快速转置算法使用n个指针k[i](0<=i<n)(n是矩阵的列数),指向稀疏矩阵M中i列的第一个非零元素在转置后的三元组B中的存放位置。

有了k[i],只要对三元组扫描一次即可定位。

关键在于找到每列首个非零元素的位置k[0]=0;k[i]=k[i-1]+num[i-1];具体代码:void SeqTriple<T>::Transpose(SeqTriple<T>& B)const{ //将this 转置赋给Bint *num=new int[n]; int *k=new int[n]; //为num和k分配空间B.m=n; B.n=m; B.t=t;if (t>0){for (int i=0; i<n; i++) num[i]=0; //初始化numfor (i=0; i<t; i++) num[trip[i].col]++; //计算numk[0]=0;for(i=1; i<n; i++) k[i]=k[i-1]+num[i-1]; //计算kfor(i=0; i<t; i++){ //扫描this对象的三元组表int j=k[trip[i].col]++; //求this对象的第i项在B中的位置jB.trip[j].row=trip[i].col; //将this对象的第i项转置到B的位置jB.trip[j].col=trip[i].row;B.trip[j].value=trip[i].value;}}delete [] num;delete [] k;}(2)整体赋值思路:先将本类对象所占空间清空,再按赋值对象(即参数对象)规格重新申请空间,最后循环拷贝每个元素。

稀疏矩阵运算器源代码

稀疏矩阵运算器源代码
C.data[k].j=B.data[n].j;
C.data[k].e=B.data[n].e;
k++;
}
if(n>B.tu&&m<=A.tu)
for( ;m<=A.tu;m++)
{C.data[k].i=A.data[m].i;
C.data[k].j=A.data[m].j;
C.data[k].e=A.data[m].e;
if(i==TM.data[k].i&&j==TM.data[k].j)
{cout<<TM.data[k].e<<setw(6);flag=0;}
if(flag) cout<<"0"<<setw(6);
flag=1;
}
cout<<endl;
}
}
//--------------矩阵转置的算法---------------//
//矩阵转置的算法
Status AddTSM(TSMatrix A,TSMatrix B,TSMatrix &C);
//矩阵的加法运算:C=A+B
Status SubTSM(TSMatrix A,TSMatrix B,TSMatrix &C);
//矩阵的减法运算:C=A-B
Status MultSMatrix(TSMatrix A,TSMatrix B,TSMatrix &C);
#include "iomanip.h"
#include "iostream.h"
#include "conio.h"

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");}。

稀疏矩阵快速转置 数据结构实验报告

稀疏矩阵快速转置 数据结构实验报告

稀疏矩阵快速转置数据结构实验报告一、实验目的1、掌握稀疏矩阵的存储方式;2、掌握稀疏矩阵的快速转置算法;3、进一步了解和巩固线性表和链表的相关知识。

二、实验内容1、根据课本内容和参考资料,设计两种不同的存储稀疏矩阵的结构体,并分别实现稀疏矩阵的快速转置操作;2、实现输出稀疏矩阵、打印转置后的稀疏矩阵、以及转置前后两个稀疏矩阵在内存中的存储情况。

三、实验原理1、稀疏矩阵的存储稀疏矩阵指的是矩阵中绝大多数元素为零的矩阵,依据存储方式,目前主要有两种实现方法:顺序表和链表。

(1)顺序表顺序表的存储方式如下:typedef struct{int arr[MAXSIZE]; // 一维数组表示矩阵int rows; // 矩阵共有 rows 行int cols; // 矩阵共有 cols 列int nums; // 矩阵中不为零的元素共有 nums 个}TSMatrix;其中,数组 arr 的长度为 MAXSIZE,每个元素保存矩阵中某个元素的值,且元素的下标按行优先排列,例如,在一个5×5 的矩阵中,a23 可以表示成 a[(2-1)×5+3-1],其中 2-1 代表该元素所在行的下标,3-1 代表该元素所在列的下标。

(2)链表链式存储的特点在于元素之间存在指针联系,节点中保存三元组(row、col、val),其中 row 表示该元素所在的行,col 表示该元素所在的列,val 表示该元素的值,next 指针表示该元素的下一个节点。

2、稀疏矩阵转置稀疏矩阵转置的基本思想是将原矩阵中非零元素的行和列对换。

转置后的矩阵中行和列的值对应变换,对应的非零元素也跟着变化。

1、初始化转置矩阵;2、遍历原矩阵中的元素,将其转置后按行优先的顺序插入转置矩阵;3、输出转置矩阵。

链表转置的步骤如下:四、实验步骤1、根据上述原理,设计 2 种结构体 TSMatrix 和 LinkMatrix,分别完成快速转置算法;2、封装 tranverse_TMatrix 和 tranverse_LinkMatrix 两个函数,并设计测试用例验证结果。

数据结构-稀疏矩阵-实验报告与代码

数据结构-稀疏矩阵-实验报告与代码

一.需求分析输入要求:稀疏矩阵的行、列和非零元素个数输出要求:稀疏矩阵的转置、加法、减法、乘法二.算法设计本程序中采用的数据模型,用到的抽象数据类型的定义,程序的主要算法流程及各模块之间的层次调用关系1.抽象数据类型:ADT List {数据对象:D={ai:|ai∈ElemSet,i=1…n,n≥0}数据关系:R={Row,Col}Row={<ai,j,ai,j>|1<=i<=m,1<=j<=n-1}Col={<ai,j,ai,j>|1<=i<=m-1,1<=j<=n}基本操作:Status CreateSMatrix(TSMatrix &M)操作结果:初始化稀疏数组void PrintSMatrix(TSMatrix M)初始条件:稀疏数组M已经存在操作结果:打印矩阵Mvoid DestroySMatrix(TSMatrix &M)初始条件:稀疏数组M已经存在操作结果:销毁矩阵Mvoid CopySMatrix(TSMatrix M, TSMatrix &T)初始条件:稀疏数组M已经存在操作结果:复制矩阵M到TStatus AddSMatrix(TSMatrix M, TSMatrix N, TSMatrix &Q)初始条件:稀疏数组M、N已经存在操作结果:求矩阵的和Q=M+NStatus SubSMatrix(TSMatrix M, TSMatrix N, TSMatrix &Q)初始条件:稀疏数组M、N已经存在操作结果:求矩阵的差Q=M-NStatus TransposeSMatrix(TSMatrix M, TSMatrix & T)初始条件:稀疏数组M已经存在操作结果:求矩阵M的转置TStatus MultSMatrix(TSMatrix M, TSMatrix N, TSMatrix &Q)初始条件:稀疏数组M已经存在操作结果:求矩阵的积Q=M*N}ADT List2. 本程序有二个模块:(1)主程序模块main(){初始化;{接受命令;显示结果;}}(2)三元组表单元模块:实现矩阵抽象数据类型。

大学数据结构--稀疏矩阵“列序”递增转置算法C文件

大学数据结构--稀疏矩阵“列序”递增转置算法C文件

大学数据结构--稀疏矩阵“列序”递增转置算法C文件#define MAXSIZE 1000 /*非零元素的个数最多为1000*/#define ElementType int/*稀疏矩阵三元组表的类型定义*/typedef struct{int row,col; /*该非零元素的行下标和列下标*/ElementType e; /*该非零元素的值*/}Triple;typedef struct{Triple data[MAXSIZE+1]; /* 非零元素的三元组表。

data[0]未用*/int m,n,len; /*矩阵的行数、列数和非零元素的个数*/}TSMatrix;/*矩阵转置的经典算法*//*"列序"递增转置法*/void TransposeTSMatrix(TSMatrix A,TSMatrix *B) { /*把矩阵A 转置到B所指向的矩阵中去。

矩阵用三元组表表示*/int i,j,k;B->m=A.n;B->n=A.m;B->len=A.len;if(B->len>0){j=1; /*j为辅助计数器,记录转置后的三元组在三元组表B中的下标值*/for(k=1; k<=A.n; k++) /*扫描三元组表A 共k 次,每次寻找列值为k的三元组进行转置*/for(i=1; i<=A.len; i++)if(A.data[i].col==k){B->data[j].row=A.data[i].col;/*从头至尾扫描三元组表A,寻找col值为k的三元组进行转置*/B->data[j].col=A.data[i].row;B->data[j].e=A.data[i].e;j++; /*计数器j自加,指向下一个存放转置后三元组的下标*/}/*内循环中if的结束*/}/* if(B->len>0)的结束*/}/* end of TransposeTSMatrix *//*"按位快速转置"法*/void FastTransposeTSMatrix(TSMatrix A,TSMatrix *B) {/*基于矩阵的三元组表示,采用"按位快速转置"法,将矩阵A转置为矩阵B*/int col,t,p,q;int num[MAXSIZE], position[MAXSIZE];B->len=A.len;B->n=A.m;B->m=A.n;if(B->len){for(col=1;col<=A.n;col++)num[col]=0;for(t=1;t<=A.len;t++)num[A.data[t].col]++; /*计算每一列的非零元素的个数*/position[1]=1;for(col=2;col<=A.n;col++) /*求col列中第一个非零元素在B.data[ ]中的正确位置*/position[col]=position[col-1]+num[col-1];for(p=1;p<=A.len;p++)/*将被转置矩阵的三元组表A从头至尾扫描一次,实现矩阵转置*/{col=A.data[p].col;q=position[col];B->data[q].row=A.data[p].col;B->data[q].col=A.data[p].row;B->data[q].e=A.data[p].e;position[col]++;/* position[col]加1,指向下一个列号为col的非零元素在三元组表B中的下标值*/ }/*end of for*/}}。

数据结构---三元组顺序表------稀疏矩阵的转置和快速转置

数据结构---三元组顺序表------稀疏矩阵的转置和快速转置
scanf("%d",&M.data[i].i);
getchar();
}
printf("输入该非零元的列数:");
scanf("%d",&M.data[i].j);
getchar();
while(M.data[i].j>M.mn||M.data[i].j<1)
{
printf("输入的列数不合法\n请重新输入列数:");
scanf("%d",&M.data[i].e);
getchar();
printf("输入该非零元的行数:");
scanf("%d",&M.data[i].i);
getchar();
while(M.data[i].i>M.mu||M.data[i].i<1)
{
printf("输入的行数不合法\n请重新输入行数:");
scanf("%d",&M.mu);
getchar();
printf("\nmn=");
scanf("%d",&M.mn);
getchar();
printf("\ntu=");
scanf("%d",&M.tu);
getchar();
if(M.tu>maxsize)
{
printf("非零元个数已超过定义的值\n请重新输入tu=");if(M.daa[k].j==i){
T.data[j].e=M.data[k].e;

数据结构课程设计--稀疏矩阵运算器(完整版)实用资料

数据结构课程设计--稀疏矩阵运算器(完整版)实用资料

数据结构课程设计--稀疏矩阵运算器(完整版)实用资料(可以直接使用,可编辑完整版实用资料,欢迎下载)题目:编制一个稀疏矩阵运算器的程序班级:计算机科学与技术四班姓名:奚明学号:41012170源代码://head.h#define MAXSIZE 10000typedef struct//稀疏矩阵的三元组顺序表存储表示{int i,j; //该非零元的行下标和列下标 int e;}Triple;typedef struct{Triple data[MAXSIZE]; //非零元三元组表,data[0]未用 int rpos[MAXSIZE+1]; //各行第一个非零元的位置表 int mu,nu,tu; //矩阵的行数列数和非零元的个数 }RLSMatrix;void CreateSMatrix(RLSMatrix *T);void AddRLSMatrix(RLSMatrix M,RLSMatrix N,RLSMatrix *Q); void SubRLSMatrix(RLSMatrix M,RLSMatrix N,RLSMatrix *Q); intMulTSMatrix(RLSMatrix M,RLSMatrix N,RLSMatrix *Q);void PrintSMatrix(RLSMatrix Q) ; //main.cpp#include <iostream> using namespace std; #include "head.h"void main(){RLSMatrix M,N,Q; int i; do { printf("\t\t***************************\n");printf("\t\t 稀疏矩阵运算器\n"); printf("\t\t***************************\n\n"); printf("\t\t 1.矩阵相加\n\n"); printf("\t\t 2.矩阵相减\n\n"); printf("\t\t 3.矩阵相乘\n\n"); printf("\t\t 4.退出\n\n"); printf("\t\t 请选择: "); scanf("%d",&i); if(i==4) goto end; else } { printf("\n请输入第一个矩阵M:\n"); CreateSMatrix(&M); printf("\n请输入第二个矩阵N:\n"); CreateSMatrix(&N); switch(i) { case 1:AddRLSMatrix(M,N,&Q);break; case 2:SubRLSMatrix(M,N,&Q);break; case 3:MulTSMatrix(M,N,&Q);break; default:break; } } PrintSMatrix(Q); getchar(); getchar(); end: ; }while(i!=4);//xishujuzhen.cpp #include <iostream> using namespace std;#include "head.h"void CreateSMatrix(RLSMatrix *T) //输入创建稀疏矩阵 {}void AddRLSMatrix(RLSMatrix M,RLSMatrix N,RLSMatrix *Q) //稀疏矩阵相加int p,q,k=1; int k; printf(" \n请输入矩阵行数、列数及非零元个数: ");scanf("%d%d%d",&T->mu,&T->nu,&T->tu); printf("\n"); if(T->tu>MAXSIZE||T->mu>21) { } for(k=1;k<=T->tu;k++) { } printf("请输入第%d个非零元素的行数,列数及其值: ",k); scanf("%d%d%d",&T->data[k].i,&T->data[k].j,&T->data[k].e); printf("非零个数超出定义范围!出错!"); exit(0);if(M.mu!=N.mu||M.nu!=N.nu) { } Q->mu=M.mu;Q->nu=M.nu;for(p=1,q=1;p<=M.tu&&q<=N.tu;) { if(M.data[p].i==N.data[q].i){ if(M.data[p].j==N.data[q].j) { } else if(M.data[p].j<N.data[q].j) { Q->data[k].i=M.data[p].i; Q->data[k].j=M.data[p].j; Q->data[k].e=M.data[p].e; Q->data[k].i=M.data[p].i; Q->data[k].j=M.data[p].j; Q->data[k].e=M.data[p].e+N.data[q].e; p++;q++;k++; printf("你的输入不满足矩阵相加的条件!\n"); exit(1);} } k++;p++; else if(M.data[p].j>N.data[q].j) { } Q->data[k].i=N.data[q].i; Q->data[k].j=N.data[q].j; Q->data[k].e=N.data[q].e; k++;p++; elseif(M.data[p].i<N.data[q].i) { } else if(M.data[p].i>N.data[q].i) { Q->data[k].i=N.data[q].i; Q->data[k].j=N.data[q].j; Q->data[k].e=N.data[q].e; Q->data[k].i=M.data[p].i; Q->data[k].j=M.data[p].j; Q->data[k].e=M.data[p].e; k++;p++; k++;q++;}}if(p!=M.tu+1)for(;p<=M.tu;p++){Q->data[k].i=M.data[p].i;Q->data[k].j=M.data[p].j;Q->data[k].e=M.data[p].e;k++;}if(q!=N.tu+1)for(;q<=N.tu;q++){Q->data[k].i=N.data[q].i;Q->data[k].j=N.data[q].j;Q->data[k].e=N.data[q].e;k++;}void SubRLSMatrix(RLSMatrix M,RLSMatrix N,RLSMatrix *Q) 阵相减 //稀疏矩{int p,q,k=1; if(M.mu!=N.mu||M.nu!=N.nu) { } Q->mu=M.mu;Q->nu=M.nu;for(p=1,q=1;p<=M.tu&&q<=N.tu;) { if(M.data[p].i==N.data[q].i){ if(M.data[p].j==N.data[q].j) { } else if(M.data[p].j<N.data[q].j) { Q->data[k].i=M.data[p].i; Q->data[k].i=M.data[p].i; Q->data[k].j=M.data[p].j; Q->data[k].e=M.data[p].e-N.data[q].e; p++;q++;k++; printf("你的输入不满足矩阵相减的条件!\n"); exit(1);} } Q->data[k].j=M.data[p].j; Q->data[k].e=M.data[p].e; k++;p++; elseif(M.data[p].j>N.data[q].j) { } Q->data[k].i=N.data[q].i; Q->data[k].j=N.data[q].j; Q->data[k].e=-N.data[q].e; k++;p++; else if(M.data[p].i<N.data[q].i) { } elseif(M.data[p].i>N.data[q].i) { Q->data[k].i=N.data[q].i; Q->data[k].i=M.data[p].i; Q->data[k].j=M.data[p].j; Q->data[k].e=M.data[p].e; k++;p++;} } Q->data[k].j=N.data[q].j; Q->data[k].e=-N.data[q].e; k++;q++; if(p!=M.tu+1)for(;p<=M.tu;p++) { Q->data[k].i=M.data[p].i; Q->data[k].j=M.data[p].j; Q->data[k].e=M.data[p].e;} } k++; if(q!=N.tu+1) for(;q<=N.tu;q++) { } Q->data[k].i=N.data[q].i; Q->data[k].j=N.data[q].j; Q->data[k].e=-N.data[q].e; k++;int MulTSMatrix(RLSMatrix M,RLSMatrix N,RLSMatrix *Q) //稀疏矩阵相乘{int ccol=0,tp,brow,t,arow,p,q,i; int ctemp[MAXSIZE+1]; if(M.nu!=N.mu) { printf("你的输入不满足矩阵相乘的条件!\n"); return 0; } Q->mu=M.mu; Q->nu=N.nu; Q->tu=0; if(M.tu*N.tu!=0) { for(arow=1;arow<=M.mu;++arow) { for(i=0;i<=N.nu;i++)ctemp[i]=0; Q->rpos[arow]=Q->tu+1; if(arow<M.mu) tp=M.rpos[arow+1]; elsetp=M.tu+1;} for(p=M.rpos[arow];p<tp;++p) { } for(ccol=1;ccol<=Q->nu;++ccol) { }if(ctemp[ccol]) { } if(++Q->tu>MAXSIZE) return 0; Q->data[Q->tu].i=arow; Q->data[Q->tu].j=ccol; Q->data[Q->tu].e=ctemp[ccol]; brow=M.data[p].j; if(brow<N.mu) t=N.rpos[brow+1]; else t=N.tu+1; for(q=N.rpos[brow];q<t;++q) { } ccol=N.data[q].j; ctemp[ccol]+=M.data[p].e*N.data[q].e;} return 1;}void PrintSMatrix(RLSMatrix Q) //输出稀疏矩阵 {int k=1,row,line; printf("\n运算结果: "); if(Q.tu==0) printf("0"); else { for(row=1;row<=Q.mu;row++) { for(line=1;line<=Q.nu;line++){ if(Q.data[k].i==row&&Q.data[k].j==line)printf("%d ",Q.data[k++].e); } } } } printf("\n\t "); else printf("0 ");。

稀疏矩阵的应用

稀疏矩阵的应用
{
ta[ta1->td].p=i;
ta[ta1->td].q=j;
ta[ta1->td].x=a[i][j];
ta1->td++;
}
ta1->md=n;
ta1->nd=m;
}
/*转置*/
void transition (tabletype *ta1, tabletype *tb1, List ta[],List tb[])
4.依次取A中的每一个非零元素对应的三元组;
2.1确定该元素在B中的下标pb;
2.2将该元素的行号列号交换后存入B中pb的位置;
2.3预置该元素所在列的下一个元素的存放位置;
具体要定义如下若干个函数:
void setup()初始化非零元的个数
void transition()转置函数
void input()输入函数
{ for(j=0;j<m;j++)
cout<<a[i][j]<<" ";
cout<<"\n";
}
}
/*三元组顺序表输出*/
void print2(List a[],int nn)
{
int i;
cout<<"\t行号\t列号\t元素值\n";
for(i=0; i<nn;i++)
cout<<" "<<a[i].p<<" "<<a[i].q<<" "<<a[i].x<<" "<<"\n";

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

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

实验四、稀疏矩阵三元组下转置一、实验内容将稀疏矩阵中的每个非零元素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;}四、调试和运行结果在完成算法的程序实现后,用任意的一组数据来加以测试运行,对运行结果加以分析,检查运行结果是否正确。

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. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
#include<stdio.h>
#define MAXSIZE 100 /* 非零元个数的最大值 */
typedef struct triple
{
int i,j; /* 行下标,列下标 */
int e; /* 非零元素值 */
}triple;
typedef struct tsmatrix
/* 对cpos对初始化,初值为0 */
*(cpos+1)=0;
for(i=1;i<=M.nu;i++)
{
for(m=1;m<=M.tu;m++)
{
if(M.data[m].j==i)
k++;
}
temp[i]=k;
if(i==1&&k!=0)
*(cpos+i)=1;/* 为cpos赋值 */
printf(" \1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1谢谢使用!\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\n\n");
getch();
}
printf(" ** ** \n");
printf(" ** 稀疏矩阵运算器 ** \n");
{printf("行或列超出范围");getch();exit();}
if(m<M->data[i-1].i||m==M->data[i-1].i&&n<=M->data[i-1].j) /*行或列的顺序有错*/
{printf("行或列的顺序有错");getch();exit();}
M->data[i].i=m;
M->data[i].j=n;
M->data[i].e=e;
}
}
void transposesmatrix(rlsmatrix M,rlsmatrix *T)
{ /* cpos存放每列的第一个非零元素的地址,temp中间变量 */
int i,m,*cpos,*temp,k=0;
printf("\2 输入数字时请用逗号隔开!\n\n");
printf(" ->");
scanf("%c",&ch);
while(ch!='N'){//进行循环运算
switch(ch){//进行运算选择
case'A':{printf("请输入要转置的矩阵:\n\n");
printf(" ** --------------------- ** \n");
printf(" *************************** \n");
printf(" ->);
ch=getchar();
}break;
default:printf("->");ch=getchar();break;
}
}
printf(" 运算结束!\n\n");
for(i=1;i<=M->tu;i++)
{
printf("请按行序顺序输入第%d个非零元素所在的行(1~%d),列(1~%d),元素值:",i,M->mu,M->nu);
scanf("%d",&m);scanf("%d",&n);scanf("%d",&e);
if(m<1||m>M->mu||n<1||n>M->nu) /*行或列超出范围 */
PrintRLSMatrix(Q);
printf("是否继续运算(Y/N)?\n\n");
printf(" ->");
ch=getchar();
}break;
case'Y':{printf("请选择运算\n");
printf(" | A.转置 Y.继续运算 N.结束运算 | \n");
printf(" |_____________________________________________________________________| \n\n");
T->mu=M.nu;
T->nu=M.mu;
T->tu=M.tu;
cpos=(int *)malloc(M.mu*sizeof(int));
if(cpos==NULL)exit();
temp=(int *)malloc(M.mu*sizeof(int));
if(temp==NULL)exit();
ScanRLSMatrix(&M);
printf(" 输入的要转置的矩阵为:\n\n");
PrintRLSMatrix(M);
FasttransposeRLSMatrix(M,&Q);
printf("转置矩阵为:\n\n");
printf(" _____________________________________________________________________ \n");
printf(" | 请选择 | \n");
T->data[*(cpos+M.data[i].j)].e=M.data[i].e;
(*(cpos+M.data[i].j))++;}
free(cpos);
}
main()
{
RLSMatrix M,N,Q;
char ch;
printf(" *************************** \n");
{ /* 创建稀疏矩阵M */
int e,i,m,n;
M->data[0].i=0; /* 为以下比较顺序做准备 */
printf("请输入矩阵的行数,列数,和非零元素的个数:");
scanf("%d",&M->mu);scanf("%d",&M->nu);scanf("%d",&M->tu);
{
triple data[MAXSIZE+1]; /* 非零元三元组表,data[0]未用 */
int mu,nu,tu; /* 矩阵的行数、列数和非零元个数 */
/* 各列第一个非零元的位置表rpos[0]未用 */
}rlsmatrix;
createsmatrix(rlsmatrix *M)
if(i>1)
*(cpos+i)=*(temp+i-1)+1;
}
free(temp);
for(i=1;i<=M.tu;i++)/* 进行转置 */
{T->data[*(cpos+M.data[i].j)].i=M.data[i].j;
T->data[*(cpos+M.data[i].j)].j=M.data[i].i;
相关文档
最新文档