c语言稀疏矩阵相乘函数 稀疏矩阵输出函数

C语言编写稀疏矩阵的加，减，乘和转置，要求用矩阵输出

#include stdio.h

#include iostream

#include math.h

#include stdlib.h

using namespace std;

#define Max 12500

#define Elemtype int

typedef struct {

int i ,j ;

Elemtype e;

}Triple;

typedef struct {

Triple data[Max+1];

int mu,nu,tu;

}Tsmatrix;

int Createsmatrix(Tsmatrix M)

{ int n;

cout"请输入稀疏矩阵的元素个数n"endl;

cinn;

M.tu=n;

cout"请输入稀疏矩阵的行数，列数："endl;

cinM.muM.nu;

int i;

for(i=1;i=n;i++){

cout"请输入稀疏矩阵的行下标和列下标，及数据;"endl;

cinM.data[i].iM.data[i].jM.data[i].e ;

}

return 1;

}

int Transpose(Tsmatrix M , Tsmatrix T)

{

T.mu=M.nu; T.nu=M.mu ; T.tu=M.tu;

if(T.tu){

int col , p , 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;

}

int Print(Tsmatrix M)

{

int i;int p=1;

{

for (i=1;i=M.mu*M.nu;i++)

if(i==((M.data[p].i-1)*M.nu+M.data[p].j))

{

if(M.data[p].j==M.nu)

{ coutM.data[p].eendl; p++;}

else

{ coutM.data[p].e" "; p++;}

}

else if(i%M.nu==0) cout"0"endl;

else cout"0 ";

}

cout"\n"endl;

return 1;

}

int Addsmatrix(Tsmatrix a, Tsmatrix b, Tsmatrix c)

{

int s=1,t=1,k=1; Elemtype temp;

if(a.mu!=b.mu||a.nu!=b.nu) return 0;

if(a.tu == 0) {c=b; return 1;}

if(b.tu==0) {c=a; return 1;}

if(a.tu==0 b.tu==0) { c=a; return 1;}

while(!(sa.tu tb.tu))

{

if(a.data[s].ib.data[t].i)

{

c.data[k]=b.data[t];

k++ ;t++;

}

if(a.data[s].ib.data[t].i)

{

c.data[k]=a.data[s];

k++ ;s++;

}

if(a.data[s].i==b.data[t].i)

{

if(a.data[s].jb.data[t].j)

{

c.data[k]=b.data[t];

k++; t++;

}

if(a.data[s].jb.data[t].j)

{

c.data[k]=a.data[s];

k++; s++;

}

if(a.data[s].j==b.data[t].j)

{

temp=a.data[s].e+b.data[t].e;

if(temp==0){s++;t++;}

else

{ c.data[k].e=temp;c.data[k].i=a.data[s].i;c.data[k].j=a.data[s].j;

s++;t++;k++;

}

}

}//if

if(sa.tut=b.tu)

{

while(t=b.tu)

{

c.data[k]=b.data[t];

k++; t++;

}

}

if(tb.tus=a.tu)

{

while(s=a.tu)

{

c.data[k]=a.data[s];

k++; s++;

}

}

}//while

c.tu=k-1; c.mu=a.mu; c.nu=a.nu;

}

return 1;int main()

{

Tsmatrix a,b,c;

Createsmatrix( a);

Createsmatrix( b);

Print(a);

Print(b);

Addsmatrix(a,b,c);

Print(c);

return 1;

}

用c语言实现两个矩阵相乘怎么做？

1、程序运行输入数据时，第一行为A矩阵的行列数和B矩阵的行列数，接着分别输入A、B两个矩阵的值。

2、首先，定义6个整型变量，保存A、B矩阵的行和列，以及控制循环的变量，k则用于实现矩阵的乘法。

3、接着，定义三个整型二维数组，保存A、B和C矩阵的各元素。

4、输入三个矩阵的行数和列数，保存在变量a、b、c中。

5、输入矩阵A的各元素，保存在数组X中。

6、输入矩阵B的各元素，保存在数组Y中。

7、将二维数组Z的各元素，初始化为0。

8、用两层for循环，控制矩阵的乘法，并输出乘法所得的结果。

9、计算A矩阵和B矩阵的乘法，结果保存在数组Z中。

10、最后，输出乘法所得的结果，即输出Z数组中的所有元素。

11、运行程序，输入矩阵A和B的行数和列数，以及A矩阵和B矩阵的所有元素，电脑就会计算出乘积C矩阵的所有元素，并输出C矩阵。

用C语言实现稀疏矩阵的快速转置和乘法。能够在TC2.0运行的求各位大侠帮忙

#includestdio.h

#includestdlib.h

#includeconio.h

struct S{ int i;

int j;

int v;

struct S *next;

};

struct S *B,*p,*q;

main()

{ int k,a,b,c,m,n;

c=m=n=0;

clrscr();

printf("-----------欢迎使用!-------------\n\n");

p=(struct S *)malloc(sizeof(struct S)); /*申请存储空间*/

p-next=NULL;

B=p;

while(1)

{

printf("\n请输入矩阵元素所在行:");

scanf("%d",p-i);

printf("\n请输入矩阵元素所在列:");

scanf("%d",p-j);

printf("\n请输入矩阵元素值:");

scanf("%d",p-v);

printf("\n是否继续输入c语言稀疏矩阵相乘函数？(Y/N)");

if(getchar()=='N'||getchar()=='n') break;

q=(struct S *)malloc(sizeof(struct S)); /*申请存储空间*/

q-next=NULL;

p-next=q;

p=q;

}

printf("\nthe B is:\n");

q=B;

while(q-next!=NULL)

{ printf("%5d%5d%5d\n",q-i,q-j,q-v);

q=q-next;

}

getch();

}

稀疏矩阵的乘法的算法思想

/*Multiplicate part*/

//C = A * B

/*算法分析：

首先，由于楼主没有给出输入函数，也没有对三元组的稀疏矩阵的数据结构做完整的说明，

所以我只能猜测这个稀疏矩阵是以行为主序存储的。（后面的乘法函数佐证了我的猜测，

但是如果我不幸猜错了，还请楼主告知）

另一个猜测是楼主的程序中设定矩阵和数组的下标都是从1开始，而非从0开始。

接下来，我们说一下普通矩阵的乘法，这个在线性代数里面有定义，无需赘言。

我要说的是稀疏矩阵的乘法也是用这个公式来计算，但却有一个问题——效率。

我们举一个例子来说明：

假设我们已知A:m*n和B:n*l,要计算C:m*l，那么C(i,j)的计算公式就是：

C(i,j) = A(i,1)*B(1,j) + A(i,2)*B(2,j) + …… + A(i,n)*B(n,j) 公式1

如果A、B都是普通矩阵（并且以二维数组存储），那么直接用循环语句就可以完成。

如果A、B都是稀疏矩阵（并且乱序存储，即是说没有以行序或列序存储），那么计算就会很麻烦。

我们需要首先遍历整个A矩阵去查找是否存在A(i,1)（若有则取其值，若无则其值为0），然后再去

遍历B矩阵查找B(1,j)，并将两者相乘；接着又是A(i,2)和B(2,j)，以此类推。

这样做当然是可行的，但是显然效率太低了，一种改进的方法（就是楼主的程序中所用的方法）如下：

首先我们要优化稀疏矩阵的存储，不能乱序存储，而是以行序或列序为主序来存储，

比如这里我们以行序为主序，以列序为次序。

具体来说，就是将稀疏矩阵的第一行中的非零元素排列在前面，然后才是第二行、第三行……

在各行的非零元素中又以列序来排列，这样存储的稀疏矩阵就是有序的。

接下来，在真正用公式来计算之前，我们要做一个预处理。

这个预处理是对矩阵B所做的，其实就是要计算得到矩阵B所对应的pos数组。

那么这个pos数组代表什么意思呢？

我们从代码中不难看出pos数组的长度是矩阵B的行数（也就是B-m）加1。

pos[i]（1 = i= B-m）表示矩阵B的第i行的第一个非零元素在三元数组B的位置。

pos[i]（i == B-m + 1）是为了方便后面的计算而增加一个标记，类似于监视哨。

有了这个pos数组之后，我们再来计算公式1就可以提高效率了。

效率的提高表现在两个方面：

1、我们看到代码中（如下）虽然有两层while循环，但是其实总共只执行了A-t次。

p=1;

while(p=A-t)

{

……

while (p=A-tA-data[p].row==crow)

{

……

p=p+1;

}

……

}

2、在第二层while循环中的for循环，由于pos数组的作用使得循环次数减少很多。

for(q=pos[brow];q=pos[brow+1]-1;q++)

{

ccol=B-data[q].col;

ctemp[ccol]=ctemp[ccol] + A-data[p].v * B-data[q].v;

}

好了，以上就是这个稀疏矩阵乘法的大致过程，如有错误请指正。

*/

void MultS(TriTable *A,TriTable *B,TriTable *C)

{

int k,p,q,brow,crow,ccol;

int num[MAXSIZE],pos[MAXSIZE],ctemp[MAXSIZE];

if (A-n==B-m)

{

for(k=1;k=B-m;k++)

num[k]=0;

for(k=1;k=B-t;k++)

num[B-data[k].row]++;

pos[1]=1;

for(k=2;k=B-m;k++) //这里将k=B-t改为k=B-m

pos[k]=pos[k-1]+num[k-1];

pos[1+B-m]=pos[B-m]+1; //这里将k=B-t改为k=B-m

C-m=A-m;

C-n=B-n;

C-t=0;

p=1;

while(p=A-t)

{

crow=A-data[p].row;

for(k=1;k=C-n;k++)

ctemp[k]=0;

while (p=A-tA-data[p].row==crow)

{

brow=A-data[p].col;

for(q=pos[brow];q=pos[brow+1]-1;q++)

{

ccol=B-data[q].col;

ctemp[ccol]=ctemp[ccol] + A-data[p].v * B-data[q].v;

}

p=p+1;

}

for(ccol=1;ccol=B-n;ccol++)

if(ctemp[ccol]!=0)

{

C-t=C-t+1;

C-data[C-t].row=crow;

C-data[C-t].col=ccol;

C-data[C-t].v=ctemp[ccol];

}

}

}else

printf("these two arrat can't Multiplicate");

return;

}

用邻接表表示稀疏矩阵并实现矩阵的加法减法乘法运算!求C语言代码啊！

# include stdio.h

typedef struct a

{

int **arc;

int vexnum;

}table;

void createbiao(table *a)//建立邻接表

void tableplus(table *a,table *b)

{

int i,j

if(a-vexnum!=b-vexnum)

{printf("不能做加法!\n");exit(0);}

for(i=0;ia-vexnum;i++)

for(j=0;ja-vexnum;j++)

a-arc[i][j]+=b-arc[i][j];

}

void tablejian(table *a,table *b)

{

int i,j

if(a-vexnum!=b-vexnum)

{printf("不能做减法!\n");exit(0);}

for(i=0;ia-vexnum;i++)

for(j=0;ja-vexnum;j++)

a-arc[i][j]-=b-arc[i][j];

}

void tableplus(table *a,table *b)

{

int i,j,k,usum=0;

if(a-vexnum!=b-vexnum)

{printf("不能做乘法!\n");exit(0);}

for(i=0;ia-vexnum;i++)

{

for(k=0;ka-vexnum;k++)

{

sum=0

for(j=0;ja-vexnum;j++)

sum=arc-arc[i][j]*b-arc[j][k];

a-arc[i][k]=sum;

}

}

}

有问题追问,写写不容易

数据结构（C语言版）稀疏矩阵相乘程序 不能得出相乘的结果 拜托帮帮我！！

给c语言稀疏矩阵相乘函数你 另一个c语言稀疏矩阵相乘函数我自己写的 矩阵相乘的算法 c语言稀疏矩阵相乘函数你可以借鉴一下 用c语言的话 就要改一些细节地方 我是用 C++

void xiangcheng()

{ char ch;

int m,n,m1,n1;

float a[100][100],b[100][100],sum=0;

int i=0,k,flag=1,t,p;

system("cls");

printf("请输入第一个矩阵的行数m与列数n:\n\n");

printf("行数m==");

scanf("%d",m);

if(m==0)

return;

printf("列数n==");

scanf("%d",n);

if(n==0)

return;

printf("请输入第一个矩阵的数字:\n\n");

for(i=0;im;i++)

for(k=0;kn;k++)

{scanf("%f",a[i][k]);

}

while(flag)

{

system("cls");

printf("\n\n您输入第一个矩阵的行数m==%d与列数n==%d:\n\n",m,n);

printf("请输入第二个矩阵的行数m1与列数n1 注意行数 m1 与前一个矩阵的 列数 n 必须向等:\n\n");

printf("行数m1==");

scanf("%d",m1);

printf("列数n1==");

scanf("%d",n1);

if(n==m1)

break;

else if(n!=m1)

{ system("cls");

printf("你的输入有误!!!! 前一个矩阵的列（n） 与 第二个矩阵的行（m1） 必须相等\n");

printf("\n是否要再次输入(Y or N)\n");

getchar();

scanf("%c",ch);

if(ch=='Y'||ch=='y')

flag++;

else flag=0;

}

}

if(flag)

{

printf("请输入第二个矩阵的数字 :\n\n");

for(i=0;im1;i++)

for(k=0;kn1;k++)

scanf("%f",b[i][k]);

}

for(i=0;im;i++)

{ for(t=0;tn1;t++)

{for(k=0,p=0;pm1;p++,k++)

sum=sum+a[i][k]*b[p][t];

printf(" %f ",sum);

sum=0;

}

printf("\n\n");

}

printf("\n\n 请按ENTER键返回: \n");

getchar();

getchar();

return;

}

关于c语言稀疏矩阵相乘函数和稀疏矩阵输出函数的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。