下三角矩阵的压缩存储(实验报告)

数据结构实验五矩阵的压缩存储与运算学习资料

数据结构实验五矩阵的压缩存储与运算第五章矩阵的压缩存储与运算【实验目的】1. 熟练掌握稀疏矩阵的两种存储结构(三元组表和十字链表)的实现；2. 掌握稀疏矩阵的加法、转置、乘法等基本运算；3. 加深对线性表的顺序存储和链式结构的理解。

第一节知识准备矩阵是由两个关系（行关系和列关系）组成的二维数组，因此对每一个关系上都可以用线性表进行处理；考虑到两个关系的先后，在存储上就有按行优先和按列优先两种存储方式，所谓按行优先，是指将矩阵的每一行看成一个元素进行存储；所谓按列优先，是指将矩阵的每一列看成一个元素进行存储；这是矩阵在计算机中用一个连续存储区域存放的一般情形，对特殊矩阵还有特殊的存储方式。

一、特殊矩阵的压缩存储1. 对称矩阵和上、下三角阵若n阶矩阵A中的元素满足= （0≤i，j≤n-1 ）则称为n阶对称矩阵。

对n阶对称矩阵，我们只需要存储下三角元素就可以了。

事实上对上三角矩阵（下三角部分为零）和下三角矩阵（上三角部分为零），都可以用一维数组ma[0.. ]来存储A的下三角元素（对上三角矩阵做转置存储），称ma为矩阵A的压缩存储结构，现在我们来分析以下，A和ma之间的元素对应放置关系。

问题已经转化为：已知二维矩阵A[i，j]，如图5-1，我们将A用一个一维数组ma[k]来存储，它们之间存在着如图5-2所示的一一对应关系。

任意一组下标(i,j)都可在ma中的位置k中找到元素m[k]= ；这里：k=i(i+1)/2+j (i≥j)图5-1 下三角矩阵a00 a10 a11 a20 … an-1,0 … an-1,n-1k= 0 1 2 3 …n(n-1)/2 …n(n+1)/2-1图5-2下三角矩阵的压缩存储反之，对所有的k=0,1，2,…,n(n+1)/2-1，都能确定ma[k]中的元素在矩阵A中的位置（i,j）。

这里，i=d-1，（d是使sum= > k的最小整数），j= 。

2. 三对角矩阵在三对角矩阵中，所有的非零元素集中在以主对角线为中心的带内状区域中，除了主对角线上和直接在对角线上、下方对角线上的元素之外，所有其它的元素皆为零，见图5-3。

规律分布特殊矩阵的压缩存储

三角矩阵大体分为三类:下三角矩阵、上三角矩阵、对称矩阵。对于一个 n 阶矩阵 A 来说:若当 i <j 时,有 a ij =c(典型情况 c=0 ),则称此矩阵为下三角矩阵;若当 i>j 时,有 aij =c(典型情况 c=0 ),则称此矩阵为上三角矩阵;若矩阵中的所有元素均满足 aij =aji,则称此矩阵为对称矩阵。
【本节要点】
= Loc( A[ 1 ][ 1 ])+( 2 ( i-1 )+ j -1)*size
1、规律分布特殊矩阵的压缩存储原则：按规律存放非零元素；
2、按规律找出地址计算公式
思考题：类同按行为主序，请给出按列或按行为主序条件下上三角矩阵以及对称矩阵的相关推导。 2 .带状矩阵
( 1 )带状矩阵描述:在矩阵中的所有非零元素都集中在以主对角线为中心的带状区域中。其中最常见的是三对角带状矩阵,如图 3 所示。
a11 A12
a21 A22 a23
A32 a33 a34
( 2 )三对角带状矩阵特点
数组 C
a11 a12 a21 a22 a23 a31 … ann
Loc(i,j)
1 2 3 4 5 6 … 3n-2
图 4 带状矩阵的压缩形式
②确定非零元素在一维数组空间中的地址 Loc ( A[ i][ j])= Loc ( A[ 1 ][ 1 ])+(前 i-1 行非零元素个数+第 i 行中 aij 前非零元素个
数)*size 前 i-1 行元素个数=3 ×( i-1 )- 1 (因为第 1 行只有 2 个非零元素); 第 i 行中 ai j 前非零元素个数=j-i +1 ,其中
j-i=
-1 ( j<i) 0 (j=i) 1 (j>i)

二维数组的压缩存储矩阵

数据结构实验报告学号：2015111898姓名：许明华专业：计算机科学与技术知识范畴：数组与广义表完成日期：2017年04月21日实验题目：基于压缩存储的半三角矩阵乘法运算的实现实验内容及要求：已知两个n阶下半三角矩阵的乘积仍为n阶下半三角矩阵。

编程输入两个n阶下半三角矩阵，输出这两个矩阵的乘积。

要求n阶下半三角矩阵采用一维数组压缩存储（即只存储下半三角）。

程序先从键盘(或字符文件)输入n值，建立三个矩阵的一维数组动态存储结构，然后从键盘(或字符文件)输入两个半三角矩阵，最后输出计算结果到屏幕上(或另一个字符文件中)。

例如：键盘输入为：312 34 5 6-1-2 -3-4 -5 -6则输出为：-1-8 -9-38 -45 -36实验目的：掌握半三角矩阵的顺序存储结构。

数据结构设计简要描述：序言：这是本学期第五个实验，本实验是要求我们将两个二维半三角矩阵压缩存储为一维矩阵，并对其进行乘法操作，得到一个一维的压缩存储矩阵，并将其打印输出；数据结构简单设计：本实验主要可分为两个大的模块（压缩存储矩阵、压缩矩阵相乘）。

第一，我们通过键盘键入一个数组的阶数，然后输入两个半三角矩阵，，但是这两个半三角矩阵要进行压缩存储为一维矩阵，关键操作即（m = （i*（i+1））/2 + j），即可将二维下标转化为一维下标；第二，运用公式 i]][[*]][[jjkbkia来进行相乘操作，求得两个下三角矩阵的乘积。

算法设计简要描述：1，通过（m = （i*（i+1））/2 + j）将二维下标转化为一维下标进行输入，得到压缩存储矩阵；2，运用公式 i]][[*]][[jjkbkia进行乘积操作，但是乘数矩阵下标和结果矩阵的下标并没有同步，所以运用三个公式来进行分离操作，m1 = （i*（i+1））/2 + k；m2 = (k*（k+1））/2 + j；m = （i*（i+1））/2 + j；c [m] += a[m1]*b[m2];这样即能实现相乘的操作，但是每一次的c[m]没有进行初始化，所以在每一次得到m值后，进行操作c[m] = 0;输入/输出设计简要描述：输入：1，输入下三角存储矩阵的阶数n；2，输入第一个下三角矩阵，如1 2 3 4 5 6；3，输入第二个下三角矩阵，如-1 -2 -3 -4 -5 -6；输出：1，输入2操作后，按存储矩阵格式输出打印第一个下三角矩阵；2，输入3操作后，按存储矩阵格式输出打印第二个下三角矩阵，并输出打印两个矩阵的乘积矩阵编程语言说明：1，编程软件，CodeBlocks 16.0；2，代码均用C语言实现；3，输入输出采用C语言的printf和scanf函数；4，程序注释采用C/C++规范；主要函数说明：void input_Arr( int, int );//输入半三角矩阵声明void print( int, int );//输出打印半三角矩阵声明int print_Array( int, int, int, int);//两个半三角矩阵的乘法运算声明程序测试简要报告：见截图：源程序代码：#include<stdio.h>//函数声明部分void input_Arr( int, int );//输入半三角矩阵声明void print( int, int );//输出打印半三角矩阵声明int print_Array( int, int, int, int);//两个半三角矩阵的乘法运算声明//输入半三角矩阵void input_Arr(int a[], int n){int m;printf("请输入数组：\n");for(int i = 0 ; i < n ; i ++){for(int j = 0 ; j <= i ; j ++)//这里在存储时我只存储了下三角对应的数组元素，，所以是j<=i,而不是j<n{m = (i*(i + 1))/2 + j;//这一步操作是关键所在，因为要将二维数组压缩存储为一维数组的话，我们来看，//二维数组的下标为i和j，但是一维数组的下标只有一个，怎么办呢，//这时候我们就可以根据公式来将二维数组的下标转化为对应的一维数组的下标，所得到的就是对应位置的对应下标scanf("%d",&a[m]); //输入对应的下三角矩阵}}}//输出打印半三角矩阵void print(int a[], int n){int m = 0;for(int i = 0 ; i < n ; i ++){for(int j = 0 ; j <= i ; j ++){m = (i*(i + 1))/2 + j;//打印操作，同上面printf("%d ",a[m]);}printf("\n");}}//两个半三角矩阵的乘法运算int print_Array(int a[], int b[], int c[], int n){int i = 0, j = 0;int k, m, m1, m2 ;//k为进行乘法操作过程的中间变量，m为乘积过后的一维压缩数组的下标，m1为第一个数组的压缩存储的下标，m2为第二个数组的压缩存储的下标for( i = 0; i < n ; i ++){for( j = 0; j <= i ; j ++)//限定在下三角元素中进行{m = (i*(i + 1))/2 + j;//将二维下标转化为压缩存储的一维下标c[m] = 0; //这一步很重要，我想了很久才想到这一步的，就是每一次将c[m]的初值赋为0，因为后面要执行c[m] +=操作，如果不仅赋初值的话，每次的第一个c[m]就是没有进行初始化，//那它就是一个无穷大的数，得出来的乘积之和就是一个无穷大的数for(k = j ; k <= i ; k ++)//由于是下三角进行相乘，所以所有的上三角元素都为零，不需要再进行乘积操作，{m1 = (i*(i + 1))/2 + k;//第一个压缩存储的数组的一维下标m2 = (k*(k + 1))/2 + j;//第二个压缩存储的数组的一维下标c[m] += a[m1]*b[m2];//进行乘积操作}}}return 0;}int main(){int n ;//数组长度nint a[100],b[100],c[100];//定义三个一维数组printf("请输入数组大小n：\n");scanf("%d",&n);input_Arr(a,n);//调用输入下三角矩阵函数printf("数组一为：\n");print(a,n);//输出下三角矩阵input_Arr(b,n);//同上printf("数组二为：\n");print(b,n);//同上print_Array(a,b,c,n);//调用下三角矩阵相乘函数printf("数组的乘积为：\n");print(c,n);//输出相乘之后的下三角矩阵return 0; }。

第4章专题3矩阵的压缩存储

三元组表＝( (0,0,15), (1,1,11), (2,3,6), (4,0,9) ) 如何存储三元组表？
清华大学出版社
数据结构（C++版）第2版
4.3 矩阵的压缩存储
稀疏矩阵的压缩存储——三元组顺序表采用顺序存储结构存储三元组表
15 0 0 22 0 -15
0 11 3 0 0 0
A=
0 0
0 0 a43 a44 a45 0 0 0 a54 a55
(a) 三对角矩阵
按行存储
元素aij在一维数组中的序号
=2 + 3(i－2)+( j－i + 2) =2i+ j -2 ∵一维数组下标从0开始
∴元素aij在一维数组中的下标
= 2i+ j -3
(b) 寻址的计算方法
0 1 2 3 4 5 6 7 8 9 10 11 12
0 0
0 0
6 0
0 0
0 0
91 0 0 0 0 0
三元组顺序表是否需要预留存储空间？
稀疏矩阵的修改操作
三元组顺序表的插入/删除操作
清华大学出版社
数据结构（C++版）第2版
4.3 矩阵的压缩存储
稀疏矩阵的压缩存储——三元组顺序表
采用顺序存储结构存储三元组表
15 0 0 22 0 -15
0 11 3 0 0 0
上三角中的元素aij（i＜j），因为aij＝aji，则访问和它对应的元素aji即可，即：k＝j×(j＋1)/2＋i -1 。
清华大学出版社
数据结构（C++版）第2版
4.3 矩阵的压缩存储
特殊矩阵的压缩存储——三角矩阵

三角矩阵在压缩存储下的转置矩阵源代码

#include<stdio.h>#include<stdlib.h>#define max 20#define zero 0typedef struct{int i,j,v;}node;typedef struct{node data[max];int m;}TSmatrix;TSmatrix *Setmatrix(){ //建三对角矩阵TSmatrix *T;T=(TSmatrix*)malloc(sizeof(TSmatrix));printf("请输入矩阵行数或列数:\n");scanf("%d",&T->m);printf("建立三对角矩阵:\n");for(int n=0;n<3*T->m-2;n++)scanf("%d%d%d",&T->data[n].i,&T->dat a[n].j,&T->data[n].v);return T;}TSmatrix *Trabsmatrix(TSmatrix *T){ //三对角矩阵转置int n,k,temp;TSmatrix *F;F=(TSmatrix*)malloc(sizeof(TSmatrix));F->m=T->m;for(n=0;n<3*T->m-2;n++){ //将结点信息存入新三元组表中temp=2*T->data[n].j+T->data[n].i; //计算待存入三元数组下标F->data[temp].i=T->data[n].j;F->data[temp].j=T->data[n].i;F->data[temp].v=T->data[n].v;}return F;}void TSmatrixout(TSmatrix *T){ //三对角矩阵输出int a,b,n;n=0;for(a=0;a<T->m;a++){for(b=0;b<T->m;b++){if(T->data[n].i==a&&T->data[n].j==b){printf("%-5d",T->data[n].v);n++;}elseprintf("%-5d",zero);}printf("\n");}}void main(){TSmatrix *T;T=Setmatrix();printf("三对角矩阵:\n");TSmatrixout(T);T=Trabsmatrix(T);printf("转置后三对角矩阵:\n");TSmatrixout(T);}问题分析：本程序要求实现对压缩存储下的三对角矩阵进行转置，为实现上述功能，需要解决的关键问题是三对角矩阵压缩存储及转置过程。

下三角矩阵的压缩存储

下三角矩阵的压缩存储下三角矩阵的压缩存储是一种有效的数据结构，用于节省内存空间和提高数据访问效率。

下面将介绍下三角矩阵的定义和压缩存储方法。

一、下三角矩阵的定义下三角矩阵是指主对角线以上的元素均为0的矩阵。

例如，一个3阶的下三角矩阵可以表示为：a21 a22 0a31 a32 a33其中，a11、a21、a22、a31、a32和a33为矩阵中的元素。

下三角矩阵的特点是上三角部分全为0，只有下三角部分有非零元素。

由于下三角矩阵的上三角部分全为0，对于大规模矩阵而言，存储这些0元素是一种浪费。

因此，可以使用一维数组来压缩存储下三角矩阵。

具体的压缩存储方法是，将下三角矩阵按行从上到下、从左到右的顺序压缩成一个一维数组。

压缩后的数组长度为矩阵下三角部分的元素个数，即n * (n + 1) / 2，其中n为矩阵的阶数。

例如，对于上述的3阶下三角矩阵，按行压缩后的一维数组为：a11, a21, a22, a31, a32, a33压缩后的一维数组长度为6，分别对应着下三角矩阵中的非零元素。

在压缩存储的时候，需要注意矩阵元素在一维数组中的下标与矩阵中的行列下标之间的对应关系。

一维数组的下标可以通过如下公式计算得到：arrayIndex = i * (i + 1) / 2 + j其中，i和j分别为矩阵元素在矩阵中的行列下标，arrayIndex为该元素在一维数组中的下标。

通过下三角矩阵的压缩存储，可以减少存储空间的占用，并且提高访问矩阵元素的效率。

在实际应用中，下三角矩阵的压缩存储常用于稀疏矩阵的表示和处理。

总结：下三角矩阵的压缩存储是一种有效的数据结构，可以节省内存空间，并提高数据访问效率。

压缩存储的方法是将下三角矩阵按行压缩成一维数组，通过计算数组下标与矩阵元素在矩阵中的下标之间的对应关系，可以实现矩阵元素的访问。

这种压缩存储方式在稀疏矩阵的处理中具有广泛的应用。

矩阵的压缩存储

矩阵的压缩存储前⾔⼀⼊编程深似海，从此砖头是爱⼈，⽇⽇搬，夜夜搬，搬到天荒地⽼，精尽⼈亡，直教⼈失去了⾃我，忘记了时间，忽然之间发现九⽉份快没了，赶紧写篇博客打个卡，证明⼀下我还活着。

数组与矩阵数组是由⼀组相同类型的数据元素构成的有限序列，访问数据元素的⽅式是使⽤元素各⾃的序号进⾏访问，也就是下标。

数组它本⾝是线性表的推⼴，⼀维数组就是⼀个向量形式的线性表，⼆维数组就是由⼀维数组组成的线性表。

在许多科学计算和⼯程应⽤中，经常要⽤到矩阵的概念，我们⽤的最多的其实就是Mysql的表，表数据都是⾏列存储，这就是矩阵。

由于矩阵具有元素数⽬固定以及元素按下标关系有序排列等特点，所以在使⽤⾼级语⾔编程时，⼀般都是⽤⼆维数组来存储矩阵。

数组的顺序存储为什么是顺序存储？我想问这个问题就太低级了。

因为它是数组，数据的存储⽅式分为顺序存储和链式存储两种，数组⼀旦被定义，他的维数和维界就已固定，除结构的初始化和销毁外，数组只会有存取元素和修改元素的操作，不存在插⼊和删除操作，所以数组适合⽤顺序存储。

数组存放在内存中的映射关系数组可以是多维的，但是内存空间却是⼀维的，所以我们就要把多维数组通过⼀定的映射顺序把它变成⼀维的，然后存储到内存空间之中。

在⼤多数⾼级编程语⾔中，多维数组在内存中通常有两种不同的顺序存储⽅式，按⾏优先顺序存储和按列优先顺序存储。

举个例⼦，以下3⾏4列的⼀个⼆维数组矩阵：a1,a2,a3,a4b1,b2,b3,b4c1,c2,c3,c4 按⾏优先顺序存储：按列优先顺序存储：地址计算地址计算的意思就是给定数组下标，求在⼀维内存空间的地址，从⽽取出数据。

我们先来看⼀维数组的地址计算⼀维数组内的元素只有⼀个下标，存储⽅法和普通的线性表⼀样。

如⼀维数组 A = [a1,a2,a3,......ai,.........,an]，每个元素占⽤size个存储单元（就是内存⼤⼩），那么元素ai的存储地址为 A[0]的位置 + (i-1)*size再来看⼆维数组的地址计算以⼆维数组Amn为例，⾸元素为A[0][0]，数组中任意元素A[i][j]的地址为：A[0][0]的位置 + （n * (i-1) + (j-1)）* size；⽐如：⼀个5⾏4列的⼆维数组A，按⾏存储，其中每个元素占2个存储单元，⾸元素地址是1000，求第3⾏第2列的元素在内存中的地址。

数据结构-矩阵的压缩存储

int i,j,m,n;
table t;
printf("请输入矩阵行数和列数：");
scanf("%d %d",&m,&n);
printf("请输入矩阵：\n");
for(i=0;i<m;i++)
{
for(j=0;j<n;j++)
{
scanf("%d",&a[i][j]);
}
}
create(t,a,m,n);
int nums;
tupletype daint transpose(table ma,table mb);//转置函数
int create(table t,int a[10][10],int m,int n)//三元组储存
{
int i,j;
table s;
t.rows=m;
pirntf("压缩后的一维数组\n");
//---添加代码-----
printf("输入要查询的行号列号:");
scanf("%d %d",&x,&y);
printf("您查询的数据是：");
//---添加代码-----
return 0;
}
（3）选做：任意输入一个稀疏矩阵M，用三元组顺序表压缩存储该稀疏矩阵M，然后求其转置矩阵T，并输出转置矩阵T。
k++;
while(t[m]!='\0')
m++;
while(i<k&&j<m)

数据结构-矩阵的压缩存储程序【范本模板】

实验报告课程名：数据结构（C语言版）实验名：矩阵的压缩存储姓名：班级：学号：时间：2014.11.23一实验目的与要求1.掌握并实现稀疏矩阵的压缩存储的方法2.在该存储方法上实现矩阵的操作二实验内容•判断一个用二维数组存储的矩阵是不是稀疏矩阵•将其转化为压缩存储的形式•在压缩存储上实现矩阵的乘法和转置操作三实验结果与分析压缩转置程序：#include〈stdio。

h〉//判断该矩阵是否为稀疏矩阵＃define m 10#define n 10int a[m][n］={{1，0,0,0，0,0,0,0,0,0｝，{0，0，0，0,0，0,0，0，0，0｝，｛0,0,0,0,0,0，0,0,0,0｝，{1，0，0,0，0，0,0,0,0，0},｛0,0,0，0，0,0，0，0,0，0},{0，0，0,0，0，0，0，0,0，0｝,{0，0，0,0，0，0,0,0,0，0｝,{0,0,0，0，0,0,0，0,7，0}，｛0，0，0，0,0，0，8,0，0,0},｛0,0,0,0,0，0,0,0，0,0}，}；struct three{int i，j;int value;｝；struct three stu[100]；struct three1｛int i，j；int value;}；struct three1 stu1[100］;int jiance()｛int x=0；//赋初值为0for（x=0；x<=99;x++）{stu[x］.value=0;}float t=0；float v；for（int i=0;i〈m;i++）｛for（int j=0；j〈n;j++）｛if（a［i］［j］！=0)t++;}}if（(v=t/(m*n）)〈=0.05)｛printf(”该矩阵为稀疏矩阵%f\n",v）;return 1;}else{printf(”该矩阵不是稀疏矩阵\n”）;return 0;｝}void yasuo（）｛int t=0；for(int r=0;r<m；r++）｛for（int c=0;c<n;c++）{if（a[r］[c]!=0）｛stu[t].i=r;stu［t］.j=c;stu［t］。

第4章矩阵的压缩存储

18
例：
行列下标 i
0
非零元值 j 7 2 3 1 6 3 2 v 8 12 9 -3 14 24 18
6 1 1 3 3 4 5
1
2 3 4 5 6 7
0 0 12 9 0 0 0 0 3 0 0 0 M 0 0 24 0 0 18 0 0 15 0 0 7

cpot[col]:表示第col列第一个非0元素在B.data[]中位置
cpot[1]=1 cpot[col]=cpot[col-1]+num[col-1] 2<=col<=A.nu
24
0 12 9 0 0 0 0 0 3 0 0 0 M 0 0 24 0 0 18 0 0 15 0 0 7
19
基本运算举例：
以矩阵的转置为例说明这种压缩存储结构是如何实现矩阵运算的。问题描述：已知一个稀疏矩阵的三元组表，求该矩阵转置矩阵的三元组表。(一个m×n矩阵A，它的转置矩阵是一个n×m 矩阵B，且A[i][j]=B[j][i]）一般矩阵转置算法： for(j=0;j<n;j++) for(i=0;i<m;i++) B[j][i]=A[i][j]; T(n)=O(mn)
14
4.2.2
三角矩阵
以主对角线划分，下三角矩阵： c ... c a11 a a22 ... c 21 ... ... ... ... an ,1 an , 2 ... an ,n 在多数情况下，三角矩阵的常数c为0。 i (i 1) / 2 ( j 1)，i j k n * ( n 1) / 2, , , , , , , , , i j

矩阵的压缩存储..共41页

矩阵的压缩存储..
11、获得的成功越大，就越令人高兴。野心是使人勤奋的原因，节制使人枯萎。 12、不问收获，只问耕耘。如同种树，先有根茎，再有枝叶，尔后花实，好好劳动，不要想太多，那样只会使人胆孝懒惰，因为不实践，甚至不接触社会，难道你是野人。(名言网) 13、不怕，不悔(虽然只有四个字，但常看常新。 14、我在心里默默地为每一个人祝福。我爱自己，我用清洁与节制来珍惜我的身体，我用智慧和知识充实我的头脑。 15、这世上的一切都借希望而完成。农夫不会播下一粒玉米，如果他不曾希望它长成种籽；单身汉不会娶妻，如果他不曾希望有小孩；商人或手艺人不会工作，如果他不曾希望因此而有收益。-- 马钉路德。
46、我们若已接受最坏的，就再没有什么损失。——卡耐基 47、书到用时方恨少、事非经过不知难。——陆游 48、书籍把我们引入最美好的社会，使我们认识各个时代的伟大智者。——史美尔斯 49、样用功，谁就会和我一样成功。——莫扎特

矩阵的压缩存储上机报告

实验：矩阵的压缩存储及相关操作一、实验目的1 理解稀疏矩阵的三元组顺序表类型定义，2 掌握稀疏矩阵的输入( 即根据输入数据创建矩阵的三元组顺序表)3 掌握稀疏矩阵输出(即根据矩阵的三元组顺序表在屏幕上输出完整的矩阵)4 掌握稀疏矩阵的转置算法。

二、实验内容1．编写程序任意输入一个稀疏矩阵M，用三元组顺序表压缩存储该稀疏矩阵M，然后求其转置矩阵T，并输出转置矩阵T。

运行效果图:注意:矩阵要求用三元组顺序表存储三、思考与提高如何计算两个三元组表表示的稀疏矩阵的乘积？【方案一】程序代码：#include <iostream>#include <malloc.h>#include <cmath>#include <iomanip>using namespace std;#define MAXSIZE 12500#define OK 1#define ERROR 0typedef int Status;typedef int ElemType;//#define Triple Mtypedef struct{int i,j;ElemType e;}Triple;typedef struct{Triple data[MAXSIZE+1];int mu,nu,tu;}TSMatrix;CreateSMatrix(TSMatrix &M){int i,m,n;ElemType e;Status k;cout<<"输入矩阵的行、列数、非零元素个数：\n";//Mcin>>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);cout<<"第"<<i<<"个数所在的行列号元素值\n";//scanf("%d,%d,%d",&m,&n,&e);cin>>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;}Status TransposeSMatrix(TSMatrix M,TSMatrix &T){ // 求稀疏矩阵M的转置矩阵T。

特殊矩阵的压缩存储

《数据结构》课程设计报告书题目：特殊矩阵的压缩存储算法的实现系别：计算机科学与技术学号：111096135学生姓名：徐光辉指导教师：刘双红完成日期：2012年6月5日目录1 需求分析 (1)2 概要设计 (1)3详细设计 (1)3.1 详细设计思想 (1)3.2 核心代码 (2)4 调试分析 (6)5 测试结果 (6)6 总结 (8)指导教师评语 (9)1 需求分析问题描述：对于特殊矩阵可以通过压缩存储减少存储空间。

基本要求：1.针对多种特殊矩阵进行压缩存储，并能显示压缩后的相关地址和值。

2.输入在原来特殊矩阵中的地址，要求能从压缩后的矩阵中读出相应的值。

2 概要设计程序流程图如下：开始选择矩阵类型输入101输入矩阵元素结束图2.1 程序流程图3详细设计3.1 详细设计思想特殊矩阵：值相同元素或者零元素分布有一定规律的矩阵称为特殊矩阵例:对称矩阵、上（下）三角矩阵都是特殊矩阵。

图3.1 特殊矩阵特殊矩阵压缩存储(以对称矩阵为例)对称矩阵是满足下面条件的n 阶矩阵: aij= aji 1<= i,j<= n图 3.2k= 0 1 2 3 4 5 6 n(n+1)/2-1对称矩阵元素可以只存储下三角部分，共需 n(n+1)/2 个单元的空间( 三角矩阵的存储方式类似）。

以一维数组sa[0..n(n+1)/2-1]作为n 阶对称矩阵A的存储结构A中任意一元素 aij 与它的存储位置 sa[k] 之间关系：图 3.3k= 0 1 2 3 4 5 6 n(n+1)/2-13.2 核心代码#include<stdio.h>#include <stdlib.h>static shangsanjiao(int n){int i,j,k,z,g;int L[100][100],SA[100];printf("请输入您要压缩矩阵的行列数\n");scanf("%d",&n);printf("请输入您的矩阵内元素：\n");for(i=1;i<n+1;i++)for(j=1;j<n+1;j++){scanf("%d",&L[i][j]);if(i<=j)k=j*(j-1)/2+i-1;elseSA[k]=L[i][j];}printf("您输入的矩阵为：\n");for(i=1;i<n+1;i++){for(j=1;j<n+1;j++)printf("%d ",L[i][j]);printf("\n");}printf("压缩存储后：\n");for(k=0;k<n*(n+1)/2+1;k++)printf("%d %d\n",k,SA[k]);printf("若要读取矩阵的值请输入'100'退出输入'000'。

矩阵压缩实验报告

一、实验目的1. 了解矩阵压缩存储的基本原理和方法。

2. 掌握稀疏矩阵的压缩存储方法，包括三元组顺序表存储和压缩存储下三角矩阵。

3. 熟悉矩阵压缩存储在数据结构中的应用，提高数据存储效率。

4. 通过实验验证矩阵压缩存储方法的有效性和优越性。

二、实验原理矩阵压缩存储是一种针对稀疏矩阵的存储方法，通过压缩存储非零元素，减少存储空间，提高数据存储效率。

稀疏矩阵是指矩阵中大部分元素为0的矩阵，其特点是存储空间利用率低，计算效率低。

矩阵压缩存储主要有以下几种方法：1. 三元组顺序表存储：将稀疏矩阵中的非零元素及其对应的行、列索引存储在一个三元组中，形成顺序表。

2. 压缩存储下三角矩阵：对于下三角矩阵，只存储主对角线以下的非零元素及其对应的行、列索引。

3. 压缩存储上三角矩阵：对于上三角矩阵，只存储主对角线以上的非零元素及其对应的行、列索引。

三、实验内容1. 实现稀疏矩阵的三元组顺序表存储。

2. 实现压缩存储下三角矩阵和上三角矩阵。

3. 实现矩阵转置算法，包括压缩存储下三角矩阵的转置和压缩存储上三角矩阵的转置。

4. 比较不同存储方法的存储空间和计算效率。

四、实验步骤1. 创建一个稀疏矩阵，随机生成非零元素及其对应的行、列索引。

2. 实现稀疏矩阵的三元组顺序表存储，将非零元素及其对应的行、列索引存储在一个顺序表中。

3. 实现压缩存储下三角矩阵，只存储主对角线以下的非零元素及其对应的行、列索引。

4. 实现压缩存储上三角矩阵，只存储主对角线以上的非零元素及其对应的行、列索引。

5. 实现矩阵转置算法，包括压缩存储下三角矩阵的转置和压缩存储上三角矩阵的转置。

6. 比较不同存储方法的存储空间和计算效率。

五、实验结果与分析1. 三元组顺序表存储存储空间：n（非零元素个数） 3计算效率：O(n)2. 压缩存储下三角矩阵存储空间：n（非零元素个数） 3计算效率：O(n)3. 压缩存储上三角矩阵存储空间：n（非零元素个数） 3计算效率：O(n)4. 矩阵转置算法计算效率：O(n)通过实验结果可以看出，压缩存储下三角矩阵和上三角矩阵的存储空间和计算效率与三元组顺序表存储相当，且对于稀疏矩阵，压缩存储方法可以显著减少存储空间，提高数据存储效率。

实验5 矩阵的压缩存储实现

实验5 矩阵的压缩存储实现1. 实验要求(1) 实现矩阵（对称阵和稀疏阵）的压缩存储结构设计；(2) 实现矩阵的操作（稀疏矩阵快速转置和乘法）算法设计；2. 主要实验方法(1) 设计算法思想；(2) 编写算法代码；(3) 运行算法代码，并分析算法的效率；3. 实验内容实验5.1 对称矩阵顺序表存储表示（一）具体要求：（1）初始化一个对称矩阵（2）显示对称矩阵（3）任意取对称矩阵第i行第j列的值（二）测试: 输入如下对称矩阵，测试存储和访问情况对称矩阵为：1 1 0 51 2 0 70 0 1 55 7 5 7实验5.2 稀疏矩阵的三元组顺序表存储表示，及稀疏矩阵快速转置（一）具体要求：（1）初始化一个稀疏矩阵（2）显示初始化后的稀疏矩阵（3）转置（4）显示转置后的稀疏矩阵（二）测试: 输入如下稀疏矩阵，测试用三元组顺序表存储的稀疏矩阵的转置结果稀疏矩阵为：0 0 0 11 0 0 10 0 1 0实验5.3 稀疏矩阵的行逻辑链接顺序表存储表示，及稀疏矩阵乘法（一）具体要求：（1）初始化两个个稀疏矩阵a,b（2）获取这两个矩阵的各行第一个非零元的位置表rpos（2）显示初始化后的稀疏矩阵a,b（3）矩阵a和b相乘，结果存入矩阵c，即c=a*b（4）显示矩阵c（二）测试: 输入如下稀疏矩阵，测试用行逻辑链接顺序表存储的稀疏矩阵的乘积结果稀疏矩阵a为：3 0 0 50 -1 0 02 0 0 0稀疏矩阵b为：0 21 0-2 40 0乘积结果矩阵c为0 6-1 00 44. 实验重点和难点(1) 重点：特殊矩阵的压缩存储结构设计。

(2) 难点：稀疏矩阵的压缩存储结构的设计及操作算法设计。

5. 实验结果与分析（必须写这部分）应用文字、表格、图形等将数据表示出来6. 实验总结与体会必须写这部分7. 部分代码指导实验5.1实验5.2实验5.3。

三角矩阵的压缩存储

设计院先进个人发言稿英文回答：Dear colleagues and respected guests,。

I am honored to stand before you today as the recipient of the Advanced Individual Award. This recognition is a testament to the dedication and hard work of the entire design team.Throughout my career, I have been passionate about creating innovative and sustainable designs that enhance the lives of people around the world. I believe that architecture has the power to inspire, transform, and connect communities.This award is a recognition of the countless hours spent collaborating with colleagues, clients, and contractors. It acknowledges the late nights spent poring over drawings and the early mornings spent on site. It is atestament to the resilience and determination of our team to overcome challenges and deliver exceptional results.I would like to express my gratitude to my colleagues for their unwavering support and hard work. I am truly inspired by the talent and dedication of each and every member of our team. Together, we have created designs that have won numerous awards and have been featured in prestigious publications.I am also grateful to our clients for entrusting us with their vision and for their collaboration throughout the design process. I believe that a strong partnership between architect and client is essential to creating successful and meaningful projects.As I look to the future, I am excited about the challenges and opportunities that lie ahead. I believe that the design industry is at the cusp of a new era, where technology and sustainability will play an increasingly important role.I am committed to continuing to push the boundaries of design and to creating projects that are both innovativeand environmentally friendly. I believe that we have a responsibility to create a built environment that is healthy, sustainable, and inspiring for generations to come.Thank you once again for this recognition. It is a privilege to be part of such a talented and dedicated team.I look forward to continuing to work with you to create exceptional designs that make a positive impact on the world.中文回答：尊敬的各位领导、各位同事：非常荣幸能够获得先进个人奖，这份荣誉是对我个人以及整个设计团队辛勤付出与奉献精神的认可。

实验5特殊矩阵的存储和运算

实验报告五特殊矩阵和广义表的存储和运算班级：：学号：专业：一、实验目的：1、了解多维数组的存储方式和存取特点2、熟悉稀疏矩阵的存储方式3、用三元组法实现稀疏矩阵的相、减、转置算法。

二、实验容：1、在矩阵类Matrix中，增加下列操作：1)判断一个矩阵是否为上（下）三角矩阵、对称矩阵。

2)判断两个矩阵是否相等。

3)计算两个矩阵的乘积。

算法原代码：public class Matrix {private int[][] matrix;private int row;private int column;public Matrix(int[][] matrix){row = matrix.length;column = matrix[0].length;this.matrix = new int[row][column];for(int i=0;i<matrix.length;i++){for(int j=0;j<matrix[i].length;j++){this.matrix[i][j] = matrix[i][j];}}}public Matrix(int row, int column){this.row = row;this.column = column;matrix = new int[row][column];}/*** 判断上三角* param matrix* return*/public static boolean isUpTri(Matrix matrix){if(matrix.column!=matrix.row){throw new IllegalArgumentException("矩阵的行列不相等"); }for(int i=0;i<matrix.getRow();i++){for(int j=i+1;j<matrix.getColumn();j++){if(0 == matrix.getElement(i, j)){return false;}}}return true;}/*** 判断下三角* param matrix* return*/public static boolean isDownTri(Matrix matrix){//先判断行列相不相等if(matrix.column!=matrix.row){throw new IllegalArgumentException("矩阵的行列不相等"); }for(int j=0;j<matrix.getColumn();j++){for(int i=j+1;i<matrix.getColumn();i++){if(matrix.getElement(i,j)==0){return false;}}}return true;}/*** 判断matrix是不是对称矩阵* param matrix* return*/public static boolean isSymmetry(Matrix matrix){for(int i=0;i<matrix.getRow();i++){for(int j=i+1;j<matrix.getColumn();j++){if(matrix.getElement(i,j) != matrix.getElement(j,i)){return false;}}}return true;}/*** 判断两个矩阵是否相等* param matrix1* param matrix2* return*/public static boolean equals(Matrix matrix1, Matrix matrix2){if(matrix1.getRow()!=matrix2.getRow()||matrix1.getColumn()!=matrix2. getColumn()){return false;}for(int i=0;i<matrix1.row;i++){for(int j=0;j<matrix1.column;j++){if(matrix1.getElement(i,j)!=matrix2.getElement(i,j)){return false;}}}return true;}/*** 将两个矩阵相乘* param TemPMatrix* return*/public Matrix multiply(Matrix TemPMatrix) {if(column!=TemPMatrix.row){throw new IllegalArgumentException("行列不匹配，两个矩阵无法相乘");}Matrix matrix1 = new Matrix(row,TemPMatrix.column);for(int i=0;i<matrix1.row;i++){for(int j=0;j<matrix1.column;j++){int sum = 0;for(int k=0;k<column;k++){sum +=(this.matrix[i][k])*(TemPMatrix.getElement(k,j));}matrix1.setElement(i,j,sum);}}return matrix1;}/*** 两个矩阵相加* param matrix* return*/public Matrix plus(Matrix matrix){if(row!=matrix.getRow()&&column!=matrix.getColumn()){ throw new IllegalArgumentException("行列不匹配");}int[][] tempMatrix = new int[row][column];for(int i=0;i<row;i++){for(int j=0;j<column;j++){tempMatrix[i][j] = this.matrix[i][j]+matrix.getElement(i,j);}}return new Matrix(tempMatrix);}Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false; Matrix matrix1 = (Matrix) o;if (row != matrix1.row) return false;if (column != matrix1.column) return false;return Arrays.deepEquals(matrix, matrix1.matrix);}public void setElement(int row, int column, int element){ matrix[row][column] = element;}public int getElement(int row, int column){return matrix[row][column];}public int getRow() {return row;}public int getColumn() {return column;}Overridepublic String toString() {String string = new String();for(int i=0;i<row;i++){for(int j=0;j<column;j++){string += matrix[i][j]+" ";}string += "\n";}return string;}}public class Test {public static void main(String[] args) throws Exception {Matrix matrix1 = new Matrix(newint[][]{{1,0,0,0,0},{1,2,0,0,0},{1,2,3,0,0},{1,2,3,4,0},{1,2,3,4,5}} );Matrix matrix2 = new Matrix(newint[][]{{1,2,3,4,5},{0,2,3,4,5},{0,0,3,4,5},{0,0,0,4,5},{0,0,0,0,5}} );Matrix matrix3 = new Matrix(newint[][]{{1,2,3,4,5},{2,1,6,7,8},{3,6,1,9,10},{4,7,9,1,11},{5,8,10,11 ,1}});Matrix matrix4 = new Matrix(newint[][]{{1,0,0,0,0},{1,2,0,0,0},{1,2,3,0,0},{1,2,3,4,0},{1,2,3,4,5}} );System.out.println(matrix1);System.out.println(matrix2);System.out.println("matrix1是否是上三角:"+Matrix.isUpTri(matrix1));System.out.println("matrix2是否是上三角:"+Matrix.isUpTri(matrix2));System.out.println("matrix1是否是下三角:"+Matrix.isDownTri(matrix1));System.out.println("matrix2是否是下三角:"+Matrix.isDownTri(matrix2));System.out.println("matrix3是否是对称矩阵"+Matrix.isSymmetry(matrix3));System.out.println("matrix2是否是对称矩阵"+Matrix.isSymmetry(matrix2));System.out.println("matrix1是否等于matrix2:"+matrix1.equals(matrix2));System.out.println("matrix1是否等于matrix4:"+matrix1.equals(matrix4));System.out.println();System.out.println("matrix1*matrix2");System.out.println(matrix1.multiply(matrix2));}}测试结果如下：2、在三元组行的单链表表示的稀疏矩阵类LinkedMatrix中，增加判断矩阵相等、判断对称矩阵、计算矩阵乘积等操作。