7.1.cpp

数据结构(c)稀疏矩阵的三元组顺序存储结构的全部操作

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
#define OK 1
#define N 100
#define ERROR 0
#define OVERFLOW -1
#define MAX_ARRAY_DIM   8   //假设最大维数为8
typedef int status;

//（1）稀疏矩阵的三元组顺序存储结构定义：
#define MAXSIZE 100 //设非零元素最大个数100
 typedef int ElemType; 
 typedef struct{
 int i;              //元素行号
 int j;              //元素列号
 ElemType value;         //元素值
}Triple;        
typedef struct{
 Triple data[MAXSIZE+1]; //三元组表，以行为主序存入一维向量 data[]中
 int mu;          //矩阵总行数
 int nu;          //矩阵总列数
 int tu;          //矩阵中非零元素总个数
}TsMatrix;     

//（2）创建稀疏矩阵算法CreateSMatrix(&M);
status CreateSMatrix(TsMatrix &M)
{
	int x,y,z;
	printf("请输入矩阵的行数：");
	scanf("%d",&x);
	M.mu=x;
	printf("请输入矩阵的列数：");
	scanf("%d",&y);
	M.nu=y;
	printf("请输入矩阵中非零元素总个数：");
	scanf("%d",&z);
	M.tu=z;
    return OK;

 



}

//（3）打印稀疏矩阵算法PrintSMatrix(M);
status PrintSMatrix(TsMatrix M)
{









//(4)两稀疏矩阵相加，获得一新的矩阵Q的算法AddSMatrix(M,N,&Q);
//初始条件：稀疏矩阵M与N的行数和列数对应相等








//(5)两稀疏矩阵相减，获得一新的矩阵Q的算法AddSMatrix(M,N,&Q);
//初始条件：稀疏矩阵M与N的行数和列数对应相等


//(6) 两稀疏矩阵相乘，获得一新的矩阵Q的算法MultSMatrix(M,N,&Q);
//初始条件：稀疏矩阵M与N的行数和列数对应相等




//(7)求稀疏矩阵M的转置矩阵T算法
status TransPoseSMatrix(TsMatrix M,TsMatrix &T)
{
T.mu=M.nu;  T.nu=M.mu;  T.tu=M.tu;
 if (T.tu) { 
   int q=1;          
   for(int col=1; col<=M.nu; col++) 
     {for(int 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].value=M.data[p].value;  q++;
            }
          }
      }
   }
     return OK;
} //TranposeSMatrix;


void main()
{
	TsMatrix A,B,C;
    CreateSMatrix(&A);
    printf("稀疏矩阵A为:"\n);
    PrintSMatrix(A);
    CreateSMatrix(&B);
	printf("稀疏矩阵B为:"\n);
    PrintSMatrix(B);
    printf("两稀疏矩阵相加得:"\n);
    AddSMatrix(A,B,&C);
	printf("两稀疏矩阵相减得:"\n);
    MinusSMatrix(A,B,&C);
	printf("两稀疏矩阵相乘得:"\n);
    MultSMatrix(A,B,&C);
    printf("稀疏矩阵A的转置矩阵为:"\n);
	TransposeSMatrix(A,&T);

}

/*
typedef int ElemType;
typedef struct{
      ElemType *base;       //数组元素基址,由InitArray分配
      int            dim;             //数组维数
      int          *bounds;        //数组各维长度信息保存区基址（数组维界基址）
      int         *constants;   //数组映像函数常量的基址Ci
   }Array;

Status InitArray(Array &A,int dim,…)
{    //若维数dim和各维长度合法，则构造相应的数组A并返回OK
	int elemtotal,i; va_list ap；
   　if(dim<1||dim>MAX_ARRAY_DIM) 
　　　　return ERROR;
   　A.dim=dim;
  　 A.bounds=(int *)malloc(dim * sizeof(int));
  　 if(!A.bounds) exit(OVERFLOW);
     //若各维长度合法，则存入A.bounds,并求出A的元素总数elemtotal
     elemtotal=1;
　   va_start(ap,dim); 
     //ap为va_list类型，是存放变长参数表信息的类型
     for(i=0;i<dim;++i){
       A.bounds[i]=va_arg(ap,int);
       if(A.bounds[i]<0) return UNDERFLOW;
       elemtotal *=A.bounds[i];   }
      va_end(ap);
      A.base=(ElemType * )malloc(elemtotal * sizeof(ElemType));
      if(!A.base) exit(OVERFLOW);
      A.constants=(int * )malloc(dim *sizeof(int));
      //求Ci时仅于维数dim、bi有关
     if(!A.constants) exit(OVERFLOW);
     A.constants[dim-1]=1;
     for(i=dim-2;i>=0;--i)
    　A.constants[i]=A.bounds[i+1]*A.constants[i+1];
     //其中Cn=L, Ci-1=bi×Ci，1<i≤n
      return OK;
 }

Status DestroyArray(Array &A)
{     //销毁数组A
   if (!A.base) return ERROR;
   free(A.base);
   A.base=NULL;
   if (!A.bounds)return ERROR;
   free(A.bounds);
   A.bounds=NULL;
   if(!A.constants)return ERROR;
   free(A.constants) ;
   A.constants=NULL;
   A.dim=0;
   return OK;
 }

Status Locate(Array A,va_list ap,int &off)
{   int i,ind;
  //若ap指示的各下标值合法，则求出该元素在A中，相对地址off，即为
    off=0;
	//va_start()在调用Locate函数中调用。
    for(i=0;i<A.dim;++i)
    {
      ind=va_arg(ap,int);
      if(ind<0||ind>A.bounds[i]) return OVERFLOW;//判下标是否越界
      off+=A.constants[i]*ind;
    }
	va_end(ap);
    return OK;
}
//４、读取数组Ａ中指定的元素
Status Value(Array A,ElemType *e,...){
  //A是n维数组，e为元素变量，随后是n个下标值，若各下标不超界，则e赋值为所指定的A的元素值，即将指定元素值读到e变量中。
   int result,off;va_list ap;
   va_start(ap,e);//ElemType &e可以吗?
   if((result=Locate(A,ap,off))<=0) return result;
   *e=*(A.base+off);//等价于*e=A.base[off];
   return OK;
}

//５、给数组某元素赋值
Status Assign(Array &A,ElemType e,…){
  //A是n维数组，e为元素变量，随后是n个下标值，若各下标不超界，则e的值赋为所指定的A的元素值，即：将e值写入指定数组单元。
   va_start(ap,e);
   if((result=Locate(A,ap,off))<=0) return result;
   *(A.base+off)=e;//等价于A.base[off]=e;
   return OK;
 }

void main()
{Array A;va_list ap;ElemType e=0;
  InitArray(A,2,2,2);
  Assign(A,1,1,1);
  Value(A,&e,1,1);
  printf("e=%d",e);
}
*/