数据结构进阶(二)矩阵(稀疏矩阵)的压缩存储

矩阵(稀疏矩阵)的压缩存储

本文转载地址:

http://blog.163.com/zhoumhan_0351/blog/static/39954227201001112526244/

为了节省存储空间并且加快处理速度,需要对这类矩阵进行压缩存储,压缩存储的原则是:不重复存储相同元素;不存储零值元素。

一、相关概念

㈠特殊矩阵

矩阵中存在大多数值相同的元,或非0元,且在矩阵中的分布有一定规律。

⒈对称矩阵

矩阵中的元素满足

aij=aji    1≤i,j≤n

⒉三角矩阵

上(下)三角矩阵指矩阵的下(上)三角(不包括对角线)中的元素均为常数c或0的n阶矩阵。

⒊对角矩阵(带状矩阵)

矩阵中所有非0元素集中在主对角线为中心的区域中。

㈡稀疏矩阵

非0元素很少(≤ 5%)且分布无规律。

二、存储结构及算法思想

1、对称矩阵

存储分配策略: 每一对对称元只分配一个存储单元,即只存储下三角(包括对角线)的元, 所需空间数为:  n(n+1)/2。

存储分配方法: 用一维数组sa[n(n+1)/2]作为存储结构。

sa[k]与aij之间的对应关系为:

2、三角矩阵

也是一个n阶方阵,有上三角和下三角矩阵。下(上)三角矩阵是主对角线以上(下)元素均为零的n阶矩阵。设以一维数组sb[0..n(n+1)/2]作为n阶三角矩阵B的存储结构,仍采用按行存储方案,则B中任一元素bi,j和sb[k]之间仍然有如上的对应关系,只是还需要再加一个存储常数c的存储空间即可。如在下三角矩阵中,用n(n+1)/2的位置来存储常数。

对特殊矩阵的压缩存储实质上就是将二维矩阵中的部分元素按照某种方案排列到一维数组中,不同的排列方案也就对应不同的存储方案

3、稀疏矩阵

常见的有三元组表示法、带辅助行向量的二元组表示法(也即行逻辑链表的顺序表),十字链表表示法等。

1)三元组表示法

三元组表示法就是在存储非零元的同时,存储该元素所对应的行下标和列下标。稀疏矩阵中的每一个非零元素由一个三元组(i,j,aij)唯一确定。矩阵中所有非零元素存放在由三元组组成的数组中。

在此,data域中表示非零元的三元组是以行序为主序顺序排列的。

以下看如何利用三元组表示法来实现矩阵的转置。

(1)按照b.data中三元组的次序依次在a.data中找出相应的三元组进行转置。换句话说,按照矩阵M的列序进行转置。为了找到M的每一列中所有的非零元素,需要对其三元组表a.data从第一行起整个扫描一遍。由于a.data是以M的行序为存放每个非零元的,由此得到的恰好是b.data应有的顺序。

三、存储结构及C语言描述

1、三元组表示法

(1)按照b矩阵中的行次序依次在a.data中找到相应的三元组进行转置。

(2)快速转置:按照a.data中三元组的次序进行转置,并将转置后的三元组放到b.data中的恰当位置。

恰当位置的确定:首先计算M矩阵的每一列(即T的每一行)中非0元的个数,然后求得M矩阵每一列第一个非0元在b.data中的位置。

算法基本思想:

设置两个向量:

num[col]:第col列的非零元素个数。

cpot[col]:第col列第一个非零元在b.data中的恰当位置。

在转置过程中,指示该列下一个非零元在b.data中的位置。

1、num[col]的计算:

顺序扫描a.data三元组,累计各列非0元个数。

2、cpot[col]计算:

四、算法的C语言实现

#include "stdio.h"
#include "stdlib.h"
#define MAXSIZE 12500
#define OK 1
typedef int ElemType;
typedef struct
{
int i,j;
ElemType e;
}Triple;
typedef struct
{
Triple data[MAXSIZE+1];
int mu,nu,tu;   //矩阵行数,列数和非0元个数
}TSMatrix;
int cpot[MAXSIZE+1],num[MAXSIZE+1];
int TransposeSMatrix(TSMatrix M,TSMatrix &T)
{
T.mu=M.nu;
T.nu=M.mu;
T.tu=M.tu;
if(T.tu)
  {
   int q=1;
   for(int col=1;col<=M.nu;++col)
          for(int p=1;p<=M.tu;++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;
                 }//if
  }//if
return OK;
}//TransposeSMatrix
int InPutM(TSMatrix &M)
{
printf("input nu mu tu(With a space interval)of a Matrix:\n");
scanf("%d %d %d",&M.nu,&M.mu,&M.tu);  //row,colume,and tu
printf("Please input the data of Matrix:\n");
for(int c=1;c<=M.tu;c++)
   {
    scanf("%d",&M.data[c].i);
       scanf("%d",&M.data[c].j);
       scanf("%d",&M.data[c].e);
   }//for
return 1;
}//InPut
int PrintM(TSMatrix T)
{
printf("Matrix after transpose is:\n");
for(int c=1;c<=T.tu;c++)
   {
    printf("%d %d %d\n",T.data[c].i,T.data[c].j,T.data[c].e);
   }//for
return 1;
}//InPut
int FastTransposeSMatrix(TSMatrix M,TSMatrix &T)
{
T.mu=M.nu;
T.nu=M.mu;
T.tu=M.tu;
if(T.tu)
  {
  for(int col=1;col<=M.mu;++col) num[col]=0;
  for(int t=1;t<=M.tu;++t) ++num[M.data[t].j]; //记述M.data[t].j列
                                          //非0元的个数
  cpot[1]=1;
  //求第col列中第一个非零元在b.data(T)中的序号
  for(int col=2;col<=M.mu;++col)
         cpot[col]=cpot[col-1]+num[col-1];
  for(int p=1;p<=M.tu;++p)
         {
            int col=M.data[p].j;
          int q=cpot[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;
         ++cpot[col];
      }//for
  }//if
return OK;
}//FastTransposeSMatrix
int main()
{
TSMatrix M,T;
InPutM(M);
//TransposeSMatrix(M,T);
FastTransposeSMatrix(M,T);
PrintM(T);
return OK;
}

美文美图

时间: 2024-09-27 04:34:53

数据结构进阶(二)矩阵(稀疏矩阵)的压缩存储的相关文章

矩阵-----对称矩阵及其压缩存储&&稀疏矩阵

什么是对称矩阵(SymmetricMatrix)? 对称对称-------看 设一个N*N的方阵A,A中任意元素Aij,当且仅当Aij == Aji(0 <= i <= N-1 && 0 <= j <= N-1),则矩阵A是对称矩阵.以矩阵的对角线为分隔,分为上三角和下三角. 压缩存就是矩阵存储时只需要存储上三角/下三角的数据,所以最多存储n(n+1)/2个数据. 对称矩阵和压缩存储的对应关系:下三角存储i>=j,  SymmetricMatrix[i][j]

对称矩阵、稀疏矩阵的压缩存储

1)对称矩阵的压缩存储 对称矩阵顾名思义就是符合行和列的个数相同,并且矩阵中存储的数据上三角和下三角中对应位置上的元素值是相等的.为了能够减少存储的空间,我们可以只存储上三角矩阵.或者下三角矩阵中的元素,这样就能够极大地节省空间的浪费.下面是对称矩阵的示列: 假设对称矩阵为n*n,这里以行优先存储下三角矩阵,总共需要存储的元素有n*(n+1)/2个元素,从而将n*n个元素压缩到n*(n+1)/2大小的空间中. 下面是具体的程序实现: --symmetric.h文件 //实现对称矩阵 #inclu

稀疏矩阵的压缩存储及转置

没有经过处理的稀疏矩阵其实就是一个特殊的二维数组,数组中的大部分元素是0或者其他类型的非法值,只有少数几个非零元素. 为了实现压缩存储,可以只存储稀疏矩阵的非0元素.在存储稀疏矩阵中的非0元素时,必须要存储该元素的行列号以及元素值.我们可以封装一个三元组类来存储这些元素. //三元组 template<class T> struct Triple { size_t _row;   //行 size_t _col;   //列 T _value;      //值 Triple<T>

稀疏矩阵的压缩存储和转置

1.稀疏矩阵:M*N的矩阵,矩阵中有效值的个数远小于无效值的个数,且这些数据的分布没有规律. 2.稀疏矩阵的压缩存储:压缩存储值存储极少数的有效数据. 由于非零元素分布没有任何规律,所以在进行压缩存储的时侯需要存储无效值的同时还要存储有效元素在矩阵中的位置,即有效元素所在的行号和列号,也就是在存储某个元素比如aij的值的同时,还需要存储该元素所在的行号i和它的列号j,这样就构成了一个三元组(i,j,aij)的线性表. 使用{ row, col, value }三元组存储每一个有效数据,三元组按原

c++稀疏矩阵的压缩存储

稀疏矩阵 M*N的矩阵 其中有效值的个数远小于无效值的个数 且分布没有规律 Eg: int array [6][5] =     {{1, 0, 3, 0, 5}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}, {2, 0, 4, 0, 6}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}}; 稀疏矩阵的压缩存储 压缩存储值存储极少数的有效数据.使用{row,col,value}//行 列 值三元组存储每一个有效 数据,三元组按原矩阵中的位置,以行优先级

2、蛤蟆的数据结构进阶二静态查询之顺序查询

2.蛤蟆的数据结构进阶二静态查询之顺序查询 本篇名言:"我从不把安逸和快乐看作是生活的本身 --这种伦理基础,我叫它猪栏的理想. --爱因斯坦" 这篇我们来看下静态查询中的顺序表查询. 我们先来看下概念,然后是代码实现. 欢迎转载,转载请标明出处:http://blog.csdn.net/notbaron/article/details/47175103 1.  查找 在计算机科学中定义为:在一些(有序的/无序的)数据元素中,通过一定的方法找出与给定关键字相同的数据元素的过程叫做查找.

C++实现稀疏矩阵的压缩存储、转置、快速转置

/*稀疏矩阵的压缩存储.转置.快速转置*/ #include <iostream> using namespace std; #include <vector> //三元组 template<class T> struct Triple { size_t _row; size_t _col; T _value; Triple(size_t row = 0, size_t col = 0, const T& value = T()) :_row(row) ,_co

【数据结构】对称矩阵及对称矩阵的压缩存储

对称矩阵: 设一个N*N的方阵A,A中任意元素Aij,当且仅当Aij == Aji(0 <= i <= N-1 && 0 <= j <= N-1),则矩阵A是对称矩阵.以矩阵的对角线为分隔,分为上三角和下三角. 如下面矩阵: 对称矩阵压缩存储时只需要存储i*(i+1)/2个数据. 对称矩阵与压缩矩阵的关系是: 对称矩阵SymmetricMatrix[i][j] =压缩矩阵Array(i*(i+1)/2+j). 下面我实现一下对称矩阵存储在压缩矩阵以及将压缩矩阵中的元

【数据结构】稀疏结构及稀疏矩阵的压缩存储,矩阵的转置

在矩阵中,有一类很重要的矩阵,就是-----稀疏矩阵. 所谓的稀疏矩阵呢,就是指的是,在矩阵中,有效的数据个数远远小于无效的数据个数(并且这些数据排列顺序没有规律).我们下面先举个稀疏矩阵的例子: 有效数据个数仅仅6个,其余都为无效数据0. 那我们将稀疏矩阵存在压缩矩阵中,设定一个三元组,使用{row,col,value}存储每一个有效数据,三元组按原矩阵中的位置,以行优先级先后顺序依次存放. 我们建立一个结构体: struct Triple//定义一个三元组,用来存储稀疏矩阵的x,y,坐标值