稀疏矩阵程序代码.doc

#include<stdio.h>
#include<iostream.h>
#include<stdlib.h>
#include<conio.h>
#include<malloc.h>
#define MAXSIZE 100 /*假设非零元个数的最大值为100*/
typedef struct
{int i,j; /*该非零元的行下标和列下标*/
int v;
}Triple;
typedef struct
{Triple data[MAXSIZE+1]; /*非零元三元组表,data[0]未用*/
int mu,nu,tu; /*矩阵的行数,列数和非零元个数*/
}TSMastrix;

//********************** 声明函数 **********************//

void creat(TSMastrix &T);/*创建三元组*/
void add(TSMastrix A,TSMastrix B);/*加法运算*/
void sub(TSMastrix A,TSMastrix B);/*减法运算*/
void mult(TSMastrix A,TSMastrix B);/* 乘法运算*/
void print(TSMastrix A);/*输出计算结果*/
char menu();//菜单
void display (TSMastrix M);//s输出函数

//******************** 主函数 ***********************//
void main()
{
TSMastrix A,B;
creat(A);
creat(B);
printf("*************** 创 建 矩 阵 ********************\n");

for(;;)
switch(menu())
{
case '0':
printf("*****************输 出 矩 阵 A*************************\n");
display(A);
printf("*****************输 出 矩 阵 B*************************\n");
display(B);
getchar();
break;
case '1':
add(A,B);
getch();
break;
case '2':
sub(A,B);
getch();
break;
case '3':
mult(A,B);
getch();
break;
case '4':
creat(A);
creat(B);
getch();
break;
case '5':
system("cls");
exit(0);
}
}

//********************* 子 函 数 ****** *****************//

//******** 创建三元组存储矩阵数据 ********//

void creat(TSMastrix &T)
{
int k,i,j;
printf("\n 请输入矩阵\n");
do
{
printf("\n请输入矩阵的行数，列数，非零元素个数\n");
scanf("%d%d%d",&T.mu,&T.nu,&T.tu);
if((T.mu<0||T.mu>20)||(T.nu<0||T.nu>20)||((T.tu>T.mu*T.nu)||T.tu>MAXSIZE))
printf("\n 超出行列定义范围，请重新输入!!\n");
}
while((T.mu<0||T.mu>20)||(T.nu<0||T.nu>20)||((T.tu>T.mu*T.nu)||T.tu>MAXSIZE));
printf("*********************************************************\n");
for(k=1;k<=T.tu;k++)
{
do
{
printf("\n请输入非零元素的行数i，列数j，数值v\n");
scanf("%d%d%d",&T.data[k].i,&T.data[k].j,&T.data[k].v);
if((T.data[k].i<0||T.data[k].i>T.mu)||(T.data[k].j<0||T.data[k].j>T.nu)||(T.data[k].v==0))
printf("\n 超出行列定义范围，请重新输入!\n");
}
while((T.data[k].i<0||T.data[k].i>T.mu)||(T.data[k].j<0||T.data[k].j>T.nu)||(T.data[k].v==0));
printf("*********************************************************\n");
}
return;
}

//********* 输出矩阵函数 ********//

void display( TSMastrix M)
{
int q,n,k,a=0;
printf("------------------------------------------------------------\n");
printf("------------------------------------------------------------\n");
for(n=1;n<=M.mu;n++)
{
for(k=1;k<=M.nu;k++)
{
for(q=1;q<=M.tu;q++)
{
if(M.data[q].i==n&&M.data[q].j==k)
{
printf("\t%-3d",M.data[q].v);
break;
}
}
if(q>M.tu)printf("\t%-3d",a);

}
printf("\n");

}

printf("------------------------------------------------------------\n");
printf("------------------------------------------------------------\n");
printf("\n");
}

//******** 加法运算 **********//
void add(TSMastrix A,TSMastrix B)
{
int n,k;
if(A.mu!=B.mu||A.nu!=B.nu)
{ printf("\n 不满足两个矩阵相加条件!");
printf("\n 需要满足两矩阵的行数、列数均各自相等方可经行减法运算！！");
}
else {for(n=1;n<=A.tu;n++)
for(k=1;k<=B.tu;k++) /*将矩阵T的非零元接至M中*/
{if(A.data[n].i==B.data[k].i&&A.data[n].j==B.data[k].j)
{A.data[n].v+=B.data[k].v;
B.data[k].v=0;}
}
for(k=1;k<=B.tu;k++)
if(B.data[k].v!=0)
{A.data[A.tu+1].i=B.data[k].i;
A.data[A.tu+1].j=B.data[k].j;
A.data[A.tu+1].v=B.data[k].v;
A.tu++;
}
print(A);
}
}
//******* 减法运算 *********//

void sub(TSMastrix A,TSMastrix B)
{int n,k;
if(A.mu!=B.mu||A.nu!=B.nu)
{ printf("\n 不满足两个矩阵相减条件!");
printf("\n 需要满足两矩阵的行数、列数均各自相等方可经行减法运算！！");
}
else{
for(n=1;n<=A.tu;n++)
for(k=1;k<=B.tu;k++) /*将矩阵T的非零元接至M中*/
{
if(A.data[n].i==B.data[k].i&&A.data[n].j==B.data[k].j)
{A.data[n].v-=B.data[k].v;
B.data[k].v=0;}
}
for(k=1;k<=B.tu;k++)
if(B.data[k].v!=0)
{A.data[A.tu+1].i=B.data[k].i;
A.data[A.tu+1].j=B.data[k].j;
A.data[A.tu+1].v=-B.data[k].v;
A.tu++;}
print(A);
}
}

//****** 乘法运算 *******//

void mult(TSMastrix A,TSMastrix B)
{int z,n1,k1,n2,k2,s,sum,count=0;
TSMastrix Z;
int b1[100][100],b2[100][100],b3[100][100];
if(A.nu!=B.mu)printf("矩阵的行数与列数不像等，不能进行相乘运算！");
else{
Z.mu=A.mu;
Z.nu=B.nu;
for(n1=1;n1<=A.mu;n1++) /*初始化为零*/
for(k1=1;k1<=A.nu;k1++){b1[n1][k1]=0;}
for(n1=1;n1<=A.mu;n1++)
for(k1=1;k1<=A.nu;k1++){b2[n1][k1]=0;}
for(n1=1;n1<=A.tu;n1++) /*装载三元组数据*/
{b1[A.data[n1].i][A.data[n1].j]=A.data[n1].v;}
for(n1=1;n1<=B.tu;n1++)
{b2[B.data[n1].i][B.data[n1].j]=B.data[n1].v;}

for(n1=1;n1<=Z.mu;n1++)
{ for(k2=1;k2<=Z.nu;k2++)
{
sum=0;
for(k1=1;k1<=Z.nu;k1++)
{
sum+=b1[n1][k1]*b2[k1][k2];
}
if(sum!=0)
{count++;
Z.data[count].i=n1;
Z.data[count].j=k2;
Z.data[count].v=sum;
Z.tu=count;
}
}
}
print(Z);
}
}
//****** 输出计算结果 ********//

void print(TSMastrix A)
{int q,n,k,a=0;
system("cls");
printf("\n\n经过稀疏矩阵运算器运算，所得结果为：\n");
printf("------------------------------------------------------------\n");
printf("------------------------------------------------------------\n");
for(n=1;n<=A.mu;n++)
{
for(k=1;k<=A.nu;k++)
{
for(q=1;q<=A.tu;q++)
{if(A.data[q].i==n&&A.data[q].j==k){printf("\t%-3d",A.data[q].v);break;}
}
if(q>A.tu)printf("\t%-3d",a);
}
printf("\n");
}
printf("------------------------------------------------------------\n");
printf("------------------------------------------------------------\n");
}
//*********** 菜单 *********//

char menu()
{
char n;
printf(" \n");
printf(" 稀疏矩阵运算器 \n");
printf("******************************************************************\n");
printf("* 0: 输出矩阵 *\n");
printf("* 1:两个矩阵相加 *\n");
printf("* 2:两个矩阵相減 *\n");
printf("* 3:两个矩阵相乘 *\n");
printf("* 4:重新创建矩阵 *\n");
printf("* 5:成功安全退出 *\n");
printf("********************************************************************************\n");
printf("\n\n\n 请选择你需要的操作: ");
n=getchar();
return n;
}