矩阵压缩
稀疏矩阵压缩存储
一般来讲，零元素多到了一定程度并且没有规律分布的矩阵叫做稀疏矩阵。对稀疏矩阵的压缩存储必须充分考虑以下三个问题：
① 尽可能减少或者不存储零元素以节省空间，降低空间复杂度。
② 尽可能快地实现数据元素的存储位置与原有位置之间的转换。
③ 尽可能不与零元素进行运算，以降低时间复杂度。
稀疏矩阵的压缩存储有三种最常见的方法，分别是三元组顺序表、行逻辑链接顺序表和十字链表。
‘贰’ 对称矩阵的压缩问题。
先考虑对角线元素a_{ii}对应的指标：1，1+n，1++n+n－1，1+n+n－1+n－2,,,1+n+n-1+...+n-(i-2)，故通式为(i-1)*n-i*(i-3)/2；一般的，a_{ij}的指标为a_{ii}的指标+j－i＝(i-1)*n-i*(i-1)/2+j
‘叁’ 对特殊矩阵的压缩可以降低运算的时间复杂度吗
1.k=n*(n+1)/2的原因是：对于三角矩阵，从1到N的总和是这么多，也就是说整个矩阵有这么多元素。另外正三角阵对应正方形。
对称矩阵满足A的转置也就是自身的特点，元素上，a[i,j] = a[j,i]。实际上的存储可以利用三角阵。所以老实说我对于他对称阵算法为什么少一个元素也有疑惑。
可能是三角阵可以对应不等长的矩阵，所以造成了k值不一样。
2.上三角阵，存在的元素是满足[1<= j <=n, i >= j]的关系[这里用i表横坐标j表纵坐标]，如果是长3宽4的当然不能和长4宽3的相提并论，试着画画就明白了。
3.对称阵不会出现像三角阵那样有一小角还是其他数字的情况。这个其他数字就是(6+1)-1=6。
4.压缩存储，只是将部分符合条件的矩阵减少一部分的存储空间。老实说我也感觉不很有用，除非他处理的数据本身必然具备此类特点。
5.固定的，多试几次自己记下来然后找找就好。如果没记错的话，在矩阵上画画就可以看出来。
6.stdlib.h是标准的输入输出库，最为常用，至少里面包括了scanf等函数，只要你需要printf你就不能扔掉它。否则会出现函数未定义的问题。毕竟语言本身不提供函数类库，类库需要另行引用。
‘肆’ 什么是压缩矩阵
在这里分开来给你解释
矩阵是许多科学计算、工程数学尤其是数值分析中经常研究的对象，矩阵也就是二维数组,所以它可以采用顺
序存储是来存储其中的元素。但有时矩阵的阶数很高，同时在矩阵中游很多值相同的元素，或大多数元素的值为
零，这时再采用严格的顺序存储显然是很浪费空间的，因为存储零元素或许多值相同的元素是没有意义的，因此为
了节省存储空间，对这类矩阵通常采用压缩存储。
压缩存储：为多个值相同的元素值分配一个存储空间，对零元素不分配存储空间。
特殊矩阵：各个元素的分布有一定规律
系数矩阵：矩阵中多数元素值为零。
‘伍’ 上三角矩阵的压缩存储原则是怎样的
上三角矩阵的压缩存储原则：对于三角矩阵，从1到N的总和是这么多，也就是说整个矩阵有这么多元素。另外正三角阵对应正方形。
经常出现一些阶数很高的矩阵，同时在矩阵中非零元素呈某种规律分布或者矩阵中有大量的零元素，若仍然用常规方法存储，可能存储重复的非零元素或零元素，这将造成存储空间的大量浪费。因此对这类矩阵进行压缩存储，从而合理地利用存储空间。
简正模式：
矩阵在物理学中的另一类泛应用是描述线性耦合调和系统。这类系统的运动方程可以用矩阵的形式来表示，即用一个质量矩阵乘以一个广义速度来给出运动项，用力矩阵乘以位移向量来刻画相互作用。求系统的解的最优方法是将矩阵的特征向量求出（通过对角化等方式）。
称为系统的简正模式。这种求解方式在研究分子内部动力学模式时十分重要：系统内部由化学键结合的原子的振动可以表示成简正振动模式的叠加。描述力学振动或电路振荡时，也需要使用简正模式求解。
‘陆’ 对稀疏矩阵进行压缩的目的
我给你源码记得顶我啊！！最主要的是把分给我哦！！
include<time.h>/*用于下面的srand((unsigned)time(NULL));函数的头文件*/
#include<stdio.h>
#include<stdlib.h>
#define MAX_ARRAY_DIM 2
#define MAXSIZE 100
typedef struct
{
int aa[MAX_ARRAY_DIM];
int dim;
int *base;
}array;
typedef struct
{
int i,j;/*记录非零元的行与列坐标*/
int e;/*记录非零原的数值*/
}triple;/*构成非零元素*/
typedef struct
{
triple data[MAXSIZE];/*预期非零原最大个数*/
int *rpos;/*记录各行第一个非零原的位置表*/
int mu,nu,tu;/*记录稀疏矩阵的行列和非零原个数*/
}tsmatrix;
main()
{
void initarray(array *a);/*数组初始化*/
void createsMatrix(array *a);/*创建稀疏矩阵*/
void inittsmatrix(array *a,tsmatrix *m);/*初始化稀疏矩阵三元组*/
void outputtsmatrix(tsmatrix *m);/*输出稀疏矩阵*/
void destroysmatrix(array *a);/*销毁稀疏矩阵*/
void outputarray(array *a);/*输出数组*/
void subtmatrix(tsmatrix *m,tsmatrix *n,tsmatrix *q);/*系数矩阵相减*/
void addsmatrix(tsmatrix *m,tsmatrix *n,tsmatrix *q);/*系数矩阵相加*/
void multsmatrix(tsmatrix *m,tsmatrix *n,tsmatrix *q);/*稀疏矩阵相乘*/
array a;
tsmatrix m,n,q;
int flag1=1,i;
srand((unsigned)time(NULL));
initarray(&a);/*初始化数组*/
createsMatrix(&a);/*创建稀疏矩阵*/
inittsmatrix(&a,&m);/*初始化稀疏矩阵三元组*/
outputtsmatrix(&m);/*输出稀疏矩阵*/
outputarray(&a);/*输出数组*/
destroysmatrix(&a);/*销毁原数组*/
initarray(&a);/*初始化数组*/
createsMatrix(&a);/*创建稀疏矩阵*/
inittsmatrix(&a,&n);/*初始化稀疏矩阵三元组*/
outputtsmatrix(&n);/*输出稀疏矩阵*/
outputarray(&a);/*输出数组*/
destroysmatrix(&a);/*销毁原数组*/
printf("2个三元数组已经创建成功，您要进行什么操作？\n1.(m+n)\n2.(m-n)\n3.(m*n)\n4.(n-m)\n");
while(flag1)
{
fflush(stdin);
scanf("%d",&i);
switch(i)
{
case 1:addsmatrix(&m,&n,&q);flag1=0;break;
case 2:subtmatrix(&m,&n,&q);flag1=0;break;
case 3:multsmatrix(&m,&n,&q);flag1=0;break;
case 4:subtmatrix(&n,&m,&q);flag1=0;break;
default:printf("输入错误请重新输入\n您要进行什么操作？1.(m+n)\n2.(m-n)\n3.(m*n)\n4.(n-m)\n\n");
}
}
printf("运算结果为\n");
outputtsmatrix(&q);/*输出运算结果*/
}
void initarray(array *a)/*创建数组*/
{
int i,j;
printf("请输入要创建的维数,(由于这里的作用是创建稀疏矩阵，建议输入2)\n");
scanf("%d",&a->dim);
if(a->dim!=MAX_ARRAY_DIM)
{
printf("输入维数超过界限\n");
exit(1);
}
for(i=0;i<a->dim;i++)
{
printf("请输入第%d维的数据",i+1);
scanf("%d",&a->aa[i]);
if(a->aa[i]<1)
{
printf("输入超过范围\n");
exit(1);
}
}
j=1;
for(i=0;i<a->dim;i++)
j*=a->aa[i];
if(!(a->base=(int *)malloc(j*sizeof(int))))
{
printf("开辟空间失败\n");
exit(1);
}
printf("数组创建成功\n");
}
void createsMatrix(array *a)/*创建稀疏矩阵*/
{
int i,j,k,l,m,n,flag1;
printf("是手动输入还是电脑自行创建？\n选1.电脑自行创建\n选0.手动创建\n");
scanf("%d",&i);
if(i!=1&&i!=0)
{
printf("输入格式错误\n");
exit(1);
}
if(i==0)/*手动输入*/
{
printf("请输入\n");
for(j=0;j<a->aa[0];j++)
{
for(k=0;k<a->aa[1];k++)
scanf("%d",&a->base[j*a->aa[1]+k]);
printf("\n");
}
}
else/*电脑自动输入*/
{
l=rand()%(a->aa[0]*a->aa[1]/4)+1;/*预期计算要输入多少个非零元*/
for(j=0;j<a->aa[0];j++)/*先将程序中所有的元素赋予0*/
for(k=0;k<a->aa[1];k++)
a->base[j*a->aa[1]+k]=0;
m=0;
while(m<l)/*输入l个非零元*/
{
flag1=1;
while(flag1)/*被赋予的元素原本必须是零*/
{
i=rand()%a->aa[0];/*自动选择行*/
j=rand()%a->aa[1];/*自动选择列*/
if(a->base[i*a->aa[1]+j]==0)/*所选择的元素是0*/
flag1=0;/*推出循环，否则继续循环直到，是零为止*/
}
flag1=1;
a->base[i*a->aa[1]+j]=rand()%10;/*赋值10以内*/
n=rand()%10;
if(n<5)
a->base[i*a->aa[1]+j]*=-1;/*输入正负*/
m++;
}
}
}
void inittsmatrix(array *a,tsmatrix *m)/*稀疏矩阵非零原初始化*/
{
int i,j,k=0,*num;
for(i=0;i<a->aa[0];i++)/*输入非零原坐标及数据*/
for(j=0;j<a->aa[1];j++)
if(a->base[i*a->aa[1]+j]!=0)
{
m->data[k+1].i=i+1;
m->data[k+1].j=j+1;
m->data[k+1].e=a->base[i*a->aa[1]+j];
k++;
}
m->mu=a->aa[0];/*记录行*/
m->nu=a->aa[1];/*记录列*/
m->tu=k;/*记录非零原数量*/
if(!(num=(int *)malloc((m->mu+1)*sizeof(int))))/*num用于记录每行的非零原的个数*/
{
printf("空间开辟失败\n");
exit(1);
}
if(!(m->rpos=(int *)malloc((m->mu+1)*sizeof(int))))/*本人认为数据结构上的rpos定义有错误，如果某一行全都是非零元那m->rpos[i]=0并不是m->rpos[i-1]+num[i-1]所以以下的rpos操作可能与书上的原意不符*/
{
printf("空间开辟失败\n");
exit(1);
}
for(i=0;i<=m->mu;i++)/*初始化num*/
num[i]=0;
for(i=1;i<=m->tu;i++)/*记录每行非零原的个数*/
++num[m->data[i].i];
if(num[1]==0)/*如果第一行没有非零原的话那m->rops[1]=0，这就是我修改的原因，如果按照书上写的话，那应该是1，对以后的操作有麻烦*/
{
m->rpos[1]=0;
j=0;
}
else/*否则记1*/
{
m->rpos[1]=1;
j=num[1];
}
for(i=2;i<=m->mu;i++)/*运算*/
{
if(num[i]==0)
m->rpos[i]=0;/*当前这一行并没有非零元所以记录1*/
else/*否则记录所对应的序列号*/
{
m->rpos[i]=j+1;
j+=num[i];
}
if(j>=m->tu)/*如果j的数量已经等于所有非零原的数量,那就应该退出循环*/
break;
}
while(i<=m->mu)/*如果半路退出循环，那么剩下的每行，都没有非零原*/
i++,m->rpos[i]=0;
}
void outputtsmatrix(tsmatrix *m)/*输出稀疏矩阵*/
{
int i;
printf("三元组表为\n");
for(i=1;i<=m->tu;i++)
printf("%d行 %d列 %d\n",m->data[i].i,m->data[i].j,m->data[i].e);
printf("行为%d列为%d\n",m->mu,m->nu);
for(i=1;i<=m->mu;i++)
printf("%d行的第一个元素所在位置表的位置是%d\n",i,m->rpos[i]);
}
void destroysmatrix(array *a)/*销毁稀疏矩阵*/
{
if(!a->base)exit(1);
free(a->base);a->base=NULL;
printf("\n稀疏矩阵数组销毁成功(*^__^*) \n\n");
}
void outputarray(array *a)/*输出数组*/
{
int i,j;
for(i=0;i<a->aa[0];i++)
{
for(j=0;j<a->aa[1];j++)
printf("%2d ",a->base[i*a->aa[1]+j]);
printf("\n");
}
}
void smatrix(tsmatrix *m,tsmatrix *t)/*复制稀疏矩阵*/
{
int i;
t->mu=m->mu,t->nu=m->nu,t->tu=m->tu;
if(!(t->rpos=(int *)malloc((t->mu+1)*sizeof(int))))
{
printf("开辟控件失败\n");
exit(1);
}
if(t->tu)
{
for(i=1;i<=m->tu;i++)
{
t->data[i].i=m->data[i].i;
t->data[i].j=m->data[i].j;
t->data[i].e=m->data[i].e;
}
}
for(i=1;i<=t->mu;i++)
t->rpos[i]=m->rpos[i];
}
void subtmatrix(tsmatrix *m,tsmatrix *n,tsmatrix *q)/*稀疏矩阵相减*/
{
int i,j,k,a,b,c,x,y,z,*num;
q->mu=m->mu>n->mu?m->mu:n->mu;
q->nu=m->nu>n->nu?m->nu:n->nu;
q->tu=0;
if(!(num=(int *)malloc((q->mu+1)*sizeof(int))))
{
printf("创建空间失败\n");
exit(1);
}
if(!(q->rpos=(int *)malloc((q->mu+1)*sizeof(int))))
{
printf("创建空间失败\n");
exit(1);
}
for(i=1;i<=q->mu;i++)
num[i]=0;
if(m->tu==0)
smatrix(n,q);
else if(n->tu==0)
smatrix(m,q);
else
{
i=j=k=1;
while(i<=m->tu&&j<=n->tu)
{
a=m->data[i].i;
b=m->data[i].j;
c=m->data[i].e;/*分别记录m的3元组的数据*/
x=n->data[j].i;
y=n->data[j].j;
z=n->data[j].e;
if(a==x)/*如果m,n行相等*/
{
if(b==y)/*如果行列都相等*/
{
if(c-z!=0)/*如果m-n!=0*/
{
num[a]++;
q->data[k].i=a;
q->data[k].j=b;
q->data[k].e=c-z;
k++;
}
i++,j++;/*无论是否m-n==0i,j都要+1*/
}
else if(b<y)/*如果行相等但是列不相等q下一个三元组应该取坐标相对较小的*/
{
num[a]++;
q->data[k].i=a;
q->data[k].j=b;
q->data[k].e=c;
k++;
i++;
}
else if(b>y)
{
num[x]++;
q->data[k].i=x;
q->data[k].j=y;
q->data[k].e=-z;
k++;j++;
}
else
printf("不可能出现的事情\n");
}
else if(a>x)
{
num[x]++;
q->data[k].i=x;
q->data[k].j=y;
q->data[k].e=-z;
k++;j++;
}
else if(a<x)
{
num[a]++;
q->data[k].i=a;
q->data[k].j=b;
q->data[k].e=c;
k++;i++;
}
else
printf("不可能发生的事情\n");
}
if(i>m->tu&&j<=n->tu)/*如果m的三元组记录完了但是n的三元组没有记录完那么剩下的应该全复制*/
{
while(j<=n->tu)
{
num[n->data[j].i]++;
q->data[k].i=n->data[j].i;
q->data[k].j=n->data[j].j;
q->data[k++].e=-n->data[j++].e;
}
}
else if(j>n->tu&&i<=m->tu)/*如果n的三元组记录完了但是m的三元组没有记录完那么剩下的应该全复制*/
{
while(i<=m->tu)
{
n->data[m->data[i].i].i;
q->data[k].i=m->data[i].i;
q->data[k].j=m->data[i].j;
q->data[k++].e=m->data[i++].e;
}
}
q->tu=k-1;
if(num[1]==0)/*如果第一行没有非零原的话那m->rops[1]=0，这就是我修改的原因，如果按照书上写的话，那应该是1，对以后的操作有麻烦*/
{
q->rpos[1]=0;
j=0;
}
else/*否则记1*/
{
q->rpos[1]=1;
j=num[1];
}
for(i=2;i<=q->mu;i++)/*运算*/
{
if(num[i]==0)
q->rpos[i]=0;/*当前这一行并没有非零元所以记录1*/
else/*否则记录所对应的序列号*/
{
q->rpos[i]=j+1;
j+=num[i];
}
if(j>=q->tu)/*如果j的数量已经等于所有非零原的数量,那就应该退出循环*/
break;
}
while(i<=q->mu)/*如果半路退出循环，那么剩下的每行，都没有非零原*/
{
i++;
q->rpos[i]=0;
}
}
}
void addsmatrix(tsmatrix *m,tsmatrix *n,tsmatrix *q)/*稀疏矩阵相加*/
{
int i,j,k,a,b,c,x,y,z,*num;
q->mu=m->mu>n->mu?m->mu:n->mu;
q->nu=m->nu>n->nu?m->nu:n->nu;
q->tu=0;
if(!(num=(int *)malloc((q->mu+1)*sizeof(int))))
{
printf("创建空间失败\n");
exit(1);
}
if(!(q->rpos=(int *)malloc((q->mu+1)*sizeof(int))))
{
printf("创建空间失败\n");
exit(1);
}
for(i=1;i<=q->mu;i++)
num[i]=0;
if(m->tu==0)
smatrix(n,q);
else if(n->tu==0)
smatrix(m,q);
else
{
i=j=k=1;
while(i<=m->tu&&j<=n->tu)
{
a=m->data[i].i;
b=m->data[i].j;
c=m->data[i].e;/*分别记录m的3元组的数据*/
x=n->data[j].i;
y=n->data[j].j;
z=n->data[j].e;
if(a==x)/*如果m,n行相等*/
{
if(b==y)/*如果行列都相等*/
{
if(c+z!=0)/*如果m+n!=0*/
{
num[a]++;
q->data[k].i=a;
q->data[k].j=b;
q->data[k].e=c+z;
k++;
}
i++,j++;/*无论是否m+n==0i,j都要+1*/
}
else if(b<y)/*如果行相等但是列不相等q下一个三元组应该取坐标相对较小的*/
{
num[a]++;
q->data[k].i=a;
q->data[k].j=b;
q->data[k].e=c;
k++;
i++;
}
else if(b>y)
{
num[x]++;
q->data[k].i=x;
q->data[k].j=y;
q->data[k].e=z;
k++;j++;
}
else
printf("不可能出现的事情\n");
}
else if(a>x)
{
num[x]++;
q->data[k].i=x;
q->data[k].j=y;
q->data[k].e=z;
k++;j++;
}
else if(a<x)
{
num[a]++;
q->data[k].i=a;
q->data[k].j=b;
q->data[k].e=c;
k++;i++;
}
else
printf("不可能发生的事情\n");
}
if(i>m->tu&&j<=n->tu)/*如果m的三元组记录完了但是n的三元组没有记录完那么剩下的应该全复制*/
{
while(j<=n->tu)
{
num[n->data[j].i]++;
q->data[k].i=n->data[j].i;
q->data[k].j=n->data[j].j;
q->data[k++].e=n->data[j++].e;
}
}
else if(j>n->tu&&i<=m->tu)/*如果n的三元组记录完了但是m的三元组没有记录完那么剩下的应该全复制*/
{
while(i<=m->tu)
{
n->data[m->data[i].i].i;
q->data[k].i=m->data[i].i;
q->data[k].j=m->data[i].j;
q->data[k++].e=m->data[i++].e;
}
}
q->tu=k-1;
if(num[1]==0)/*如果第一行没有非零原的话那m->rops[1]=0，这就是我修改的原因，如果按照书上写的话，那应该是1，对以后的操作有麻烦*/
{
q->rpos[1]=0;
j=0;
}
else/*否则记1*/
{
q->rpos[1]=1;
j=num[1];
}
for(i=2;i<=q->mu;i++)/*运算*/
{
if(num[i]==0)
q->rpos[i]=0;/*当前这一行并没有非零元所以记录1*/
else/*否则记录所对应的序列号*/
{
q->rpos[i]=j+1;
j+=num[i];
}
if(j>=q->tu)/*如果j的数量已经等于所有非零原的数量,那就应该退出循环*/
break;
}
while(i<=q->mu)/*如果半路退出循环，那么剩下的每行，都没有非零原*/
{
i++;
q->rpos[i]=0;
}
}
}
void multsmatrix(tsmatrix *m,tsmatrix *n,tsmatrix *q)/*稀疏矩阵相乘*/
{
int i,j,k,l,o,p,x,y,*a,*num;
if(!(a=(int *)malloc(((m->mu+1)*(n->nu+1))*sizeof(int))))/*创建一个跟q相同大小的空间用来记录此坐标是否已经输入一个数*/
{
printf("开辟空间失败\n");
exit(1);
}
if(m->nu!=n->mu)
{
printf("不匹配\n");
exit(1);
}
q->mu=m->mu,q->nu=n->nu,q->tu=0;/*初始化*/
if(!(num=(int *)malloc((m->mu+1)*sizeof(int))))
{
printf("开辟空间失败\n");
exit(1);
}
if(!(q->rpos=(int *)malloc((q->mu+1)*sizeof(int))))
{
printf("空间开辟失败");
exit(1);
}
for(i=1;i<=q->mu;i++)
num[i]=0;
if(m->tu*n->tu!=0)
{
for(i=1;i<=m->mu;i++)/*初始化a数组*/
for(j=1;j<=n->nu;j++)
a[i*n->nu+j]=0;
for(i=1;i<=m->tu;i++)
{
o=m->data[i].i;
p=m->data[i].j;
if(n->rpos[p]==0)
continue;
l=p+1;
while(n->rpos[l]==0&&l<=n->mu)
l++;
if(l>n->mu)
j=n->tu+1;
else
j=n->rpos[l];
for(k=n->rpos[p];k<j;k++)/*k-j的范围是本行非零远的个数*/
{
x=n->data[k].i;/*x,y分别是n->data[k]的行和列*/
y=n->data[k].j;
if(a[o*n->nu+y]!=0)
q->data[a[o*n->nu+y]].e+=m->data[i].e*n->data[k].e;/*如果此空间已经输入一个数了，那么在相应的位置累加*/
else
{
q->data[++q->tu].e=m->data[i].e*n->data[k].e;
q->data[q->tu].i=o;
q->data[q->tu].j=y;
a[o*n->nu+y]=q->tu;/*此位置记录q->tu*/
num[o]++;
}
}
}
for(i=1;i<=q->mu;i++)
printf("%d ",num[i]);
if(num[1]==0)/*如果第一行没有非零原的话那m->rops[1]=0，这就是我修改的原因，如果按照书上写的话，那应该是1，对以后的操作有麻烦*/
{
q->rpos[1]=0;
j=0;
}
else/*否则记1*/
{
q->rpos[1]=1;
j=num[1];
}
for(i=2;i<=q->mu;i++)/*运算*/
{
if(num[i]==0)
q->rpos[i]=0;/*当前这一行并没有非零元所以记录1*/
else/*否则记录所对应的序列号*/
{
q->rpos[i]=j+1;
j+=num[i];
}
if(j>=q->tu)/*如果j的数量已经等于所有非零原的数量,那就应该退出循环*/
break;
}
while(i<=q->mu)/*如果半路退出循环，那么剩下的每行，都没有非零原*/
i++,q->rpos[i]=0;
}
}
‘柒’ 特殊矩阵和稀疏矩阵哪一种采用压缩存储会失去随机存取的功能为什么
稀疏矩阵压缩存储后,必会失去随机存取功能.
稀疏矩阵在采用压缩存储后将会失去随机存储的功能.因为在这种矩阵中,非零元素的分布是没有规律的,为了压缩存储,就将每一个非零元素的值和它所在的行、列号做为一个结点存放在一起,这样的结点组成的线性表中叫三元组表,它已不是简单的向量,所以无法用下标直接存取矩阵中的元素.
‘捌’ 矩阵的压缩存储是什么
二维数组在形式上是矩阵，因此一般用二维数组来存储矩阵。在不压缩存储的情况下，矩阵采用按行优先或按列优先方式存储，占用的存储单元数等于矩阵的元素个数。在实际应用中，经常出现一些阶数很高的矩阵，同时在矩阵中非零元素呈某种规律分布或者矩阵中有大量的零元素，若仍然用常规方法存储，可能存储重复的非零元素或零元素，这将造成存储空间的大量浪费。因此对这类矩阵进行压缩存储，从而合理地利用存储空间。
为了节省存储空间，可以利用特殊矩阵的规律，对它们进行压缩存储，也就是说为多个值相同的元素只分配一个存储单元，对零元素不分配空间。适合压缩存储的矩阵一般是值相同的元素或者零元素在矩阵中分布有一定规律的特殊矩阵和稀疏矩阵。常见的特殊矩阵有对称矩阵、三角矩阵和对角矩阵。
‘玖’ 特殊矩阵的压缩原则有那些
【知识点】
若矩阵A的特征值为λ1，λ2，...，λn，那么|A|=λ1·λ2·...·λn
【解答】
|A|=1×2×...×n= n！
设A的特征值为λ，对于的特征向量为α。
则 Aα = λα
那么 (A²-A)α = A²α - Aα = λ²α - λα = (λ²-λ)α
所以A²-A的特征值为 λ²-λ，对应的特征向量为α
A²-A的特征值为 0 ，2，6，...，n²-n
【评注】
对于A的多项式，其特征值为对应的特征多项式。
线性代数包括行列式、矩阵、线性方程组、向量空间与线性变换、特征值和特征向量、矩阵的对角化，二次型及应用问题等内容。