矩陣壓縮
稀疏矩陣壓縮存儲
一般來講，零元素多到了一定程度並且沒有規律分布的矩陣叫做稀疏矩陣。對稀疏矩陣的壓縮存儲必須充分考慮以下三個問題：
① 盡可能減少或者不存儲零元素以節省空間，降低空間復雜度。
② 盡可能快地實現數據元素的存儲位置與原有位置之間的轉換。
③ 盡可能不與零元素進行運算，以降低時間復雜度。
稀疏矩陣的壓縮存儲有三種最常見的方法，分別是三元組順序表、行邏輯鏈接順序表和十字鏈表。
『貳』 對稱矩陣的壓縮問題。
先考慮對角線元素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的多項式，其特徵值為對應的特徵多項式。
線性代數包括行列式、矩陣、線性方程組、向量空間與線性變換、特徵值和特徵向量、矩陣的對角化，二次型及應用問題等內容。