java三元组的快速转置_数据结构稀疏矩阵的三元组相加和快速转置算法

#include

#include

#define OK 1

typedef int status;

#define MAXSIZE 12500

typedef int ElemType ;//数据类型

typedef struct

{

int i,j;// 行下标,列下标

ElemType e; // 非零元素值

}Triple;

typedef struct

{

Triple data[MAXSIZE+1]; // 非零元三元组表,data[0]未用

int mu,nu,tu;// 矩阵的行数、列数和非零元个数

}TSMatrix;

#include "TSMatrix.h"

status scan_n_m(TSMatrix *);

int main()

{

int **A,**B;

srand((unsigned)time(NULL));

TSMatrix M,N,T,Q;

scan_n_m(&N);

scan_n_m(&M);

Initi_SMatrix(N,&B);

CreateSMatrix(&N,&B);

Initi_SMatrix(M,&A);

CreateSMatrix(&M,&A);

FastTransposeSMatrix(M,&T);

AddSMatrix(M,N,&Q);

printf("稀疏矩阵A----------------\n");

PrintSMatrix_T(M);

PrintSMatrix(M);

printf("稀疏矩阵B-----------------\n");

PrintSMatrix_T(N);

PrintSMatrix(N);

printf("稀疏矩阵A的转置矩阵T------\n");

PrintSMatrix_T(T);

PrintSMatrix(T);

printf("A,B矩阵相加得到的矩阵Q----\n");

PrintSMatrix_T(Q);

PrintSMatrix(Q);

}

//输入矩阵行和列

status scan_n_m(TSMatrix *M)

{

printf("请输入矩阵的行数, 列数:\n");

scanf("%d", &(*M).mu);

scanf("%d",&(*M).nu);

}

//初始化矩阵

status Initi_SMatrix(TSMatrix M,int ***T)

{

*T = (int **)malloc(sizeof(int *) * (M.mu) );//开辟行

for(int i = 0; i < M.nu ;i++) {

*(*T + i) = (int *)malloc(sizeof(int) * M.nu);//开辟列

}

}

// 创建稀疏矩阵M

status CreateSMatrix(TSMatrix *M,int ***T)

{

int k;

int a=1;

M->tu = 0;

for(int i = 0;i < M->mu;i++)

{

for(int j = 0;j < M->nu;j++)

{

k= rand()%100;

(*T)[i][j] = rand()%100 > 80 ? k : 0;

if((*T)[i][j] != 0)

{

M->data[a].i = i + 1;//行下标

M->data[a].j = j + 1;//列下标

M->data[a].e = (*T)[i][j];//该下标所对应的值

M->tu ++;

a++;

}

}

}

return OK;

}

// AddSMatrix函数用来比较元素大小

int comp(int c1,int c2)

{

int i;

if(c1

i=1;

else if(c1==c2)

i=0;

else

i=-1;

return i;

}

// 求两个稀疏矩阵的和Q=M+N

status AddSMatrix(TSMatrix M,TSMatrix N,TSMatrix *Q)

{

Triple *Mp,*Me,*Np,*Ne,*Qh,*Qe;

if(M.mu!=N.mu)

return 0;

if(M.nu!=N.nu)

return 0;

(*Q).mu=M.mu;

(*Q).nu=M.nu;

Mp=&M.data[1];// Mp的初值指向矩阵M的非零元素首地址,工作指针

Np=&N.data[1];// Np的初值指向矩阵N的非零元素首地址,工作指针

Me=&M.data[M.tu];// Me指向矩阵M的非零元素尾地址

Ne=&N.data[N.tu];// Ne指向矩阵N的非零元素尾地址

Qh=Qe=(*Q).data;// Qh、Qe的初值指向矩阵Q的非零元素首地址的前一地址

while(Mp <= Me && Np <= Ne)

{

Qe++;

switch(comp(Mp->i,Np->i))

{

case 1:

*Qe=*Mp;

Mp++;

break;

case 0:

// M、N矩阵当前非零元素的行相等,继续比较列

switch(comp(Mp->j,Np->j))

{

case 1:

*Qe=*Mp;

Mp++;

break;

case 0:

*Qe=*Mp;

Qe->e+=Np->e;

if(!Qe->e) // 元素值为0，不存入压缩矩阵

Qe--;

Mp++;

Np++;

break;

case -1:

*Qe=*Np;

Np++;

}

break;

case -1:

*Qe=*Np;

Np++;

}

}

if(Mp>Me) // 矩阵M的元素全部处理完毕

while(Np<=Ne)

{

Qe++;

*Qe=*Np;

Np++;

}

if(Np>Ne) // 矩阵N的元素全部处理完毕

while(Mp<=Me)

{

Qe++;

*Qe=*Mp;

Mp++;

}

(*Q).tu=Qe-Qh; // 矩阵Q的非零元素个数

return OK;

}

// 销毁稀疏矩阵M，所有元素置空

void DestroySMatrix(TSMatrix *M)

{

(*M).mu=0;

(*M).nu=0;

(*M).tu=0;

}

//快速转置矩阵算法

status FastTransposeSMatrix(TSMatrix M,TSMatrix *T)

{

int num[M.nu];

int cpot[M.nu];

T->mu = M.nu;

T->nu = M.mu;

T->tu = M.tu;

if(T->tu)

{

for(int col = 1;col <= M.nu; ++col)

{

num[col] = 0;

}

for(int t = 1; t <=M.tu;t++)//求M中每一列含非零元个数

{

++num[M.data[t].j];

}

cpot[1] = 1;

//求出第col列中第一个非零元素在T中的位置

for(int col = 2;col <= M.nu;++col)

{

cpot[col] = cpot[col-1] + num[col - 1];

}

for(int p = 1;p<=M.tu;p++)

{

int col = M.data[p].j;

int q = cpot[col];

T->data[q].j = M.data[p].i;

T->data[q].i = M.data[p].j;

T->data[q].e = M.data[p].e;

++cpot[col];

}//for

}//if

return OK;

}//FastTransporeSMatrix

// 输出稀疏矩阵M,三元组形式

void PrintSMatrix(TSMatrix M)

{

int i;

printf("\n %d 行, %d 列， %d 个非零元素。\n",M.mu, M.nu, M.tu);

printf("======================\n");

printf("%4s %4s %8s\n", "i", "j", "e");

printf("======================\n");

for(i=1;i<=M.tu;i++)

printf("%4d %4d %8d\n", M.data[i].i, M.data[i].j, M.data[i].e);

printf("======================\n");

}

//输出系数矩阵矩阵形式

status PrintSMatrix_T(TSMatrix M)

{

int i , j,k = 1;

for(i=1 ;i<=M.mu;i++)

{

for(j=1;j<=M.nu;j++)

{

if(M.data[k].i == i&&M.data[k].j == j)

{

printf("%2d ",M.data[k].e);

k++;

}

else

{

printf("%2d ",0);

}

}

printf("\n");

}

}

//---------------------------------------------------------------------

//快速转置矩阵

/*status transposeSMatrix(TSMatrix M,TSMatrix *T)

{

int p,q,col;

(*T).mu=M.nu;

(*T).nu=M.mu;

(*T).tu=M.tu;

if((*T).tu)

{

q=1;

for(col=1;col<=M.nu;++col)//先将列转换成行

for(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].e=M.data[p].e;

++q;

}

}

return OK;

}*/

// 由稀疏矩阵M复制得到T

int CopySMatrix(TSMatrix M,TSMatrix *T)

{

(*T)=M;

return 1;

}