矩阵转置实验报告doc.docx
《矩阵转置实验报告doc.docx》由会员分享，可在线阅读，更多相关《矩阵转置实验报告doc.docx（14页珍藏版）》请在冰豆网上搜索。
矩阵转置实验报告doc
矩阵转置实验报告
篇一：
实验报告矩阵快速转置
实验报告
实验项目名称：
实现矩阵的快速转置的操作所属课题名称：
数据结构
实验类型：
验证实验
实验日期：
XX/12/20
学院：
数学与信息科学学院
专业:
信息与计算科学
班级:
082班
姓名：
李晓璐
学号：
0801214037
实验稀疏矩阵的快速转置操作
一、实验目的
1、了解稀疏矩阵的三元组存储形式。
2、熟悉掌握三元表存储矩阵的转置算法。
二、实验环境
硬件：
PC微型计算机、256M以上内存，40G以上硬盘。
软件：
WindowsXP，TurboC/C++
三、实验内容
转置运算是一种最简单的矩阵运算。
对于一个m*n的矩阵M，它的转置矩阵T是一个n*m的矩阵。
假设a和b是TSMatrix型的变量，分别表示矩阵M和T。
按照a.data中三元组的次序进行转置，并将转置后的三元组置入b中恰当的位置。
实现由a得到b的方式如下。
在转置前，应先求得M的每一列中非零元的个数，进而求得每一列的第一个非零元在b.data中应有的位置。
在此，设num和cpot两个向量，num[col]表示矩阵M中第col列中非零元的个数，cpot[col]指示M中第col列的第一个非零元在b.data中应有的位置。
显然有：
cpot[1]=1;
cpot[col]=cpot[col-1]+num[col-1]
四、实验步骤
1、本实验的程序清单如下。
“TSMatrix.h”
#defineMAXSIZE12500
#defineOK1
#defineERROR0
#defineTRUE1
#defineFALSE0
#defineOVERFLOW0
typedefintStatus;
typedefintElemType;
structTriple
{
inti,j;
ElemTypee;
};
classTSMatrix
{
public:
TSMatrix（）{mu=0;nu=0;tu=0;};
TSMatrix（int,int,int）;
~TSMatrix（）{};
voidsetTSMatrix（）;
StatusPrintSMatrix（）;
StatusTransposeSMatrix（TSMatrix&T）;
StatusFastTransposeSMatrix（TSMatrix&T）;
private:
Tripledata[MAXSIZE+1];intmu,nu,tu;
};
TSMatrix:
:
TSMatrix（inta,intb,intc）
{
mu=a;nu=b;tu=c;
for（intp=1;p {
printf（"依次输入稀疏矩阵第%d个非零元的行号,列号,元素:
",p）;scanf（"%d,%d,%d",&data[p].i,&data[p].j,&data[p].e）;
}
}
voidTSMatrix:
:
setTSMatrix（）
{
cout cin>>mu;
cout cin>>nu;
cout cin>>tu;
for（intp=1;p {
printf（"依次输入稀疏矩阵第%d个非零元的行号,列号,元素:
",p）;scanf（"%d,%d,%d",&data[p].i,&data[p].j,&data[p].e）;
}
}
StatusTSMatrix:
:
PrintSMatrix（）
{
intk=1,t=0;
for（intp=1;p {
for（intq=1;q {
if（p==data[k].i&&q==data[k].j&&k {
cout.width（3）;
cout.setf（ios:
:
left）;
cout cout.unsetf（ios:
:
left）;
k++;
}
else
{
cout.width（3）;
cout.setf（ios:
:
left）;
cout cout.unsetf（ios:
:
left）;
}
}
cout }
returnOK;
}
StatusTSMatrix:
:
TransposeSMatrix（TSMatrix&T）
{
intcol,p,q;
T.mu=nu;
T.nu=mu;
T.tu=tu;
if（T.tu）
{
q=1;
for（col=1;col for（p=1;p if（data[p].j==col）
{
T.data[q].i=data[p].j;
T.data[q].j=data[p].i;
T.data[q].e=data[p].e;
++q;
}
}
returnOK;
}
StatusTSMatrix:
:
FastTransposeSMatrix（TSMatrix&T）
{
intcol,p,q,t;
int*num=newint[10],*cpot=newint[10];
num=（int*）malloc（tu*sizeof（int））;
cpot=（int*）malloc（tu*sizeof（int））;
T.mu=nu;
T.nu=mu;
T.tu=tu;
if（T.tu）
{
for（col=1;col for（t=1;t cpot[1]=1;
for（col=2;col {
col=data[p].j;
q=cpot[col];
T.data[q].i=data[p].j;
T.data[q].j=data[p].i;
T.data[q].e=data[p].e;
++cpot[col];
}
}
returnOK;
}
“TSMstrixMain.cpp”
#include"iostream"
usingnamespacestd;
#include"TSMatrix.h"
intmain（）
{
TSMatrixM,T;
cout M.setTSMatrix（）;
M.PrintSMatrix（）;
M.TransposeSMatrix（T）;
cout T.PrintSMatrix（）;
M.FastTransposeSMatrix（T）;
cout T.PrintSMatrix（）;
return0;
篇二：
稀疏矩阵三元组实现矩阵转置算法实验报告
实验三稀疏矩阵的三元组表示实现矩阵转置算法
学院专业班
学号姓名一．实习目的
1.掌握稀疏矩阵的三元组顺序表存储表示；
2.掌握稀疏矩阵三元组表示的传统转置算法的实现；
3.掌握稀疏矩阵三元组表示的快速转置算法的实现；
二．实习内容
1.稀疏矩阵的按三元组形式输入，即按行序输入非零元的行号、列号、值，实现传统转置
算法，输出按通常的阵列形式输出。
2.稀疏矩阵的按三元组形式输入，即按行序输入非零元的行号、列号、值，实现快速转置
算法，输出按通常的阵列形式输出。
三．实验步骤
1.三元组的定义
#defineMAX_SIZE100//非零元个数的最大值
structTriple
{
inti,j;//行下标,列下标
ElemTypee;//非零元素值
};
structTSMatrix
{
structTripledata[MAX_SIZE+1];//非零元三元组表，data[0]未用
intmu,nu,tu;//矩阵的行数、列数和非零元个数
};
2.创建稀疏矩阵M（按三元组形式输入，即按行序输入非零元的行号、列号、值）
3.编写三元组传统转置函数。
4.编写三元组快速转置函数。
4..主函数
（1）程序代码
#include"stdio.h"
#include"stdlib.h"
#defineMAX_SIZE100//非零元个数的最大值
typedefintElemType;
structTriple
{
inti,j;//行下标,列下标
ElemTypee;//非零元素值
};
structTSMatrix
structTripledata[MAX_SIZE+1];//非零元三元组表，data[0]未用intmu,nu,tu;//矩阵的行数、列数和非零元个数
};
intCreateSMatrix（TSMatrix&M）
{//创建稀疏矩阵M
inti,m,n;
ElemTypee;
intk;
printf（"请输入矩阵的行数,列数,非零元素数：
"）;
scanf（"%d,%d,%d",&M.mu,&M.nu,&M.tu）;
if（M.tu>MAX_SIZE）
return-1;
M.data[0].i=0;//为以下比较顺序做准备
for（i=1;i {
do
{
printf（"请按行序顺序输入第%d个非零元素所在的行（1～%d）,列（1～%d）,元素值:
",i,M.mu,M.nu）;
scanf（"%d,%d,%d",&m,&n,&e）;//输入非零元的行号、列号、元素值k=0;
if（mM.mu||nM.nu）//行或列超出范围
k=1;
if（m k=1;
}while（k）;
M.data[i].i=m;//将m,n,e填入M
M.data[i].j=n;
M.data[i].e=e;
}
return1;
}
voidPrintSMatrix（TSMatrixM）
{//按矩阵形式输出M
inti,j,k=1;
Triple*p=M.data;
p++;//p指向第1个非零元素
for（i=1;i for（j=1;j if（ki==i&&p->j==j）
//p指向非零元，且p所指元素为当前处理元素
{
printf（"%3d",p->e）;//输出p所指元素的值
p++;//p指向下一个元素
k++;//计数器+1
}
else//p所指元素不是当前处理元素
printf（"%3d",0）;//输出0
printf（"\n"）;
}
}
voidTransposeSMatrix（TSMatrixM,TSMatrix&T）
{//求稀疏矩阵M的转置矩阵T。
intp,q,col;
T.mu=M.nu;
T.nu=M.mu;
T.tu=M.tu;
if（T.tu）
{
q=1;
for（col=1;col for（p=1;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;
}
}
}
voidFastTransposeSMatrix（TSMatrixM,TSMatrix&T）
{//快速求稀疏矩阵M的转置矩阵T。
算法5.2改
intp,q,t,k,col,*num,*cpot;
num=（int*）malloc（（M.nu+1）*sizeof（int））;//存M每列（T每行）非零元素个数（[0]不用）cpot=（int*）malloc（（M.nu+1）*sizeof（int））;//存T每行的下1个非零元素的存储位置（[0]不用）
T.mu=M.nu;//给T的行、列数与非零元素个数赋值
T.nu=M.mu;
T.tu=M.tu;
if（T.tu）//是非零矩阵
{
for（col=1;col num[col]=0;//计数器初值设为0
for（t=1;t {k=M.data[t].j;++num[col];}
cpot[1]=1;//T的第1行的第1个非零元在T.data中的序号为1
for（col=2;col cpot[col]=cpot[col-1]+num[col-1];
//求T的第col行的第1个非零元在T.data中的序号
printf（"num数组的值为：
\n"）;
for（col=1;col printf（"%4d",num[col]）;
printf（"\n"）;
printf（"转置前cpot数组的值为：
\n"）;
for（col=1;col printf（"%4d",cpot[col]）;
printf（"\n"）;
for（p=1;p {
col=M.data[p].j;//求得在M中的列数
q=cpot[M.data[p].j];//q指示M当前的元素在T中的序号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];//T第col行的下1个非零元在T.data中的序号
}
}
printf（"转置后cpot数组的值为：
\n"）;
for（col=1;col printf（"%4d",cpot[col]）;
printf（&
quot;\n"）;
free（num）;
free（cpot）;
}
voidmain（）
{
TSMatrixA,T;
printf（"创建矩阵A:
"）;
CreateSMatrix（A）;
PrintSMatrix（A）;
TransposeSMatrix（A,T）;
printf（"传统矩阵转置程序执行后的矩阵t（A的转置）:
\n"）;PrintSMatrix（T）;
FastTransposeSMatrix（A,T）;
printf（"快速矩阵转置程序执行后的矩阵t（A的转置）:
\n"）;PrintSMatrix（T）;
}
（2）调试程序
（3）运行程序（截图）
四．实习小结
自己写
篇三：
矩阵转置及相加实验报告
一、实验内容和要求
1、稀疏矩阵A,B均采用三元组表示，验证实现矩阵A快速转置算法，设计并验证A,B相加得到矩阵C的算法。
（1）从键盘输入矩阵的行数和列数，随机生成稀疏矩阵。
（2）设计算法将随机生成的稀疏矩阵转换成三元组顺序表示形式存储。
（3）设计算法将快速转置得到的与相加得到的三元组顺序表分别转换成矩阵形
式。
（4）输出随机生成的稀疏矩阵A,B及其三元组顺序表、快速转置得到的与相加得
到的三元组顺序表及其矩阵形式。
二、实验过程及结果
一、需求分析
1、将随机生成的数定义为int型（为方便起见设定范围为-20至20（不含0），可修改），三元组存储的元素分别为非零元的行下标、列下标及该位置的元素值，零元不进行存储。
实际上在生成稀疏矩阵时是随机选取一些位置生成非零元然后存入三元组中。
2、从键盘输入矩阵的行数和列数后应能输出三元组顺序表及相应矩阵（按行和列排列形式输出）。
3、程序能实现的功能包括：
①随机产生稀疏矩阵；②输出阵列形式的矩阵；③输出三元组顺序表；④将矩阵快速转置；⑤将两个稀疏矩阵相加生成新的矩阵。
二、概要设计
1、稀疏矩阵的抽象数据类型定义：
ADTTSMatrix{
数据对象：
D={aij|i=1,2,…,m,j=1,2,…,n;
Ai,j∈ElemSet,m和n分别称为矩阵的行数和列数}
数据关系：
R={Row，Col}
Row={|1≤i≤m,1≤j≤n-1}
Col={|1≤i≤m-1,1≤j≤n}
基本操作:
CreateTSMatrix（&M）
操作结果：
创建矩阵M
PrintTSMatrix（M）
初始条件：
矩阵M已存在
操作结果：
输出矩阵M中三元组形式的非零元素
PrintTSMatrix1（M）
初始条件：
矩阵M已存在
操作结果：
以阵列形式输出矩阵
UnZore（M,row,col）
初始条件：
矩阵M已存在
操作结果：
若位置（row,col）处存在非零元素，则返回该元素存储在矩阵中的序号
TSMatrix_Add（M,N,&Q）
初始条件：
矩阵M，N已存在
操作结果：
将矩阵M,N相加得到Q并返回矩阵Q
FastTransposeSMatrix（M,&N）
初始条件：
矩阵M已存在
操作结果：
将矩阵M快速转置得到转置矩阵N并返回
}ADTTSMatrix；
⒊本程序模块结构
⑴主函数模块
voidmain（）{
初始化迷矩阵；
创建矩阵并输出；
将矩阵转置并输出；
将矩阵相加并输出结果；
｝
三、详细设计
1、基本数据类型操作
⑴typedefintElemType;
typedefstruct{
inti,j;
ElemTypee;
}Triple;//数据类型三元组
typedefstruct{
Tripledata[maxsize+1];//矩阵大小
intmu,nu,tu;//
}TSMatrix;//矩阵抽象数据类型
2、参数设置：
#definemaxsize10000
//----------基本操作的算法描述--------------------
StatusCreateTSMatrix（TSMatrix*M）{
//创建一个随机矩阵（data[0]未用）
srand（（int）time（NULL））;
printf（"PleaseInputTheLinesAndColumnsOfTheMatrix:
\n"）;printf（"...（矩阵的期望规格大于4*5（或5*4））...\n"）;
scanf（M->mu，M->nu）;
for（m=0;mmu;m++）{
for（n=0;nnu;n++）{
k[m][n]=rand（）%20;
if（k[m][n]==0）{
if（rand（）%2）
M->data[p].e=rand（）%20+1;
else
M->data[p].e=rand（）%20-20;
M->data[p].i=m+1;
M->data[p].j=n+1;
p++;
}
}
}
M->tu=p-1;//p从1开始，非零元个数刚好等于p-1
returnOK;
}
voidPrintTSMatrix（TSMatrixM）{
//输出矩阵的三元组顺序表
if（M.tu==0）
printf（"无非零元!
\n"）;
else{
printf（"该矩阵的行数为%d、列数为%d、非零元素个数为%d.\n非零元的坐标及值:
\n\n",M.mu,M.nu,M.tu）;
printf（"行列元素值\n"）;
for（i=1;i printf（"%4d%4d%6d\n",M.data[i].i,M.data[i].j,M.data[i].e）;}
printf（"\n"）;
}
}
voidPrintTSMatrix1（TSMatrixM）{
//输出矩阵的阵列形式
printf（"阵列形式为:
\n"）;
for（i=1;i for（j=1;j if（ki==i&&p->j==j）{
printf（"%4d",p->e）;//data[0]未用，p从data[1]开始p++;
k++;
}
else
printf（"%4d",0）;
printf（"\n"）;
}
printf（"\n"）;
}
intUnZore（TSMatrixM,introw,intcol）{
while（order if（M.data[order].i==row&&M.data[order].j==col）//order从1开始returnorder;
order++;
}
return0;
}
StatusTSMatrix_Add（TSMatrixM,TSMatrixN,TSMatrix*Q）{
//矩阵相加得到新的矩阵，order从1开始
if（M.mu==N.mu&&M.nu==N.nu）{
for（row=1;row for（col=1;col order1=UnZore（M,row,col）;
order2=UnZore（N,row,col）;
if（order1&&order2）{
Q->data[order].i=row;
Q->data[order].j=col;
Q->data[order].e=M.data[order1].e+N.data[order2].e;order++;
}
elseif（order1&&（!
order2））{
Q->data[order].e=M.data[order1].e;
Q->data[order].i=M.data[order1].i;
Q->data[order].j=M.data[order1].j;
order++;
}
elseif（（!
order1）&&order2）{
Q->data[order].e=N.data[order2].e;
Q->data[order].i=N.data[order2].i;
Q->data
升级会员 