数据结构（二）之稀疏矩阵篇

稀疏矩阵是指矩阵中大多数元素为零的矩阵。从直观上讲，当非零元素个数低于总元素的30%,这样的矩阵被称为稀疏矩阵。
稀疏矩阵的表示方法
ex1
A={0,12,9,0,0,0,0
0,0,0,0,0,0,0
-3,0,0,0,0，14,0
0,0,24,0,0,0,0
0,18,0,0,0,0,0
15,0,0，-7,0,0,0}
一 三元组表示法

	row	col	e
1	1	2	12
2	1	3	9
3	3	1	-3
4	3	6	14
5	4	3	24
6	5	2	18
7	6	1	15
8	7	4	-7

我们在实现经典矩阵转置时

for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
a[i][j]=b[j][i];

而我们在实现稀疏矩阵用三元组表示时，也可以把行列互换，但转置之后三元组变得无序，重新排序三元组影响算法的效率。
有两种方法实现
①多次扫描，设一个标记数k，标记在转置矩阵的位置,多次扫描三元组，将列数为col（1<=col<=n）的依次放入转置矩阵中，i++；
核心算法为

int k=1;
for(Int col=1;col<=n;col++)
for(int i=1;i<=A.len;i++)
{
if(A[i]..col==col)//转置
{ 
 B[k].e=A[i].e;
 B[k].row=A[i].col;
 B[k].col=A[I].row;
}
}

即可实现转置后按顺序排列
②一次扫描转置
我们可以建立两个数组num[i],postion[i]，
num[i]用来存放待转置矩阵列为i的个数，
positon[i]用来存放转置矩阵放置列为i的个数。

核心算法

for(int i=1;i<=A.n;i++)
num[i]=0;
for(int i=1;i<=A.len;i++)
num[A[i].col]++;//初始化num
int positon[1]=1;
for(int i=2;i<=A.n;i++)
{
  positon[i]=positon[i-1]+num[i-1];
  }//初始化positon
  //我们知道列数为i的转置后的数组位置positon[i]，接着position[i]++；指向下一个列数为i的存储位置
  for(int i=1;i<=A.len;i++)
  { 
  col=A[i].col;q=positon[col];
  B[q].col=A[i].row;
  B[q].row=A[i].col;
  B[q].e=A[I].e;
  positon[col]++;
  }
  }
  

第一种算法有两层for循环时间复杂度=O（A.n*A.len）;
第二种算法有一层for循环时间复杂度为O（A.n+A.len）;
算法在时间复杂度的提升是牺牲空间为代价的。
稀疏矩阵表示法之三，十字链表表示法

typedef strucr Node 
{ int row,col
int value;
struct Node *right,*down;
}OLNode,*OLink;
typedef struct
{
OLink *row_head,*col_head；
int m,n,len;
}CrossList；
//核心代码 
 {CrossList M；
 M->row_head=(OLink*)malloc(sizeof(OLink)*(m+1))
 /*关键部分
 //char *p;
 p=(char*)malloc(sizeof(len*sizeof(char)));
 我们平常这样做 分配长度为len一个字符数组
 同理OLink为指向OLNode的指针 分配一个长度为m+1的指向OLNode的指针数组。
 把数组的地址传给M->row_hear;*/
 p=new OLNode;
 p->row=i;p->col=j;p->data=e;
 //插入操作
 if(M->row_head[i]==NULL)
M->row_head[i]=p;
else
{
q=M->row_head;
while(q->right!=NULL&&q->right->col<j)
q=q->right;
p->right=q->right;q->right=p;
}//对列同理插入