稀疏矩阵转置c语言

‘壹’ 编写用“三元组表”存储稀疏矩阵，进行矩阵处理的程序。实现（1）矩阵转置 （2）矩阵相加

矩阵加减注意格式
#include <stdio.h>
#define maxsize 20
typedef int data;
typedef struct
{
int i,j;
data v;
}mat;
typedef struct
{
int m,n,t;
mat dtt[maxsize+1];
}matrix;
matrix a,b,c;
void transmat(matrix a,matrix *b)
{
int p,q,col;
b->m=a.n;
b->n=a.m;
b->t=a.t;
if(a.t!=0)
{
q=1;
for(col=1;col<=a.n;col++)
for(p=1;p<=a.t;p++)
if(a.dtt[p].j==col)
{
b->dtt[q].j=a.dtt[p].i;
b->dtt[q].i=a.dtt[p].j;
b->dtt[q].v=a.dtt[p].v;
q++;
}
}
}
void creat(matrix *x)
{
printf("\nn,m,t=?");
scanf("%d,%d,%d",&x->n,&x->m,&x->t);
for(int i=1;i<=x->t;i++)
{
printf("\ni,j,v=?");
scanf("%d,%d,%d",&x->dtt[i].i,&x->dtt[i].j,&x->dtt[i].v);
}
}
void mout(matrix x)
{
printf("\nn,m,t=");
printf("%d,%d,%d\n",x.n,x.m,x.t);
for(int i=1;i<=x.t;i++)
{
printf("\ni,j,v=");
printf("%d,%d,%d\n",x.dtt[i].i,x.dtt[i].j,x.dtt[i].v);
}
}
void jiajian(matrix x,matrix y,matrix *b)
{
int t;
printf("\n1加");
printf("\n2减\n\n");
scanf("%d",&t);
if(t==1)
{
int s=0,j=1,z=1;
b->m=x.m;
b->n=x.n;
for(int i=1;i<=b->n;i++)
{
for(;j<=x.t,z<=y.t;)
{
if(x.dtt[j].i!=i&&y.dtt[z].i!=i)
{
break;
}
else if(x.dtt[j].i!=i)
{
s++;
b->dtt[s].i=i;
b->dtt[s].j=y.dtt[z].j;
b->dtt[s].v=y.dtt[z].v;
z++;
}
else if(y.dtt[z].i!=i)
{
s++;
b->dtt[s].i=i;
b->dtt[s].j=x.dtt[j].j;
b->dtt[s].v=x.dtt[j].v;
j++;
}
else if(x.dtt[j].j>y.dtt[z].j)
{
s++;
b->dtt[s].i=i;
b->dtt[s].j=y.dtt[z].j;
b->dtt[s].v=y.dtt[z].v;
z++;
}
else if(x.dtt[j].j==y.dtt[z].j)
{
s++;
b->dtt[s].i=i;
b->dtt[s].j=y.dtt[z].j;
b->dtt[s].v=y.dtt[z].v+x.dtt[j].v;
z++;
j++;
}
else if(x.dtt[j].j<y.dtt[z].j)
{
s++;
b->dtt[s].i=i;
b->dtt[s].j=x.dtt[j].j;
b->dtt[s].v=x.dtt[j].v;
j++;
}
}
}
b->t=s;
}
else if(t==2)
{
int s=0,j=1,z=1;
b->m=x.m;
b->n=x.n;
for(int i=1;i<=b->n;i++)
{
for(;j<=x.t,z<=y.t;)
{
if(x.dtt[j].i!=i&&y.dtt[z].i!=i)
{
break;
}
else if(x.dtt[j].i!=i)
{
s++;
b->dtt[s].i=i;
b->dtt[s].j=y.dtt[z].j;
b->dtt[s].v=-y.dtt[z].v;
z++;
}
else if(y.dtt[z].i!=i)
{
s++;
b->dtt[s].i=i;
b->dtt[s].j=x.dtt[j].j;
b->dtt[s].v=x.dtt[j].v;
j++;
}
else if(x.dtt[j].j>y.dtt[z].j)
{
s++;
b->dtt[s].i=i;
b->dtt[s].j=y.dtt[z].j;
b->dtt[s].v=-y.dtt[z].v;
z++;
}
else if(x.dtt[j].j==y.dtt[z].j)
{
if(x.dtt[j].v-y.dtt[z].v!=0)
{
s++;
b->dtt[s].i=i;
b->dtt[s].j=y.dtt[z].j;
b->dtt[s].v=x.dtt[j].v-y.dtt[z].v;
}
z++;
j++;
}
else if(x.dtt[j].j<y.dtt[z].j)
{
s++;
b->dtt[s].i=i;
b->dtt[s].j=x.dtt[j].j;
b->dtt[s].v=x.dtt[j].v;
j++;
}
}
}
b->t=s;
}
}
int main(int argc, char *argv[])
{
printf("1创建\n");
printf("2转置\n");
printf("3矩阵加减\n");
printf("4退出\n");
printf("\n\n\n");
int t;
while(~scanf("%d",&t))
{
if(t==1)
{
creat(&a);
}
else if(t==2)
{
transmat(a,&b);
mout(b);
}
else if(t==3)
{
creat(&c);
jiajian(a,c,&b);
mout(b);
}
else if(t==4)
break;
printf("\n\n\n");
printf("1创建\n");
printf("2转置\n");
printf("3矩阵加减\n");
printf("4退出\n");
printf("\n\n\n");
}

return 0;
}

‘贰’ c语言矩阵转置问题

其实只是小问题，你自己都编的很好了。就是保存屏幕不在按入Q和Enter键屏幕不会马上消失上面有问题：
你可以用两个getchar（）函数来读取键盘输入，前一个数缓冲enter键，后一个等待键盘输入，然后屏幕消失！
代码已修改，如下：
#include <stdio.h>
#include <stdlib.h>

#define MAXSIZE 20 /*矩阵中最大非零元的个数*/
typedef struct triple
{
int i; /*行标,本程序中从1开始的*/
int j; /*列标,本程序中从1开始的*/
int e; /*非零元*/
}Triple; /*三元组定义*/

typedef struct tabletype
{
int mu; /*矩阵的行数*/
int nu; /*列数*/
int tu; /*非零元个数*/
Triple data[MAXSIZE+1]; /*非零元的三元组表,*/
}Tabletype; /*三元组线性表*/

void out_matrix(Tabletype *); /*输出 矩阵*/

/*以下为转置程序,将a所指矩阵转置，将结果存入b所指的矩阵中*/
int TransposeSMatrix(Tabletype *,Tabletype *);
int main( void )
{
char ch;

while(1)
{
printf(" @@@@@@@@@@本程序的功能是实现稀疏矩阵的普通转置@@@@@@@@@@@@@@@@@@@\n");
printf(" @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n");
/*源矩阵a*/
Tabletype a= {6,7,8,{ {1,2,12},{1,3,9},{3,1,-3},{3,6,14},{4,3,24},{5,2,18},{6,1,15},{6,4,-7} }};
Tabletype b; /*声明矩阵b*/
printf("The source Matrix:\n");
out_matrix(&a);
if(TransposeSMatrix(&a,&b)) /*若a不为零矩阵则转置a，存入b中*/
{ printf("After TransposeSMatrix: \n");
out_matrix(&b);
}
else
{
printf("The matrix is zeros:\n");
out_matrix(&a);
}
do{
printf("Input 'q' to quit and ENTER run again:");
if((ch = getchar()) == 'q' || ch == 'Q')
getchar(); //读取enter
getchar();//任意字符
exit(0);
}while(ch!='\n');
system("cls");
}
return 1;
}

void out_matrix(Tabletype *a) /* 打印矩阵*/
{
int i,j,k = 0;

for(i = 1 ;i <= a->mu; i++)
{
for(j = 1; j<= a->nu; j++)
{ /*判断是否为非零元*/
if((a->data[k].i == i)&&(a->data[k].j == j))
{
printf("%4d",a->data[k].e);
k++;
}
else
printf("%4d",0);
}
printf("\n");
}
}

int TransposeSMatrix(Tabletype *a,Tabletype *b)
{
int p,q,col;
b->mu = a->nu; /*原矩阵的行数为新矩阵的列数，愿列数为新行数，非零元个数不变*/
b->nu = a->mu;
b->tu = a->tu;
if(b->tu) /*若a不为零矩阵*/
{
q = 0; /*b->data下标*/
for(col = 1; col < a->nu; col++)
for(p = 0;p < a->tu;p++) /*p为a->data的下标*/
if(col == a->data[p].j) /*按b->data[q]中的列标对a->data[p]进行扫描*/
{
b->data[q].i = a->data[p].j;
b->data[q].j = a->data[p].i;
b->data[q].e = a->data[p].e;
q++;
}
return 1;
}
else /*a为零矩阵*/
return 0;
}

不知道是不是你的要求。希望能帮助你！

‘叁’ 采用基于稀疏矩阵的三元组压缩存储方法，实现m×n矩阵的快速转置

#include<iostream>
using
namespace
std;
class
matrix
{
public:
int
data[100][100];
int
m,n;
};
typedef
int
spmatrix[100][3];
void
Init(matrix&
mx);//稀疏矩阵初始化
void
SpmDisplay(spmatrix
spm);//显示三元组表示的矩阵
void
Compressmatrix(matrix
A,spmatrix
B);//将稀疏矩阵转换为三元组矩阵
void
Transpmatrix(spmatrix
B,spmatrix&
C);//将三元组矩阵转置
int
main()
{
matrix
mx;
spmatrix
spm1,spm2;
//矩阵初始化
Init(mx);
//矩阵转为三元组
Compressmatrix(mx,spm1);
//显示三元组矩阵
SpmDisplay(spm1);
//将三元组转置存放到spm2中
Transpmatrix(spm1,spm2);
//显示转置后的三元组
SpmDisplay(spm2);
return
0;
}

‘肆’ 稀疏矩阵三元组表示以及转置

visual studio下编译通过，测试结果正确，万一VC6编译不过请用TC2.0
//稀疏矩阵就是只记录非零元的位置和值，适合处理0比较多的矩阵
#include <stdio.h>
#include <malloc.h>

#define MAXSIZE 10

typedef struct node
{
int i,j,value; //i为行下标，j为列下标，value为该处的值
}NODE;
typedef struct mat
{
int mv,mc,mt; //mv为行数，mc为列数，mt为非零元个数
NODE v[MAXSIZE];
}MAT;
//view为输出稀疏矩阵
void view(MAT *a)
{
printf("矩阵的三元组表示：\n");
printf("i j v\n");
for(int k=0;k<a->mt;k++)
printf("%-6d%-6d%-6d\n",a->v[k].i,a->v[k].j,a->v[k].value);

}
//init为输入一个矩阵并存为稀疏矩阵
void init(MAT *a)
{
int k=0; //非零元的序号
//for(k=0;k<MAXSIZE;k++)
// a->v[k].value=0; //先都初始化为零
a->mt=0;
printf("请输入行数和列数：\n");
scanf("%d%d",&a->mv,&a->mc);
printf("\n请依次输入矩阵的各个元素的值：\n");
for(int m=1;m<=a->mv;m++)
for(int n=1;n<=a->mc;n++)
{
int t;
scanf("%d",&t);
//如果t为非零元，存入v[k]中
if(t!=0)
{
a->v[k].i=m;
a->v[k].j=n;
a->v[k].value=t;
a->mt++;
k++;
}
}
}
//矩阵a转置后存入矩阵b
void change(MAT *a,MAT *b)
{
b->mv=a->mc;
b->mc=a->mv;
b->mt=a->mt;
if(a->mt)
{
int p=0,q=0;
for(int n=1;n<=a->mc;n++)
for(int p=0;p<=a->mc;p++)
{
if(a->v[p].j==n) //v[p]是第n列的非零元
{
b->v[q].i=a->v[p].j;
b->v[q].j=a->v[p].i;
b->v[q].value=a->v[p].value;
q++;
}
}
}
}
void main()
{
MAT *a,*b;
b=(MAT *)malloc(sizeof(MAT));
a=(MAT *)malloc(sizeof(MAT));
init(a);
view(a);
change(a,b);
view(b);
}

‘伍’ 用十字链表存储结稀疏矩阵，并进行矩阵的转置。 要C的，c++的我看不懂。。。。~

这个吧 功能比你要的还多：http://wenku..com/view/3d744dd950e2524de5187e68.html
建立稀疏矩阵A 的十字链表首先输入的信息是：m（A 的行数），n（A 的列数），r（非零项的数目），紧跟着输入的是r 个形如（i,j,aij）的三元组。

算法的设计思想是：首先建立每行（每列）只有头结点的空链表，并建立起这些头结点拉成的循环链表；然后每输入一个三元组（i，j，aij），则将其结点按其列号的大小插入到第i 个行链表中去，同时也按其行号的大小将该结点插入到第j 个列链表中去。在算法中将利用一个辅助数组MNode *hd[s+1]; 其中s=max(m , n) , hd [i]指向第i 行(第i 列)链表的头结点。这样做可以在建立链表时随机的访问任何一行（列），为建表带来方便。

算法如下：
MLink CreatMLink( ) /* 返回十字链表的头指针*/
｛
MLink H;
Mnode *p,*q,*hd[s+1];
int i,j,m,n,t;
datatype v;
scanf(“%d,%,%d”,&m,&n,&t);
H=malloc(sizeof(MNode)); /*申请总头结点*/
H->row=m; H->col=n;
hd[0]=H;
for(i=1; i<S; i++)
{ p=malloc(sizeof(MNode)); /*申请第i 个头结点*/
p->row=0; p->col=0;
p->right=p; p->down=p;
hd[i]=p;
hd[i-1]->v_next.next=p;
}
hd[S]->v_next.next=H; /*将头结点们形成循环链表*/
for (k=1;k<=t;k++)
{ scanf (“%d,%d,%d”,&i,&j,&v); /*输入一个三元组，设值为int*/
p=malloc(sizeof(MNode));
p->row=i ; p->col=j; p->v_next.v=v
/*以下是将*p 插入到第i 行链表中去，且按列号有序*/
q=hd[i];
while ( q->right!=hd[i] && (q->right->col)<j ) /*按列号找位置*/
q=q->right;
p->right=q->right; /*插入*/
q->right=p;
/*以下是将*p 插入到第j 行链表中去，且按行号有序*/
q=hd[i];
while ( q->down!=hd[j] && (q->down->row)<i ) /*按行号找位置*/
q=q->down;
p-> down =q-> down; /*插入*/
q-> down =p;
} /*for k*/
return H;
} /* CreatMLink */

‘陆’ 稀疏矩阵与转置算法

#include<stdio.h>
#include<stdlib.h>

typedefstruct{
introw;
intcol;
intdata;
}xishu;//存储稀疏矩阵的结构(行，列，值)


#defineMAX_COL10
//staticvoidtranspose(xishua[],xishub[]);//普通算法

staticvoidfasttranspose(xishua[],xishub[]);//改进的算法

staticvoidcreate(inta[][6],intm,intn,xishub[],int*count);
staticvoidprint(int*count,xishua[]);

intmain(intargc,char**argv)
{
inta[6][6]={{0,0,0,22,0,-1},{0,71,0,0,0,0},{0,0,0,88,0,0},
{0,0,-9,0,0,0},{0,0,0,0,0,0},{0,0,0,0,0,7}};
xishub[10],c[10];
intcount=0,i,k;

for(i=0;i<10;i++){
b[i].row=c[i].row=0;
b[i].col=c[i].col=0;
b[i].data=c[i].data=0;
}//初始化


create(a,6,6,b,&count);//建立一个以xishu为元素的数组来表示一个稀疏矩阵

printf("
beforetranpose
");
print(&count,b);//打印建立好的稀疏矩阵


//transpose(b,c);

fasttranspose(b,c);//建立转置矩阵

printf("
aftertranspos
");
print(&count,c);//打印转置矩阵

exit(0);
}

staticvoidprint(int*count,xishua[])
{
intk;

for(k=1;k<=*count;k++){
printf("%d	%d	%d
",a[k].row,a[k].col,a[k].data);
}
}

staticvoidcreate(inta[][6],intm,intn,xishub[],int*count)
{
inti,j;

*count=0;
b[0].row=m;
b[0].col=n;

for(i=0;i<m;i++){
for(j=0;j<n;j++){
if(a[i][j]!=0){
(*count)++;
b[*count].row=i;
b[*count].col=j;
b[*count].data=a[i][j];
}
}
}
b[0].data=*count;
}

/***
staticvoidtranspose(xishua[],xishub[])
{
//该算法的时间代价为O(a[0].data*a[0].data)

intcount=0;
inti,col;

b[0].row=a[0].col;
b[0].col=a[0].row;
b[0].data=a[0].data;
printf("%d,%d,%d
",b[0].row,b[0].col,b[0].data);
printf("%d,%d,%d
",a[0].row,a[0].col,a[0].data);

for(col=0;col<a[0].col;col++){
for(i=1;i<=a[0].data;i++){
if(a[i].col==col){
count++;
b[count].row=a[i].col;
b[count].col=a[i].row;
b[count].data=a[i].data;
}
}
}
}
***/
staticvoidfasttranspose(xishua[],xishub[])
{
//改进的算法，该算法的时间代价为O(a[0].col+a[0].data)

inti,pos;
introw_num[MAX_COL];
intstart_pos[MAX_COL];

b[0].row=a[0].col;
b[0].col=a[0].row;
b[0].data=a[0].data;

for(i=0;i<a[0].col;i++){
row_num[i]=0;
}
for(i=1;i<=a[0].data;i++){
row_num[a[i].col]++;
}

start_pos[0]=1;
for(i=1;i<a[0].col;i++){
start_pos[i]=start_pos[i-1]+row_num[i-1];
}

for(i=1;i<=a[0].data;i++){
pos=start_pos[a[i].col];
while(b[pos].data!=0){
pos++;
}
b[pos].row=a[i].col;
b[pos].col=a[i].row;
b[pos].data=a[i].data;
}
}

‘柒’ 关于稀疏矩阵的数组存储表示，转置，输出

#include<iostream>
using std::cout;
using std::cin;
using std::endl;
struct node
{
int r;//行标
int c;//列标
double dat;//数据
};
class triple
{
private:
int row;//行数
int col;//列数
int num;//非零个数
node *ptr;//存放数组的首地址
public:
triple(int co,int ro,int nu):col(co),row(ro),num(nu)
{
ptr=new node[num];//分配num，盛放num个元素
cout<<"请输入"<<num<<"个三元组元素\n"<<"格式为： 2 3 6.7\n其中2为行标，3为列标，6.7为数据元素"<<endl;
for(int i=0;i<num;i++)
{
cin>>ptr[i].r;
cin>>ptr[i].c;
cin>>ptr[i].dat;
}
}
~triple(){delete[]ptr;}
void print()
{
int flag=ptr[0].r;
cout<<"第"<<flag<<"行元素为：";
for(int i=0;i<num;i++)
{
if(ptr[i].r!=flag)
{
cout<<"\n";
flag=ptr[i].r;
cout<<endl;
cout<<"第"<<flag<<"行元素为：";
}
cout<<"("<<ptr[i].r<<","<<ptr[i].c<<","<<ptr[i].dat<<") ";
}
}
void transpose()
{
int flag=0;
for(int i=1;i<=col;i++)
{
for(int j=0;j<num;j++)
{
if(ptr[j].c==i)
{
if(flag!=ptr[j].c)
{
flag=ptr[j].c;
cout<<"\n第"<<ptr[j].c<<"行为：";
}
cout<<"("<<ptr[j].c<<","<<ptr[j].r<<","<<ptr[j].dat<<") ";
}
}
}
}
};
void main()
{
cout<<"请输入数组的行列和元素个数：\n";
int a[3];
for(int i=0;i<3;i++)
{
cin>>a[i];
}
triple t(a[0],a[1],a[2]);
t.print();//输出原矩阵
cout<<"转制后的矩阵为：";
t.transpose();
}

‘捌’ 用C语言编写一个矩阵运算的程序，高分！

//矩阵三元组之矩阵相加 相乘
#include <iostream>
using namespace std;
typedef int Elemtype;
#define MAXSIZE 12500 //最大非零元素
typedef struct Triple
{
Elemtype value;
int row,col;
}Triple;

typedef struct TSMatrix
{
Triple data[MAXSIZE+1];
int mu,nu,tu;
}TSMatrix;
TSMatrix T;
void InputMatrix(TSMatrix &T) //输入t个非零元素
{
cout<<"请输入稀疏矩阵的信息,(行，列，非零元素个数)"<<endl;
cin>>T.mu>>T.nu>>T.tu;
int i;
cout<<"请输入非零元素的信息(行，列，值),提醒(下标从1开始)"<<endl;
for(i=1;i<=T.tu;++i)
{
cin>>T.data[i].row>>T.data[i].col>>T.data[i].value;
}
}

void Output(TSMatrix T)
{
cout<<"矩阵的三元组表示(ROW=)"<<T.mu<<" COL="<<T.nu<<"非零个数="<<T.tu<<endl;
int i;
for(i=1;i<=T.tu;++i)
{
cout<<"ROW(行):"<<T.data[i].row<<" COL(列):"<<T.data[i].col<<" Value(值)"<<T.data[i].value<<endl;
}
}

void TransposeSMatrix(TSMatrix M,TSMatrix &T) //矩阵的转置
{
T.mu=M.nu;T.nu=M.mu;T.tu=M.tu;
int i,j,k=1;
for(i=1;i<=M.nu;++i)
{
for(j=1;j<=M.tu;++j)
if(M.data[j].col==i)
{
T.data[k].row=i;
T.data[k].col=M.data[j].row;
T.data[k].value=M.data[j].value;
++k;
}
}
}

void AddMastrix(TSMatrix M,TSMatrix T,TSMatrix &Q) //矩阵相加
{
int index_a,index_b,i=1,j=1,k=1;
Q.mu=M.mu; Q.nu=M.nu;
while (i<=M.tu&&j<=T.tu)
{
index_a=(M.data[i].row)*(M.data[i].col)+M.data[i].col;
index_b=(T.data[j].row)*(T.data[j].col)+T.data[j].col;
if(index_a<index_b)
{
Q.data[k]=M.data[i];
i++;
k++;
}
else if(index_a>index_b)
{
Q.data[k]=T.data[j];
j++;
k++;
}
else if(index_a==index_b)
{
if((M.data[i].value+T.data[j].value)!=0)
{
Q.data[k]=M.data[i];
Q.data[k].value=M.data[i].value+T.data[j].value;
k++;
}
++i;
++j;
}
}
//复制剩余元素
for(;i<=M.tu;++i)
{
Q.data[k]=M.data[i];
k++;
}
for(;j<=T.tu;++j)
Q.data[k++]=T.data[j];
Q.tu=k-1;
}

void Multiply(TSMatrix M,TSMatrix T,TSMatrix &Q) //相乘
{
if(M.nu!=T.mu)
{
cerr<<"两矩阵相乘不合法"<<endl;
return ;
}
int *rowSize=new int[T.mu+1]; //存放每行非零元素的个数
int *rowStart=new int[T.mu+2]; //矩阵每行在三元组开始位置
int *temp=new int[T.nu+1]; //存放结果矩阵中每行的计算结果
int i,Current,k,ROWM,COLM,COLB;
for(i=1;i<=T.mu;i++) rowSize[i]=0;
for(i=1;i<=T.tu;++i) rowSize[T.data[i].row]++;
rowStart[1]=1;
for(i=2;i<=T.mu+1;i++)
rowStart[i]=rowStart[i-1]+rowSize[i-1];
Current=1; k=1;
while (Current<=M.tu)
{
ROWM=M.data[Current].row; //当前三元组数据中元素的行号
for(i=1;i<=T.nu;++i) temp[i]=0;
while (Current<=M.tu&&ROWM==M.data[Current].row)
{
COLM=M.data[Current].col; //当前元素的列号，方便与T矩阵的行号相乘
for(i=rowStart[COLM];i<rowStart[COLM+1];i++) //对应T矩阵中每行的个数
{
COLB=T.data[i].col;
temp[COLB]+=(M.data[Current].value)*(T.data[i].value);
}
Current++;
}
for(i=1;i<=T.nu;i++)
{
if(temp[i]!=0)
{
Q.data[k].row=ROWM;
Q.data[k].col=i;
Q.data[k].value=temp[i];
}
k++;
}
}
Q.mu=M.mu;Q.nu=T.nu;
Q.tu=k-1;
}
int main()
{
TSMatrix T,M,Q,S;
InputMatrix(M);
InputMatrix(T);
cout<<"两矩阵相乘"<<endl;
Multiply(M,T,Q);
Output(Q);
cout<<"两矩阵相加"<<endl;
AddMastrix(M,M,S);
Output(S);
system("pause");
return 0;
}

‘玖’ c++ 实现稀疏矩阵创建（从文件方式）

C++稀疏矩阵转置代码：

#include<iostream>
002usingnamespacestd;
003//三元组
004structTrituple
005{
006introw,col;//非零元素的行号、列号
007intval;//非零元素的值
008};
009//稀疏矩阵类声明
010classSparseMatrix
011{
012//friendostream&operator<<(ostream&,SparseMatrix&);
013//友元函数，输出流操作符重载
014//friendistream&operator>>(istream&,SparseMatrix&);
015//友元函数，输入流操作符重载
016public:
017SparseMatrix(intmaxt=100);//构造函数
018~SparseMatrix();//析构函数
019boolTransposeTo(SparseMatrix&);//转置
020boolTransposeTo_Faster(SparseMatrix&);//快速转置
021voidAddTo(constSparseMatrix&);//加运算
022boolInput();//输入稀疏矩阵
023voidOutput();//输出稀疏矩阵
024private:
025Trituple*data;//存储非零元素三元组的数组
026introws,cols,terms;//矩阵的行数、列数、非零元素个数
027intmaxterms;//数组data的大小
028};
029//构造函数，分配maxt个三元组结点的顺序空间，构造一个空的稀疏矩阵三元组表。
030SparseMatrix::SparseMatrix(intmaxt)
031{
032maxterms=maxt;
033data=newTrituple[maxterms];
034terms=rows=cols=0;
035}//SparseMatrix
036//析构函数，将三元组表结构销毁。
037SparseMatrix::~SparseMatrix()
038{
039if(data!=NULL)delete[]data;
040}//~SparseMatrix
041/*//输出稀疏矩阵
042ostream&operator<<(ostream&out,SparseMatrix&M)
043{
044out<<"rows="<<M.rows<<endl;
045out<<"cols="<<M.cols<<endl;
046out<<"terms="<<M.terms<<endl;
047for(inti=0;i<M.terms;i++)
048out<<"data["<<M.data[i].row<<","<<M.data[i].col<<"]="<<M.data[i].val<<endl;
049returnout;
050};
051//输入稀疏矩阵
052istream&operator>>(istream&in,SparseMatrix&M)
053{
054cout<<"输入稀疏矩阵的行数、列数以及非零元素个数"<<endl;
055in>>M.rows>>M.cols>>M.terms;
056if(M.terms>M.maxterms)exit(1);
057cout<<"terms="<<M.terms<<endl;
058for(inti=0;i<M.terms;i++){
059cout<<"输入非零元素的行号、列号和元素值"<<i+1<<endl;
060in>>M.data[i].row>>M.data[i].col>>M.data[i].val;
061}
062returnin;
063};*/
064//转置，将*this的转置矩阵送入B
065boolSparseMatrix::TransposeTo(SparseMatrix&B)
066{
067if(terms>B.maxterms)
068returnfalse;
069B.rows=cols;
070B.cols=rows;
071B.terms=terms;
072if(terms>0){
073intp=0;
074for(intj=1;j<=cols;j++)
075for(intk=0;k<terms;k++)
076if(data[k].col==j){
077B.data[p].row=j;
078B.data[p].col=data[k].row;
079B.data[p].val=data[k].val;
080p++;
081}
082}
083returntrue;
084}//TransposeTo
085//快速转置，将*this的转置矩阵送入B
086boolSparseMatrix::TransposeTo_Faster(SparseMatrix&B)
087{
088if(terms>B.maxterms)
089returnfalse;
090B.rows=cols;
091B.cols=rows;
092B.terms=terms;
093if(terms>0){
094int*num,*cpot;
095intj,k,p;
096num=newint[cols];
097cpot=newint[cols];
098for(j=0;j<cols;j++)//初始化num[]
099num[j]=0;
100for(k=0;k<terms;k++)//统计每一列的非零元素个数num[]
101num[data[k].col-1]++;
102//求出B中每一行的起始下标cpot[]
103cpot[0]=0;
104for(j=1;j<cols;j++)
105cpot[j]=cpot[j-1]+num[j-1];
106//执行转置操作
107for(k=0;k<terms;k++){
108p=cpot[data[k].col-1]++;//B中的位置
109B.data[p].row=data[k].col;
110B.data[p].col=data[k].row;
111B.data[p].val=data[k].val;
112}
113delete[]num;
114delete[]cpot;
115}
116returntrue;
117}//TransposeTo_Faster
118//输入稀疏矩阵
119boolSparseMatrix::Input()
120{
121cout<<"输入稀疏矩阵的行数、列数以及非零元素个数"<<endl;
122cin>>rows>>cols>>terms;
123if(terms>maxterms){
124cout<<"非零元个数太多！"<<endl;
125returnfalse;
126}
127if(terms==0)
128returntrue;
129cout<<"按行序输入"<<terms<<"个非零元素的三元组"<<endl;
130for(inti=0;i<terms;i++){
131cout<<"输入第"<<i+1<<"个非零元素的行号、列号和元素值"<<endl;
132cin>>data[i].row>>data[i].col>>data[i].val;
133if(data[i].row<1||data[i].row>rows||data[i].col<1||data[i].col>cols){
134cout<<"矩阵输入有误！"<<endl;
135returnfalse;
136}
137}
138returntrue;
139}//Input
140//输出稀疏矩阵
141voidSparseMatrix::Output()
142{
143cout<<"rows="<<rows<<endl;
144cout<<"cols="<<cols<<endl;
145cout<<"terms="<<terms<<endl;
146for(inti=0;i<terms;i++)
147cout<<"data["<<data[i].row<<","<<data[i].col<<"]="<<data[i].val<<endl;
148}//Output
149intmain()
150{
151SparseMatrixM(100);
152if(M.Input()){
153cout<<"原始矩阵："<<endl;
154M.Output();
155SparseMatrixT,S;
156cout<<"转置矩阵："<<endl;
157if(M.TransposeTo(T))
158T.Output();
159if(M.TransposeTo_Faster(S))
160S.Output();
161system("pause");
162return1;
163}
164else
165return0;
166}