test.cpp

矩阵运算器

#include "stdio.h"
#include "stdlib.h"
#include<iostream> 
#include<windows.h> 
#include<conio.h>
#define   OK        1
#define   ERROR     0
#define   MAXSIZE   20    /*非零元个数*/
#define   MAXRC     20
#define   MAXR      20
#define   MAXC      20
typedef   struct{
    int i,j;              /*非零元行下标和列下标*/
    int e;
} Triple ; 
typedef   struct{
    Triple   data[MAXSIZE+1];  /*非零元三元组，data[0]未用*/
    int      rpos[MAXRC+1];    /*各行第一非零元的位置表*/
    int      mu,nu,tu;          /*矩阵的行数，列数，非零元数*/
} RLSMatrix  ;
void Print(RLSMatrix  *A,RLSMatrix  *B,RLSMatrix *T);
//特殊用法实现光标移动
void gotoxy(int x, int y) { 
COORD c; 
c.X = x - 1; 
c.Y = y - 1; 
SetConsoleCursorPosition (GetStdHandle(STD_OUTPUT_HANDLE), c); 
} 
//特殊用法实现光标移动
void ADD(RLSMatrix  *A,RLSMatrix  *B,RLSMatrix *T)      /*加法*/
{
       int x=1;//A中非零元素的位置
       int y=1;//B中非零元素的位置
       int z=1;//T中非零元素的位置
       
       T->tu=0;
       T->mu=A->mu;//行数
       T->nu=A->nu;//列数
       
       while(x<=A->tu)
       {
       //一，如果A中元素的行号小于B中对应元素的行号，则将A中此元素的行号，列号及值付给T中对应元素   
           if(A->data[x].i<B->data[y].i)
           {
                T->data[z].i=A->data[x].i;
                T->data[z].j=A->data[x].j;
                T->data[z].e=A->data[x].e;
                x++;z++;//同时将A和T中指向非零元素的指针加一
           }
       //二，如果A中元素的行号等于B中对应元素的行号，则分为以下几种元素
          else if(A->data[x].i==B->data[y].i)
          {
		//二.1如果A中元素的列号大于B中对应元素的列号，则将B中对应元素信息付给T中对应元素
             if(A->data[x].j>B->data[y].j)
             {
                T->data[z].i=B->data[y].i;
                T->data[z].j=B->data[y].j;
                T->data[z].e=B->data[y].e;
                y++;z++;//同时将B和T中指向非零元素的指针加一
             }
		//二.2如果A中元素的矩阵位置和B的相同则分为以下情况
             else if(A->data[x].j==B->data[y].j)
			 {
		//二.2.1如果如果两元素相加结果不等于零
              if((T->data[z].e=A->data[x].e+B->data[y].e)!=0)
				{
					T->data[z].i=A->data[x].i;
					T->data[z].j=A->data[x].j;
					x++;
					y++;//则指向各矩阵非零元素的指针都加一
					z++;
				}
		//二.2.2如果结果等于零
				else
				{
					x++;//则光AB的指针加一，T的指针不变
					y++;
					}
			 }
		//二.2.3如果A中对应元素的列号小于B中对应元素的列号，则将A的值付给T中的对应元素
             else if(A->data[x].j<B->data[y].j)
             {
                T->data[z].i=A->data[x].i;
                T->data[z].j=A->data[x].j;
                T->data[z].e=A->data[x].e;
                x++;z++;//并且将AT的指针加一
             }
         }
		//三如果A中元素的行号大于B中元素的行号时，将B付给T
          else if(A->data[x].i>B->data[y].i)
          {
                T->data[z].i=B->data[y].i;
                T->data[z].j=B->data[y].j;
                T->data[z].e=B->data[y].e;
                y++;z++;//并且BT的指针均加一
           }
		//如果B被指到最后一个元素时跳出这个while语句继续执行
       if(y>B->tu)//原来的">="被改为“>”
           break;
       }//while(x<)
	  //如果A的还没被指到最后一个元素则将A的剩下的元素付给T
       if(x<=A->tu){
            while(x<=A->tu){
                T->data[z].i=A->data[x].i;
                T->data[z].j=A->data[x].j;
                T->data[z].e=A->data[x].e;
                x++;z++;  
            }
       }
	   //如果是A先指到最后的元素B没有指到最后的元素，则将B的剩余元素付给T
       if(y<=B->tu){
            while(y<=B->tu){  
                T->data[z].i=B->data[y].i;
                T->data[z].j=B->data[y].j;
                T->data[z].e=B->data[y].e;
                y++;z++;  
            }
       }
   
   T->tu=z;
   Print(A,B,T);
}
void SUB(RLSMatrix  *A,RLSMatrix  *B,RLSMatrix *T)     /*减法*/
{
       int x=1;
       int y=1;
       int z=1;
       T->tu=0;
       T->mu=A->mu;
       T->nu=A->nu;
       while(x<=A->tu)
       {
		//如果A的行号小于B的行号直接将A赋予T
           if(A->data[x].i<B->data[y].i)
           {
                T->data[z].i=A->data[x].i;
                T->data[z].j=A->data[x].j;
                T->data[z].e=A->data[x].e;
                x++;z++;
           }
       //当行号相等的时候
          else if(A->data[x].i==B->data[y].i)
          {
			  //A的列号大于B的列号将B的值赋予T
             if(A->data[x].j>B->data[y].j)
             {
                T->data[z].i=B->data[y].i;
                T->data[z].j=B->data[y].j;
                T->data[z].e=0-B->data[y].e;
                y++;z++;
             }
			 //当矩阵位置相同的时候A-B
             else if(A->data[x].j==B->data[y].j)
			 {
				 //A-B不等于零赋予T
                 if((T->data[z].e=A->data[x].e-B->data[y].e)!=0)
				 {
					T->data[z].i=A->data[x].i;
					T->data[z].j=A->data[x].j;
					x++;
					y++;
					z++;
				 }
				 //A-B等于零时AB指针下移，T不变
			      else
				  { 
					x++;
					 y++;
				  }
			 }  
			 //A的列号小于B的列号将A的值付给T
             else if(A->data[x].j<B->data[y].j)
             {
                T->data[z].i=A->data[x].i;
                T->data[z].j=A->data[x].j;
                T->data[z].e=A->data[x].e;
                x++;z++;
            }
         }
		//A的行号大于B的行号时，将B的值付给T
         else if(A->data[x].i>B->data[y].i)
         {
                T->data[z].i=B->data[y].i;
                T->data[z].j=B->data[y].j;
                T->data[z].e=0-B->data[y].e;
                y++;z++;
         }
        if(y>B->tu)//如果B到了做后跳出while的循环
       break;
       }
      
       if(x<=A->tu)
       {
            while(x<=A->tu)
            {
                T->data[z].i=A->data[x].i;
                T->data[z].j=A->data[x].j;
                T->data[z].e=A->data[x].e;
                x++;z++;  
            }
       }
       if(y<=B->tu)
       {
            while(y<=B->tu){  
                T->data[z].i=B->data[y].i;
                T->data[z].j=B->data[y].j;
                T->data[z].e=0-B->data[y].e;
                y++;z++;  
                           }
       }
   
   T->tu=z;
   Print(A,B,T);
}
int MUL(RLSMatrix  *A,RLSMatrix  *B,RLSMatrix *T)   /*乘法*/
{
    int arow,ccol,tp,p,q,blow,t,i;
    int ctemp[MAXRC];
	//如果A的列号不等于B的行号直接退出
    if(A->nu!=B->mu) return ERROR;
    T->mu=A->mu;T->nu=B->nu;T->tu=0;
    if(A->tu*B->tu!=0)//如果没有空的矩阵
    {
      for(arow=1;arow<=A->mu;++arow)
      {
        for(i=1;i<=T->nu;i++)
           ctemp[i]=0;
        T->rpos[arow]=T->tu+1;
        if(arow<A->mu) tp=A->rpos[arow+1];//tp等于A中下一行第一个非零元素的位置
        else{tp=A->tu+1;}
        for(p=A->rpos[arow];p<tp;++p)
        {
          blow=A->data[p].j;//blow为A中对应元素的列号
          if(blow<B->mu)
           t=B->rpos[blow+1];//t等于B中下一行第一个非零元素的位置
          else
           t=B->tu+1;
		  for(q=B->rpos[blow];q<t;++q)
			{
			ccol=B->data[q].j;
			ctemp[ccol] += A->data[p].e*B->data[q].e;
			}  /*for q*/
        }  /*求得Q中的crow( arow)行的非零元*/
        for(ccol=1;ccol<=T->nu;++ccol)
        {
          if(ctemp[ccol])
          {
            if(++T->tu>MAXSIZE) return ERROR;
            T->data[T->tu].i=arow;
            T->data[T->tu].j=ccol;
            T->data[T->tu].e=ctemp[ccol];
          }//if
        }//for(ccol)
      }//for(arow)
    }//if
    Print(A,B,T);
    return OK;
}
void Printt(RLSMatrix  *A)     /*打印矩阵*/
{
   int row,col,i=1,k=0;
   for(row=1;row<=A->mu;row++)
    {
     for(col=1;col<=A->nu;col++)
       {
		 //如果A的第i个元素的行号等于循环行号，并且列号等于循环列号，并且在A的非零元素个数内
         if(A->data[i].i==row&&A->data[i].j==col&&i<=A->tu)
         printf("%-4d",A->data[i++].e);//占4个位置左对齐，先将i的值付出，再将i加一
         else  printf("%-4d",k);
       }
       printf("\n");
     }
}
void Print(RLSMatrix  *A,RLSMatrix  *B,RLSMatrix *T)    /*打印函数*/
{
   system("cls"); 
   if(A->tu!=0) {printf("Print Matrix A:\n");Printt(A); printf("\n");}
   else  printf("Matrix A is blank!\n");
   if(B->tu!=0) {printf("Print Matrix B:\n");Printt(B); printf("\n");}
   else  printf("Matrix B is blank!\n");
   if(T->tu!=0) {printf("Print Matrix T:\n");Printt(T); printf("\n");}
   else {printf("Matrix T is blank!\n");getch();}//为空的时候的取符号
   getch();//不空的时候的取符号
}
void Enter(RLSMatrix  *A,RLSMatrix  *B,RLSMatrix *T)      /*输入函数*/
{
    int i,num[MAXRC];
    char cmd;
	//刷屏一下先
    system("cls"); 
    printf("Enter the mu and nu and tu of Matrix A(mu,nu,tu): \n");  /*输入矩阵A*/
    scanf("%d,%d,%d",&A->mu,&A->nu,&A->tu);
	//存在非法输入时,重新输入
    while(A->mu<=0||A->mu>MAXR||A->nu<=0||A->nu>MAXC)
    {
    printf("Enter the mu and nu and tu of Matrix A(mu,nu,tu): \n");
    scanf("%d,%d,%d",&A->mu,&A->nu,&A->tu);
    }
    printf("Enter the Matrix A(i-j:e):\n");
    for(i=1;i<=A->tu;i++)
    scanf("%d-%d:%d",&A->data[i].i,&A->data[i].j,&A->data[i].e);
    for(i=1;i<=A->mu;i++)
    num[i]=0;
	//统计每行非零元素的个数
    for(i=1;i<=A->tu;i++)
    ++num[A->data[i].i];
    A->rpos[1]=1;
    for(i=2;i<=A->mu;i++)
    A->rpos[i]=A->rpos[i-1]+num[i-1];//求每行第一个非零元素的位置
    printf("Enter the mu and nu and tu of Matrix B(mu,nu,tu): \n"); /*输入矩阵B,同上*/
    scanf("%d,%d,%d",&B->mu,&B->nu,&B->tu);
    while(A->mu<=0||A->mu>MAXR||A->nu<=0||A->nu>MAXC)
    {
    printf("Enter the mu and nu and tu of Matrix B(mu,nu,tu): \n");
    scanf("%d,%d,%d",&B->mu,&B->nu,&B->tu);
    }
    printf("Enter the Matrix B(i-j:e):\n");
    for(i=1;i<=B->tu;i++)
    scanf("%d-%d:%d",&B->data[i].i,&B->data[i].j,&B->data[i].e);
    for(i=1;i<=B->mu;i++)
    num[i]=0;
    for(i=1;i<=B->tu;i++)
    ++num[B->data[i].i];
    B->rpos[1]=1;
    for(i=2;i<=B->mu;i++)
    B->rpos[i]=B->rpos[i-1]+num[i-1];

   do{
       printf("Enter the operation you want(+,-,*):");    /*选择需要的运算*/
       cmd=getche();
     }while(cmd!='+'&&cmd!='-'&&cmd!='*');//非法输入时再此输入
    getch();//等待别跳屏
    switch(cmd) 
    {
      case '+' :  if(A->mu==B->mu&&A->nu==B->nu) ADD(A,B,T);   break;
      case '-' :  if(A->mu==B->mu&&A->nu==B->nu) SUB(A,B,T);   break;
      case '*' :  if(A->nu==B->mu)               MUL(A,B,T);   break;
      default  :  printf("No thia operation!");  break;
    }
}
void InitializationMatrix(RLSMatrix  *A,RLSMatrix  *B,RLSMatrix *T)  /*初始化矩阵*/
{
   A->mu=A->nu=A->tu=0;
   B->mu=B->nu=B->tu=0;
   T->mu=T->nu=T->tu=0;
}
/*************************************主函数************************************/
void InitializationMatrix(RLSMatrix  *A,RLSMatrix  *B,RLSMatrix *T);
void Enter(RLSMatrix  *A,RLSMatrix  *B,RLSMatrix *T);
void Print(RLSMatrix  *A,RLSMatrix  *B,RLSMatrix *T);
void ADD(RLSMatrix  *A,RLSMatrix  *B,RLSMatrix *T);
void SUB(RLSMatrix  *A,RLSMatrix  *B,RLSMatrix *T);
int MUL(RLSMatrix  *A,RLSMatrix  *B,RLSMatrix *T);
void Initialization();
void Exit();
void main()
{
    char cmd;
    RLSMatrix  *A,*B,*T;
    
    A=(  RLSMatrix *)malloc(sizeof( RLSMatrix));  /*分配空间*/
    B=(  RLSMatrix *)malloc(sizeof( RLSMatrix));
    T=(  RLSMatrix *)malloc(sizeof( RLSMatrix));
   InitializationMatrix(A,B,T);//初始化矩阵
    while(1)
  {
    Initialization();//初始化屏幕
    do{
    gotoxy(10,10);
    printf("Enter E/e ,Q/q ,P/p to continue:");
    cmd=getche();
    printf("\n");
    }while(cmd!='q'&&cmd!='Q'&&cmd!='e'&&cmd!='E'&&cmd!='p'&&cmd!='P');
    switch(cmd)
    {
      case 'q' : Exit();  break;
      case 'Q' : Exit();  break;
      case 'e' : Enter(A,B,T);  break;
      case 'E' : Enter(A,B,T);  break;
      case 'p' : Print(A,B,T);  break;
      case 'P' : Print(A,B,T);  break;
    }//switch
   }//while
}//main
void Initialization()      /*初始化函数*/
{
    system("cls"); 
    printf("*********************************************************************************");
    gotoxy(7,2);//到第2行第7列
    printf("Enter the RLSMatrix--E");
    gotoxy(38,2);
    printf("Print--P");
    gotoxy(55,2);
    printf("Quit--Q");
    gotoxy(80,2);
    printf("*");
    printf("********************************************************************************");
    gotoxy(1,22);
    printf("*********************************************************************************");
    gotoxy(10,23);
    printf("Enter a operation code: E/e ,Q/q ,P/p to continue: ");
    gotoxy(80,23);
    printf("*");
    printf("********************************************************************************");

}
void Exit()       /*退出函数*/
 {
   char cmd;
   do{
     gotoxy(10,11);
     printf("Do you want to out?Y/N:");
     cmd=getche();
     }while(cmd!='y'&&cmd!='Y'&&cmd!='n'&&cmd!='N');
     if(cmd=='y'||cmd=='Y')
       exit(0);
 }