C语言数据结构——矩阵的加减乘除

#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输出函数

//******************** 主函数 ***********************//
int 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;
}