矩阵压缩存储

最新推荐文章于 2024-02-14 19:41:41 发布
最新推荐文章于 2024-02-14 19:41:41 发布
阅读量372 收藏
点赞数
分类专栏： 数据结构 文章标签： 矩阵压缩存储 三元组顺序表 行逻辑链接 十字链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/The_Only_God/article/details/102289150
版权

文章目录

矩阵压缩存储

三元组顺序表+行逻辑链接

数据结构

const int MAX_SIZE = 1000;
const int MAX_SIZE_OF_ROW = 100;
typedef struct {
 int i, j;//行标、列标
 int e;//元素
}Triple;
typedef struct {
 Triple data[MAX_SIZE];//数据
 int rpos[MAX_SIZE_OF_ROW];//各行第一个非零元的位置(行逻辑链接)
 int mu, nu, tu;//行数、列数、非零元个数
}RLTMatrix;//三元组顺序表
RLTMatrix

矩阵转置

行列交换+重新排序

普通方法

按列查找、放入

快速转置

建立每列第一个非零元对应的三元组顺序表的行号的数组，逐个遍历三元组顺序表放入相应位置。（类似于计数排序）

矩阵乘法

公式: M ( i , j ) = ∑ k = 1 n L 1 ( i , k ) ∗ L 2 ( k , j ) M(i,j)=\sum_{k=1}^nL1(i,k)*L2(k,j) M(i,j)=∑k=1n​L1(i,k)∗L2(k,j)
( 1 ≤ i ≤ m 1 , 1 ≤ j ≤ n 2 ) (1\leq i \leq m_1 ,1\leq j \leq n_2) (1≤i≤m1​,1≤j≤n2​)

源码

#include<iostream>
#include<stdlib.h>
using namespace std;
const int MAX_SIZE = 1000;
const int MAX_SIZE_OF_ROW = 100;
typedef struct {
 int i, j;//行标、列标
 int e;//元素
}Triple;
typedef struct {
 Triple data[MAX_SIZE];//数据
 int rpos[MAX_SIZE_OF_ROW];//各行第一个非零元的位置
 int mu, nu, tu;//行数、列数、非零元个数
}RLTMatrix;//三元组顺序表
RLTMatrix CreatTMatrix(int** x, int m, int n)//构建三元组形式的矩阵
{
 int i,*num;
 num = new int[m];
 for (i = 0; i < m; i++) num[i] = 0;
 RLTMatrix T;
 T.mu = m;
 T.nu = n;
 T.tu = 0;
 for(i=0;i<m;i++)
  for (int j = 0; j < n; j++)
   if (x[i][j] != 0)
   {
    T.data[T.tu].i = i;
    T.data[T.tu].j = j;
    T.data[T.tu].e = x[i][j];
    T.tu++;
    num[i]++;
   }
 T.rpos[0] = 0;
 for (i = 1; i < m; i++) T.rpos[i] = T.rpos[i - 1] + num[i - 1];//获得rpos
 return T;
}
void PrintTMatrix(RLTMatrix T)//打印三元组
{
 int i, j;
 cout << "三元组" << endl;
 for (i = 0; i < T.tu; i++)
  cout << T.data[i].i << ' ' << T.data[i].j << ' ' << T.data[i].e << endl;
 cout << "rpos" << endl;
 for (i = 0; i < T.mu; i++)
  cout << i << ' ' << T.rpos[i] << endl;
}
RLTMatrix FastTransposeRLTMatrix(RLTMatrix T)//三元组矩阵快速转置
{
 int i, j, * num, * cpos;
 RLTMatrix M;
 M.mu = T.nu;
 M.nu = T.mu;
 M.tu = T.tu;
 if (T.tu <= 0) return M;
 num = new int[T.nu];
 cpos = new int[T.nu];
 for (i = 0; i < T.nu; i++) num[i] = 0;
 for (i = 0; i < T.tu; i++) num[T.data[i].j]++;
 for (M.rpos[0]=cpos[0] = 0, i = 1; i < T.nu; i++)
 {
  cpos[i] = cpos[i - 1] + num[i - 1];//每列第一个非零元的序号
  M.rpos[i] = cpos[i];
 }
 for (i = 0; i < T.tu; i++)
 {
  int row = cpos[T.data[i].j]++;
  M.data[row].i = T.data[i].j;
  M.data[row].j = T.data[i].i;
  M.data[row].e = T.data[i].e;
 }
 return M;
}
RLTMatrix MultRLTMatrix(RLTMatrix T1, RLTMatrix T2)//三元组矩阵乘法
{
 int i, * temp;
 RLTMatrix M;
 M.mu = T1.mu; M.nu = T2.nu; M.tu = 0;
 if (T1.tu * T2.tu == 0 || T1.nu != T2.mu) return M;
 temp = new int[T1.nu];
 for (i = 0; i < T1.mu; i++)//一行一行的确定相乘后的元素
 {
  int j, l, r;
  M.rpos[i] = M.tu;//设置三元组矩阵的行逻辑
  for (j = 0; j < T1.nu; j++) temp[j] = 0;//初始化各列元素累加器
  l = T1.rpos[i];
  if (i < T1.mu - 1) r = T1.rpos[i + 1];
  else if (i == T1.mu - 1) r = T1.tu ;
  for (; l < r; l++)
  {
   int k = T1.data[l].j;
   int ll, rr;
   ll = T2.rpos[k];
   if (k < T2.mu - 1) rr = T2.rpos[k + 1];
   else rr = T2.tu;
   for (; ll < rr; ll++)
    temp[T2.data[ll].j] += T1.data[l].e * T2.data[ll].e;
  }
  for(j=0;j<T1.nu;j++)//将结果压缩到三元组矩阵内
   if (temp[j])
   {
    M.data[M.tu].i = i;
    M.data[M.tu].j = j;
    M.data[M.tu++].e = temp[j];
   }
 }
 return M;
}
int main()
{
 int i;
 int** x, ** y, m, n;
 RLTMatrix T1, T2, M;
 cout << "请输入矩阵一：" << endl;
 cin >> m >> n;
 x = new int* [m];
 for (i = 0; i < m; i++) x[i] = new int[n];
 for (i = 0; i < m; i++)
  for (int j = 0; j < n; j++)
   cin >> x[i][j];
 T1 = CreatTMatrix(x, m, n);
 cout << "请输入矩阵二：" << endl;
 cin >> m >> n;
 y = new int* [m];
 for (i = 0; i < m; i++) y[i] = new int[n];
 for (i = 0; i < m; i++)
  for (int j = 0; j < n; j++)
   cin >> y[i][j];
 T2 = CreatTMatrix(y, m, n);
 cout << "矩阵一、二：" << endl;
 PrintTMatrix(T1);
 PrintTMatrix(T2);
 cout << "转置后矩阵一" << endl;
 M = FastTransposeRLTMatrix(T1);
 PrintTMatrix(M);
 M = MultRLTMatrix(T1, T2);
 cout << "乘积矩阵为：" << endl;
 PrintTMatrix(M);
 return 0;
}

十字链表

数据结构

typedef struct Node {
 int i, j;
 int e;
 struct Node* right, * down;
}Node,*Link;//十字链表的一个结点
typedef struct {
 Link* rHead,* cHead;
 int mu, nu, tu;
}CrossList;//十字链表
void Cr

矩阵加法

源码

#include<iostream>
#include<stdlib.h>
using namespace std;
typedef struct Node {
 int i, j;
 int e;
 struct Node* right, * down;
}Node,*Link;//十字链表的一个结点
typedef struct {
 Link* rHead,* cHead;
 int mu, nu, tu;
}CrossList;//十字链表
void CrossListInsertNode(CrossList& L, Link& node)//Insert a new node into the CrossList 
{
 int i, j;
 i = node->i; j = node->j;
 //insert row
 if (L.rHead[i] == NULL || L.rHead[i]->j > j)
 {
  node->right = L.rHead[i];
  L.rHead[i] = node;
 }
 else
 {
  Link p;
  for (p = L.rHead[i]; p->right && p->right->j <= j; p = p->right);
  if (p->j == j)//该位置已有结点，进行加法操作
  {
   p->e += node->e;
   free(node);
   return;
  }
  else
  {
   node->right = p->right;
   p->right = node;
  }
 }
 //insert column
 if (L.cHead[j] == NULL || L.cHead[j]->i < i)
 {
  node->down = L.cHead[j];
  L.cHead[j] = node;
 }
 else
 {
  Link p;
  for (p = L.cHead[j]; p->down && p->down->i < i; p = p->down);
  node->down = p->down;
  p->down = node;
 }
 L.tu++;
}
CrossList CreatCrossList(int** x, int m, int n)
{
 int i, j;
 CrossList L;
 L.mu = m;
 L.nu = n;
 L.tu = 0;
 L.rHead = (Link*)malloc(m * sizeof(Link));
 L.cHead = (Link*)malloc(n * sizeof(Link));
 for (i = 0; i < m; i++) L.rHead[i] = NULL;
 for (i = 0; i < n; i++) L.cHead[i] = NULL;
 for(i=0;i<m;i++)
  for(int j=0;j<n;j++)
   if (x[i][j])
   {
    Link newNode = (Link)malloc(sizeof(Node));
    newNode->i = i;
    newNode->j = j;
    newNode->e = x[i][j];
    CrossListInsertNode(L,newNode);
   }
 return L;
}
CrossList AddCrossListMatrix(CrossList l1, CrossList l2)
{
 int i, j;
 CrossList L;
 L.cHead = NULL; L.rHead = NULL;
 L.mu = 0; L.nu = 0; L.tu = 0;
 if (l1.mu != l2.mu || l1.nu != l2.nu) return L;//These two matrices can`t be added
 L.mu = l1.mu; L.nu = l1.nu;
 L.rHead = (Link*)malloc(L.mu*sizeof(Link));
 L.cHead = (Link*)malloc(L.nu * sizeof(Link));
 for (i = 0; i < L.mu; i++) L.rHead[i] = NULL;
 for (i = 0; i < L.nu; i++) L.cHead[i] = NULL;
 if (l1.tu == 0 && l2.tu == 0) return L;//Both matrixes are null
 for (i = 0; i < L.mu;i++)
 {
  Link p1, p2;
  p1 = l1.rHead[i];
  p2 = l2.rHead[i];
  while (p1 || p2)
  {
   Link node1, node2;
   node1 = (Link)malloc(sizeof(Node));
   node2 = (Link)malloc(sizeof(Node));
   node1->i = i; node2->i = i;
   if (p2 == NULL)
   {
    node1->j = p1->j;
    node1->e = p1->e;
    CrossListInsertNode(L, node1);
    p1 = p1->right;
   }
   else if (p1 == NULL)
   {
    node1->j = p2->j;
    node1->e = p2->e;
    CrossListInsertNode(L, node1);
    p2 = p2->right;
   }
   else
   {
    node1->j = p1->j;
    node2->j = p2->j;
    if (p1->j == p2->j)
    {
     node1->e = p1->e + p2->e;
     CrossListInsertNode(L, node1);
    }
    else
    {
     node1->e = p1->e;
     node2->e = p2->e;
     CrossListInsertNode(L, node1);
     CrossListInsertNode(L, node2);
    }
    p1 = p1->right;
    p2 = p2->right;
   }
  }
 }
 return L;
}
void PrintMatrix(CrossList L)
{
 int i, * x;
 x = new int[L.nu];
 for (i = 0; i < L.mu; i++)
 {
  int j;
  Link p;
  for (j = 0; j < L.nu; j++) x[j] = 0;
  for (p = L.rHead[i]; p; p = p->right) x[p->j] = p->e;
  for (j = 0; j < L.nu - 1; j++) cout << x[j] << ' ';
  cout << x[L.nu - 1] << endl;
 }
  
}
int main()
{
 CrossList l1, l2;
 int** x;
 int i, m, n;
 cout << "请输入矩阵一：" << endl;
 cin >> m >> n;
 x = new int* [m];
 for (i = 0; i < m; i++) x[i] = new int[n];
 for (i = 0; i < m; i++)
  for (int j = 0; j < n; j++)
   cin >> x[i][j];
 l1 = CreatCrossList(x, m, n);
 cout << "请输入矩阵二：" << endl;
 cin >> m >> n;
 x = new int* [m];
 for (i = 0; i < m; i++) x[i] = new int[n];
 for (i = 0; i < m; i++)
  for (int j = 0; j < n; j++)
   cin >> x[i][j];
 l2 = CreatCrossList(x, m, n);
 CrossList l3 = AddCrossListMatrix(l1, l2);
 cout << "两矩阵和为" << endl;
 PrintMatrix(l3);
 return 0;
}
The_Only_God
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
矩阵的压缩存储
静无需言
05-29 1355
定义: 对相同的 元 只分配一个存储空间;对 0 元不分配存储空间. 对称矩阵压缩存储(适用于三角矩阵):     可以将n^2个元 压缩到 n(n+1)/2  个空间的中.(存储(上/下)三角和对角线)     所以可以压缩到一纬数组Sa[k]中, 和矩阵a(i,j)对应关系如下:                 {  i(i-1)/2+j-1     i
9.矩阵的压缩存储
Liaily的博客
03-18 874
1.一维数组的存储结构 各数组元素大小相同，且物理上连续存放。 数组元素a[i]的存放地址 = LOC + i * sizeof(Elem Type) (0<=i<=10) 2.二维数组的存储结构 起始地址：LOC 为了把非线性的二维数组变成线性形状定义了两种存储原则： M行N列的二维数组b[M] [N]中， 若按行优先存储，则b[i] [j] 的存储地址 = LOC + (i*N + j) * sizeof(ElemType), 若按列优先存储，则b[i] [j] 的存
【数据结构】特殊矩阵的压缩存储|保姆级详解+图解
Yaoyao2024的博客
04-05 7543
在线性代数这门学科中已经学习了矩阵。在高级计算机语言中，矩阵常用二维数组表示。所谓**“压缩存储”**，目的在于节省空间！体现在，为多个值相同的元素只分配一个存储空间，多元素值为0的元素不分配空间二维数组A[n][n]和的写法是等价的。如果数组写法为,则说明指定了下标是从1开始存储元素。二维数组元素写为a[i][j],注意数组元素下标i和j通常是从0开始的。矩阵元素通常写为a i,j或者a(i),(j)，注意这时的i和j代表的行号和列号，都是从1开始的！这里我们讨论两种特殊矩阵。
5.3矩阵的压缩存储（稀疏矩阵转置和快速转置）
IT1995的博客
02-09 3万+
5.3矩阵的压缩存储（稀疏矩阵转置和快速转置）
【数据结构】矩阵的压缩存储
WINGREZ‘S BLOG
09-10 4527
参考资料：《数据结构（C语言版）严蔚敏著》 版权说明：未经作者允许，禁止转载。如引用本文内容，需标明作者及出处。如本文侵犯了您的权益，请联系我删除并致歉。 文章说明：如文章中出现错误，请联系我更改。如您对文章的内容有任何疑问，也欢迎来与我讨论。 本文正在施工中...请稍等... 矩阵的压缩存储 对称矩阵 若n阶矩阵A中的元满足性质，则称为n阶对称矩阵。对于对称矩阵，为每一对对称元素只分配一个...
C++ 实现稀疏矩阵的压缩存储的实例
08-29
C++ 实现稀疏矩阵的压缩存储的实例 本文主要介绍了C++ 实现稀疏矩阵的压缩存储的实例的相关资料，...本文详细讲解了C++ 实现稀疏矩阵的压缩存储的实例的实现过程，为读者提供了一个实用的稀疏矩阵压缩存储的解决方案。
对角矩阵压缩存储
08-05
### 对角矩阵压缩存储详解 #### 一、对角矩阵概览 对角矩阵是一种特殊类型的矩阵，其特征在于非零元素主要分布在主对角线及其附近的一系列对角线上，而其他位置上的元素均为零。具体而言，这类矩阵可以分为几种...
矩阵压缩存储和快速转置
10-31
实现矩阵的压缩存储，并实现快速转置，大大减少了转置的时间复杂度。
三对角矩阵压缩存储 转置.doc
07-05
【三对角矩阵压缩存储与转置】 在计算机科学中，矩阵运算是一项基本任务，尤其在数值计算和线性代数领域。对于特定类型的矩阵，如三对角矩阵，可以采用压缩存储的方式来优化内存占用和计算效率。三对角矩阵是指除主...
矩阵压缩存储之稀疏矩阵详解（C语言版）.rar
09-20
因此，稀疏矩阵的压缩存储方法应运而生，其目的是以更节省空间的方式存储和操作这些矩阵。 C语言中实现稀疏矩阵的常见方法是采用三元组表（Triples）或压缩行存储（Compressed Row Storage, CRS）。这里我们将主要...
数据结构进阶(二)矩阵（稀疏矩阵）的压缩存储
热门推荐
IT全栈 华强工作室
05-02 6万+
矩阵（稀疏矩阵）的压缩存储注 本文转载地址:http://blog.163.com/zhoumhan_0351/blog/static/39954227201001112526244/ 为了节省存储空间并且加快处理速度，需要对这类矩阵进行压缩存储，压缩存储的原则是：不重复存储相同元素；不存储零值元素。一、相关概念㈠特殊矩阵 矩阵中存在大多数值相同的元,或非0元，且在矩...
压缩矩阵
qq_41683305的博客
02-25 5150
压缩矩阵：指为多个值相同的元素只分配一个存储空间，对零元素不分配存储空间 特殊矩阵：指具有许多相同矩阵元素或零元素，并且这些相同矩阵元素或零元素的分配有一定规律性 1、对称矩阵 对称矩阵：矩阵每个元素都有aij=aji 压缩方法：将对称矩阵存放到一维数组B[n(n+1)/2]中，第一行先存，依次向下，只存放主对角线和下三角线的元素 元素aij在数组B中的下标k=1+2+…+（i-1）+j-1...
数据结构与算法之矩阵的压缩存储
five-five
06-12 5706
M 行 N 列的二维数组 b[M][N] 中，若按照行优先存储，则 的存储地址=可用二维数组存储注意：描述矩阵元素时，行、列号通常从 1 开始；而描述数组时通常下标从 0 开始（具体看题目给出的条件，注意审题！）分类：稀疏矩阵方阵：某些特殊矩阵可以压缩存储空间定义：若 n 阶方阵中任意一个元素 a[i][j]=a[j][i]，则该矩阵称为对称矩阵普通存储：n*n 二维数组压缩存储策略：只存储主对角线 + 下三角区 以 该策略 为例，按行优先原则将各元素存入一维数组中。 等差数列公式： ^7kygmb可以实
数据结构-数组与压缩矩阵
11-20 7511
数组的定义 数组是由n(n&gt;1)个具有相同数据类型的数据元素a1...an组成的有序序列，且该序列必须存储在一块地址连续的存储单元中。 1.数组中的数组元素就有相同的数据类型 2.数组是一种随机存取结构，给定一组下标就可以访问与其对应的数据元素。 3.数组中的数据元素个数是固定的。   行向量的一位数组形式 列向量的一位数组形式   数组的两种顺序存储方式 1.行...
矩阵的压缩存储（与解压缩）
最新发布
2301_79070589的博客
02-14 325
压缩：待压缩矩阵为二维数组a，用以为数组x用来存储压缩后的矩阵，矩阵中的常数c存储在x[0]，a[ij]存储在x[n]中——n=[1+2+...+(i-2)]+(j+1)-1+1=(i-1)(i-2)/2+j+1，一维数组x的最后一个元素存储为1（若为下三角矩阵则存储为2）。解压缩：假设压缩后的数据存储在数组x中，建立一个二维数组y(即矩阵)，将数组x中的数据按顺序存储在二维数组y的下三角区，然后再通过a(ji)=a(ij)来补充二维数组y(即矩阵)对称矩阵，对角矩阵，三角矩阵，稀疏矩阵的压缩与解压缩。
c/c++ 显示图形二叉树
The_Only_God的博客
12-01 1970
文章目录头文件数据结构 头文件 #include<easyx.h> #include<conio.h> easyx库下载地址link 数据结构 二叉链表 typedef struct BSTNode { int key; BSTNode* lchild, * rchild; }BSTNode,*BSTree;//二叉树结点 ...
稀疏矩阵压缩存储方法
12-25
稀疏矩阵压缩存储方法是一种优化矩阵存储空间的方法，它只存储非零元素及其对应的行列索引。常见的稀疏矩阵压缩存储方法有三种：COO（Coordinate），CSR（Compressed Sparse Row）和CSC（Compressed Sparse Column）...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值