数组（稀疏矩阵）

typedef struct
{
	int i,j;
	int value;
}Triple;
typedef struct
{
	Triple data[MAXSIZE];
	int rpos[MAXRC]; 
	int row,col,num;
}XiShuArray;
int triarray(XiShuArray  &M)
//     创建一个稀疏矩阵；  
//     输入行数、列数，支持乱序输入三元组，并计数；  
{  
       int num=0,p,q,min,temp;  //     中间变量；  
       int row;  
       printf("请输入稀疏矩阵的总行数和总列数（空格隔开）:\n");  
       scanf("%d%d",&M.row,&M.col); //     输入行数、列数；  
       if(M.row>MAXRC)
              return ERROR;
	   printf("请输入三元组顺序表的内容：\n");
       printf("i j value\n");
       scanf("%d%d%d",&M.data[num+1].i,&M.data[num+1].j,&M.data[num+1].value);  
       while(M.data[num+1].i) //     乱序输入三元组；  
       {
              if(++num>MAXSIZE)  
                     return ERROR;  
              scanf("%d%d%d",&M.data[num+1].i,&M.data[num+1].j,&M.data[num+1].value);  
       }  
       M.num=num; //     num的值即为此矩阵的非零元个数；  
       
	   for(p=1;p<=M.num-1;++p)   // 按行为主序依次重新排列非零元  
       {  
              min=p;           //     使较小的行数、列数的元的序号min为当前值p；  
              for(q=p+1;q<=M.num;++q)           //     开始依次比较；  
              {  
                     if(M.data[min].i>M.data[q].i||(M.data[min].i==M.data[q].i&&M.data[min].j>M.data[q].j))  
                            min=q;           //     在乱序的三元表中，始终保证min是较小的行列数的序号；  
              }  
              temp=M.data[min].i;                         //     交换行值；            
               M.data[min].i=M.data[p].i;  
              M.data[p].i=temp;  
              temp=M.data[min].j;                         //     交换列值；  
              M.data[min].j=M.data[p].j;  
              M.data[p].j=temp;  
              temp=M.data[min].value;                        //     交换元素值；  
              M.data[min].value=M.data[p].value;  
              M.data[p].value=temp;  
       }  
       for(row=1,num=0;row<=M.row;++row)            // 记录M.rpos[row];  
       {  
              M.rpos[row]=num+1;  
              while(M.data[num+1].i==row)  
                     ++num;    
       }  
       return OK;  
} 
void printtriarray(XiShuArray &M)
{
	printf("    i    j    k\n");
	for(int k=1;k<=M.num;k++)
	{
		printf("%5d",M.data[k].i);
		printf("%5d",M.data[k].j);
		printf("%5d",M.data[k].value);
		printf("\n");
	}
}
void printxishuarray(XiShuArray &M)
{
	int i,j,t=1,e=0;
	for(i=1;i<=M.row;i++)
	{
		for(j=1;j<=M.col;j++)
		{
			if(M.data[t].i==i&&M.data[t].j==j)
			{
				printf("%3d",M.data[t].value);
				t++;
			}
			else
				printf("%3d",e);
		}
		printf("\n");
	}
}
//实现矩阵的转置；
int zhuanzhi(XiShuArray M,XiShuArray &T)
{
	int col,p,q,t;
	int num[MAXSIZE],cpot[MAXSIZE];
	T.row=M.col;
	T.col=M.row;
	T.num=M.num;
	if(T.num)
	{
		//计算num[col]的值
		for(col=1;col<=M.col;++col)
			num[col]=0;
		for(t=1;t<=M.num;++t)
		++num[M.data[t].j];
		//计算cpot[col]的值
		cpot[1]=1;
		for(col=2;col<=M.col;++col)
			cpot[col]=cpot[col-1]+num[col-1];
		//扫描三元组顺序表M，生成三元组顺序表T
		for(p=1;p<=M.num;++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].value=M.data[p].value;
			++cpot[col];
		}
	}
	return OK;
}


int MulTriple(XiShuArray M,XiShuArray N,XiShuArray & Q)
//输入两个稀疏矩阵M和N，并初始化Q，然后计算M*N的值赋给Q   
{  
       int arow,brow,ccol;  
       int ctemp[MAXSIZE+1]; //以N的列值为序号的临时数组 
       int tp,p,tq,q;  //中间变量   
       if(M.col!=N.row)
	   {
		   printf("您输入的矩阵不能相乘!\n");
              return ERROR; 
	   }
       Q.row=M.row;   //初始化Q  
       Q.col=N.col;
       Q.num=0;
       if(M.num*N.num!=0)  //Q是非零矩阵 
       {  
              for(arow=1;arow<=M.row;++arow) //逐行扫描
              {
                     for(ccol=1;ccol<=N.col;ccol++)
                            ctemp[ccol]=0;  // 初始化累加器 
                     Q.rpos[arow]=Q.num+1;  //????????????????????
                     if(arow<M.row)
                            tp=M.rpos[arow+1];  //tp是M下一行的序号 
                     else  
                            tp=M.num+1;  //MEICUO
                     for(p=M.rpos[arow];p<tp;++p) //从M的当前行找到元素
                     {  
                            brow=M.data[p].j;  //对应元在N中的行号
                            if(brow<N.row)
                                   tq=N.rpos[brow+1];  //tq是N下一行的行号 
                            else  
                                   tq=N.num+1;//youcuo
                            for(q=N.rpos[brow];q<tq;++q)  //以M的对应元的列号为N的行号进行扫描 
                            {  
                                   ccol=N.data[q].j;//提取对应元的列号  
                                   ctemp[ccol]+=M.data[p].value*N.data[q].value;    
                                 //两个对应元的值相乘并累加到以列号为序号的累加器中
                            }  
                     } 
                     for(ccol=1;ccol<=Q.col;++ccol) // 将此行非零元压缩入Q中
                     {  
                            if(ctemp[ccol])
                            {  
                                   if(++Q.num>MAXSIZE)  
                                          return ERROR;  
                                   Q.data[Q.num].i=arow;  
                                   Q.data[Q.num].j=ccol;  
                                   Q.data[Q.num].value=ctemp[ccol];  
                            }  
                     }  
              }  
       }  
       return OK;  
}
//加法的实现
int addTriple(XiShuArray M,XiShuArray W,XiShuArray &X)
{
	int p,q,temp=1;
	int min,row,num;
	if(M.row!=W.row||M.col!=W.col)
	{
		printf("您输入的矩阵不能相加减!\n");
              return ERROR;
	}
	   //初始化X
	 X.row=M.row;  
       X.col=M.col;
       M.num=0;
	   for(p=1;p<=M.num||p<=W.num;p++)
	   {
		   for(q=1;q<=M.num||q<=W.num;p++)
		   {
		   if(M.data[p].i==W.data[q].i&&M.data[p].j==W.data[q].j)
		   {X.data[temp].value=M.data[p].value+W.data[q].value;temp++;}
		   else
			  { X.data[temp].value=M.data[p].value;temp++;
		        X.data[temp].value=W.data[q].value;temp++;
		      }
		   }
	   }




	      for(p=1;p<=X.num-1;++p)   // 按行为主序依次重新排列非零元  
       {  
              min=p;           //     使较小的行数、列数的元的序号min为当前值p；  
              for(q=p+1;q<=X.num;++q)           //     开始依次比较；  
              {  
                     if(X.data[min].i>X.data[q].i||(X.data[min].i==X.data[q].i&&X.data[min].j>X.data[q].j))  
                            min=q;           //     在乱序的三元表中，始终保证min是较小的行列数的序号；  
              }  
              temp=X.data[min].i;                         //     交换行值；            
               X.data[min].i=X.data[p].i;  
              X.data[p].i=temp;  
              temp=X.data[min].j;                         //     交换列值；  
              X.data[min].j=X.data[p].j;  
              X.data[p].j=temp;  
              temp=X.data[min].value;                        //     交换元素值；  
              X.data[min].value=X.data[p].value;  
             X.data[p].value=temp;  
       }  
       for(row=1,num=0;row<=X.row;++row)            // 记录M.rpos[row];  
       {  
              X.rpos[row]=num+1;  
              while(X.data[num+1].i==row)  
                     ++num;    
       }  



	   return OK;
}


//减法的实现
/*int redTriple(XiShuArray M,XiShuArray W,XiShuArray &Y)
{
}*/