稀疏矩阵快速转置算法

⑴ c++ 十字链表实现稀疏矩阵的转置

mplate <class Type>SparseMatrix<Type>
SparseMatrix<Type>::SparseMatrix::FastTranspose()
{
int *RowSize = new int[Cols]; // 统计各列非零元素个数
int *RowStart = new int[Cols]; // 预计转置后各行存放位置
SparseMatrix b; // 存放转置结果
b.Rows = cols; b.cols = Rows; b.Terms = Terms;
if (Terms>0) //nonzero matrix
{
for (int i=0;i<Cols;i++) RowSize[i] = 0; //initialize
for (i=0;i<terms;i++) RowSize[smArray[i].col]++;
//RowStart[i]=starting position of row i in b
RowStart[0]=0;
for (i=1;i<Cols;i++) RowStart[i] = RowStart[i-1]+
RowSize[i-1];
for (i=0;i<Terms;i++) //move from a to b
{
int j=Rowstart[smArray[i].col];
b.smArray[j].row=smArray[i].col;
b.smArray[j].col= smArray[i].row;
b.smArray[j].value= smArray[i].value;
RowStart[smArray[i].col]++;
} //end of for
}
delete [ ]Rowsize;
delete [ ]Rowstart;
return b;
}
另外,站长团上有产品团购,便宜有保证

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

#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();
}

⑶ 修改程序 利用三元组表快速转置矩阵

//重写了，vc6下编译通过
//作者：qmroom
//2008-11-049:00
//blog：http://blog.csdn.net/qmroom
//Email：qmroom#126.com#=@

#include"stdafx.h"
#include<iostream>
#include<fstream>
#include<vector>
#include<algorithm>
usingnamespacestd;

structTrituple
{
introw;
intcol;
doublevalue;
Trituple():row(-1),col(-1),value(0){}
//friendostream&operator<<(ostream&os,constTrituple&tpl);
};

ostream&operator<<(ostream&os,constTrituple&tpl)
{
os<<tpl.row<<"\t"<<tpl.col<<"\t"<<tpl.value;
returnos;
}

structltTrituple
{
booloperator()(constTrituple&pos1,constTrituple&pos2)const
{
if(pos1.row!=pos2.row)
returnpos1.row<pos2.row;
returnpos1.col<pos2.col;
}
};

typedefvector<Trituple>VT;
typedefvector<Trituple>::const_iteratorIterator;

intmain(intargc,char*argv[])
{
Tritupletpl;
intnTemp;
VTvt;
Iteratoritr;

ifstreamfin("Trituple.txt");
while(!fin.eof())
{
fin>>tpl.row>>tpl.col>>tpl.value;
if(!fin.eof())
vt.push_back(tpl);
}
fin.close();

for(itr=vt.begin();itr!=vt.end();itr++)
{
nTemp=itr->row;
(int)(itr->row)=itr->col;
(int)(itr->col)=nTemp;
}

sort(vt.begin(),vt.end(),ltTrituple());
(vt.begin(),vt.end(),ostream_iterator<Trituple>(cout,"\n"));

return0;
}

⑷ C语言编写稀疏矩阵的加，减，乘和转置，要求用矩阵输出

#include <stdio.h>
#include <iostream>
#include <math.h>
#include <stdlib.h>
using namespace std;
#define Max 12500
#define Elemtype int
typedef struct {
int i ,j ;
Elemtype e;
}Triple;
typedef struct {
Triple data[Max+1];
int mu,nu,tu;
}Tsmatrix;
int Createsmatrix(Tsmatrix &M)
{ int n;
cout<<"请输入稀疏矩阵的元素个数n"<<endl;
cin>>n;
M.tu=n;
cout<<"请输入稀疏矩阵的行数，列数："<<endl;
cin>>M.mu>>M.nu;
int i;
for(i=1;i<=n;i++){
cout<<"请输入稀疏矩阵的行下标和列下标，及数据;"<<endl;
cin>>M.data[i].i>>M.data[i].j>>M.data[i].e ;
}
return 1;
}
int Transpose(Tsmatrix M , Tsmatrix &T)
{
T.mu=M.nu; T.nu=M.mu ; T.tu=M.tu;
if(T.tu){
int col , p , 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 1;
}
int Print(Tsmatrix M)
{

int i;int p=1;
{
for (i=1;i<=M.mu*M.nu;i++)
if(i==((M.data[p].i-1)*M.nu+M.data[p].j))
{
if(M.data[p].j==M.nu)
{ cout<<M.data[p].e<<endl; p++;}
else
{ cout<<M.data[p].e<<" "; p++;}
}
else if(i%M.nu==0) cout<<"0"<<endl;
else cout<<"0 ";
}
cout<<"\n"<<endl;
return 1;
}
int Addsmatrix(Tsmatrix a, Tsmatrix b, Tsmatrix &c)
{
int s=1,t=1,k=1; Elemtype temp;
if(a.mu!=b.mu||a.nu!=b.nu) return 0;
if(a.tu == 0) {c=b; return 1;}
if(b.tu==0) {c=a; return 1;}
if(a.tu==0 && b.tu==0) { c=a; return 1;}
while(!(s>a.tu && t>b.tu))
{
if(a.data[s].i>b.data[t].i)
{
c.data[k]=b.data[t];
k++ ;t++;
}
if(a.data[s].i<b.data[t].i)
{
c.data[k]=a.data[s];
k++ ;s++;
}
if(a.data[s].i==b.data[t].i)
{
if(a.data[s].j>b.data[t].j)
{
c.data[k]=b.data[t];
k++; t++;
}
if(a.data[s].j<b.data[t].j)
{
c.data[k]=a.data[s];
k++; s++;
}
if(a.data[s].j==b.data[t].j)
{
temp=a.data[s].e+b.data[t].e;
if(temp==0){s++;t++;}
else
{ c.data[k].e=temp;c.data[k].i=a.data[s].i;c.data[k].j=a.data[s].j;
s++;t++;k++;
}
}
}//if
if(s>a.tu&&t<=b.tu)
{
while(t<=b.tu)
{
c.data[k]=b.data[t];
k++; t++;
}
}
if(t>b.tu&&s<=a.tu)
{
while(s<=a.tu)
{
c.data[k]=a.data[s];
k++; s++;
}
}
}//while
c.tu=k-1; c.mu=a.mu; c.nu=a.nu;
}
return 1;int main()
{

Tsmatrix a,b,c;
Createsmatrix( a);
Createsmatrix( b);
Print(a);
Print(b);
Addsmatrix(a,b,c);
Print(c);
return 1;
}

⑸ 稀疏矩阵的转置运算用C语言

#include<string.h>

#include<ctype.h>
#include<malloc.h> // malloc()等
#include<limits.h> // INT_MAX等
#include<stdio.h> // EOF(=^Z或F6),NULL
#include<stdlib.h> // atoi()
#include<io.h> // eof()
#include<math.h> // floor(),ceil(),abs()
#include<process.h> // exit()
#include<iostream.h> // cout,cin
// 函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
// #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行
typedef int Status; // Status是函数的类型,其值是函数结果状态代码，如OK等
typedef int Boolean; // Boolean是布尔类型,其值是TRUE或FALSE
typedef int ElemType;
// c5-2.h 稀疏矩阵的三元组顺序表存储表示
#define MAXSIZE 100 // 非零元个数的最大值
struct Triple
{
int i,j; // 行下标,列下标
ElemType e; // 非零元素值
};
struct TSMatrix
{
Triple data[MAXSIZE+1]; // 非零元三元组表,data[0]未用
int mu,nu,tu; // 矩阵的行数、列数和非零元个数
};
// bo5-2.cpp 三元组稀疏矩阵的基本操作,包括算法5.1(9个)
Status CreateSMatrix(TSMatrix &M)
{ // 创建稀疏矩阵M
int i,m,n;
ElemType e;
Status k;
printf("请输入矩阵的行数,列数,非零元素数：");
scanf("%d,%d,%d",&M.mu,&M.nu,&M.tu);
M.data[0].i=0; // 为以下比较顺序做准备
for(i=1;i<=M.tu;i++)
{
do
{
printf("请按行序顺序输入第%d个非零元素所在的行(1～%d),列(1～%d),元素值：",i,M.mu,M.nu);
scanf("%d,%d,%d",&m,&n,&e);
k=0;
if(m<1||m>M.mu||n<1||n>M.nu) // 行或列超出范围
k=1;
if(m<M.data[i-1].i||m==M.data[i-1].i&&n<=M.data[i-1].j) // 行或列的顺序有错
k=1;
}while(k);
M.data[i].i=m;
M.data[i].j=n;
M.data[i].e=e;
}
return OK;
}
void DestroySMatrix(TSMatrix &M)
{ // 销毁稀疏矩阵M
M.mu=0;
M.nu=0;
M.tu=0;
}
void PrintSMatrix(TSMatrix M)
{ // 输出稀疏矩阵M
int i;
printf("%d行%d列%d个非零元素。\n",M.mu,M.nu,M.tu);
printf("行 列 元素值\n");
for(i=1;i<=M.tu;i++)
printf("%2d%4d%8d\n",M.data[i].i,M.data[i].j,M.data[i].e);
}
Status CopySMatrix(TSMatrix M,TSMatrix &T)
{ // 由稀疏矩阵M复制得到T
T=M;
return OK;
}
int comp(int c1,int c2) // 另加
{ // AddSMatrix函数要用到
int i;
if(c1<c2)
i=1;
else if(c1==c2)
i=0;
else
i=-1;
return i;
}
Status AddSMatrix(TSMatrix M,TSMatrix N,TSMatrix &Q)
{ // 求稀疏矩阵的和Q=M+N
Triple *Mp,*Me,*Np,*Ne,*Qh,*Qe;
if(M.mu!=N.mu)
return ERROR;
if(M.nu!=N.nu)
return ERROR;
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: switch(comp(Mp->j,Np->j)) // M、N矩阵当前非零元素的行相等,继续比较列
{
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;
}
Status SubtSMatrix(TSMatrix M,TSMatrix N,TSMatrix &Q)
{ // 求稀疏矩阵的差Q=M-N
int i;
for(i=1;i<=N.tu;i++)
N.data[i].e*=-1;
AddSMatrix(M,N,Q);
return OK;
}
Status MultSMatrix(TSMatrix M,TSMatrix N,TSMatrix &Q)
{ // 求稀疏矩阵的乘积Q=M*N
int i,j,h=M.mu,l=N.nu,Qn=0;
// h,l分别为矩阵Q的行、列值,Qn为矩阵Q的非零元素个数，初值为0
ElemType *Qe;
if(M.nu!=N.mu)
return ERROR;
Q.mu=M.mu;
Q.nu=N.nu;
Qe=(ElemType *)malloc(h*l*sizeof(ElemType)); // Qe为矩阵Q的临时数组
// 矩阵Q的第i行j列的元素值存于*(Qe+(i-1)*l+j-1)中，初值为0
for(i=0;i<h*l;i++)
*(Qe+i)=0; // 赋初值0
for(i=1;i<=M.tu;i++) // 矩阵元素相乘，结果累加到Qe
for(j=1;j<=N.tu;j++)
if(M.data[i].j==N.data[j].i)
*(Qe+(M.data[i].i-1)*l+N.data[j].j-1)+=M.data[i].e*N.data[j].e;
for(i=1;i<=M.mu;i++)
for(j=1;j<=N.nu;j++)
if(*(Qe+(i-1)*l+j-1)!=0)
{
Qn++;
Q.data[Qn].e=*(Qe+(i-1)*l+j-1);
Q.data[Qn].i=i;
Q.data[Qn].j=j;
}
free(Qe);
Q.tu=Qn;
return OK;
}
Status TransposeSMatrix(TSMatrix M,TSMatrix &T)
{ // 求稀疏矩阵M的转置矩阵T。算法5.1
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;
}
Status FastTransposeSMatrix(TSMatrix M,TSMatrix &T)
{ // 快速求稀疏矩阵M的转置矩阵T。算法5.2
int p,q,t,col,*num,*cpot;
num=(int *)malloc((M.nu+1)*sizeof(int)); // 生成数组（[0]不用）
cpot=(int *)malloc((M.nu+1)*sizeof(int)); // 生成数组（[0]不用）
T.mu=M.nu;
T.nu=M.mu;
T.tu=M.tu;
if(T.tu)
{
for(col=1;col<=M.nu;++col)
num[col]=0; // 设初值
for(t=1;t<=M.tu;++t) // 求M中每一列含非零元素个数
++num[M.data[t].j];
cpot[1]=1;
for(col=2;col<=M.nu;++col) // 求第col列中第一个非零元在T.data中的序号
cpot[col]=cpot[col-1]+num[col-1];
for(p=1;p<=M.tu;++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].e=M.data[p].e;
++cpot[col];
}
}
free(num);
free(cpot);
return OK;
}
void main()
{
TSMatrix A,B;
printf("创建矩阵A: ");
CreateSMatrix(A);
PrintSMatrix(A);
FastTransposeSMatrix(A,B);
printf("矩阵B(A的快速转置): ");
PrintSMatrix(B);
DestroySMatrix(A);
DestroySMatrix(B);
}

稀疏矩阵三元组转置，你参考下

⑹ 采用基于稀疏矩阵的三元组压缩存储方法，实现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;
}