特殊矩阵的压缩存储

最新推荐文章于 2020-07-20 16:03:13 发布
最新推荐文章于 2020-07-20 16:03:13 发布
阅读量607 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/windyblankboy/article/details/51558258
版权

  1. 对称矩阵及对称矩阵的压缩存储

  设一个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] == Array[i*(i+1)/2+j]。

spacer.gif 实现代码如下：

  

#include <iostream>
using namespace std;

template <class T>
class SymmetricMatrix
{
public:
	SymmetricMatrix(T * a, size_t size)
		:_a(new T[size*(size+1)/2])
		,_size(size*(size + 1) / 2)
		,_n(size)
	{
		size_t index = 0;
		for (size_t i = 0; i < size; i++)
		{
			for (size_t j = 0; j < size; j++)
			{
				if (i >= j)
				{
					_a[index++] = a[size*i + j];//按照一维数组的方式存入数据
				}
				else
				{
					break;
				}
			}
		}
	}
	~SymmetricMatrix()
	{
		if (_a)
		{
			delete[]_a;
			_a = NULL;
			_size = 0;
		}
	}
	T& Access(size_t i, size_t j)
	{
		if (i < j)
		{
			swap(i, j);//当是上三角时，交换i和j
		}
		return _a[i*(i + 1) / 2 + j];
	}
	void display()
	{
		for (size_t i = 0; i < _n; i++)
		{
			for (size_t j = 0; j < _n; j++)
			{
				if (i >= j)
				{
					cout << _a[i*(i + 1) / 2 + j] << " ";
				}
				else
				{
					cout << _a[j*(j + 1) / 2 + i] << " ";
				}
			}
			cout << endl;
		}
	}
protected:
	size_t _size;//存储数据的个数
	T * _a;//存储之后的对称矩阵的指针
	size_t _n;//对称矩阵的大小
};

2.稀疏矩阵

 M*N的矩阵，矩阵中有效值的个数远小于无效值的个数，且这些数据的分布没有规律。

 比如下面这个矩阵：

 wKioL1cUekXTHIOVAAAJWXulRyo033.png

spacer.gif （1）稀疏矩阵的压缩存储

   压缩存储只存储极少数的有效数据。使用{row,col,value}三元组存储每一个有效数据，三元组按原矩阵中的位置，以行优先级先后顺序依次存放。

  那么上面的矩阵压缩存储结果就是：

  wKiom1cUefrgD4A3AAAEUJora9M325.png

  三元组的定义：

   

template<typename T>
struct Triple//三元组
{
	Triple<T>::Triple()//无参的构造函数
	{

	}

	Triple(size_t row, size_t col, T value)//构造函数
		:_row(row)
		,_col(col)
		,_value(value)
	{

	}

	size_t _row;//行
	size_t _col;//列
	T _value;//值

};

 压缩存储的实现代码：

template<typename T>
class SparseMatrix
{
public:

	SparseMatrix()
	{

	}
        //用vector顺序表来存储三元组的信息 
	SparseMatrix(T * a, size_t m, size_t n, const T & invalid)
		:_rowsize(m)
		,_colsize(n)
		,_invalid(invalid)
	{
		for (size_t i = 0; i < m; i++)
		{
			for (size_t j = 0; j < n; j++)//按照二元数组的方式进行遍历
			{
				if (a[i*n + j] != invalid)//不是无效数据
				{
					Triple<T> cur(i, j, a[i*n + j]);
					_a.push_back(cur);
				}
			}
		}
	}
protected:
	vector <Triple<T>> _a;
	size_t _rowsize;
	size_t _colsize;
	T _invalid;
};

 （2）稀疏矩阵的转置

   将原矩阵的行、列对换，也就是将[i][j]和[j][i]位置上的数据对换。

 wKioL1cUfJXBya7rAAAW17qk6v4073.png

  普通转置（列转置）

    按照原矩阵的列优先把vector中的三元组放入新的容器中，并且交换行和列的值

	SparseMatrix<T> Transport()
	{
		assert(_a.size() < 0);
		//创建新的矩阵，交换行列的值
		SparseMatrix<T> ret;
		ret._rowsize = _colsize;
		ret._colsize = _rowsize;
		ret._invalid = _invalid;
		//两次循环
		for (size_t i = 0; i < _colsize; i++)//按原矩阵的列扫描
		{
			size_t index = 0;
			while (index < _a.size())
			{
				if (_a[index]._col == i)
					//如果三元组中的列值=i时
					//交换行列的值，放入新的矩阵
				{
					Triple<T> tmp(_a[index]._col, _a[index]._row, _a[index]._value);
					ret._a.push_back(tmp);
				}
				index++;
			}
			if (_a.size() == ret._a.size())
			{
				break;//两个容器的大小相同时，break
			}
		}
		return ret;
	}

  用此方法可以有效的转置矩阵，我们来看一下此函数的时间复杂度：O(col * _a.size())——矩阵的列*矩阵的元素总和。

   如果元素很多就会浪费很多的时间。有没有办法让两层循环变成一层循环呢？付出空间上的代价，换取时间效率。

  快速转置

  我们只用一层循环来遍历容器_a中所有元素，并把该元素放到指定的位置。这样我们就需要一个数组rowStar来存放第i个元素所在位置。在定义这个数组之前，我们还需要一个数组rowCount来实现统计矩阵第i行元素的数量。这样我们才能更方便的知道第i个元素应该存放的位置。

       wKioL1cUgh7xfJ6XAAAl71YfXUA333.png实现代码如下：

SparseMatrix<T> FastTransport()
	{
		assert(_a.size() > 0);
		SparseMatrix<T> ret;

		ret._rowsize = _colsize;//行列值互换
		ret._colsize = _rowsize;
		ret._invalid = _invalid;

		int * rowCount = new int[_colsize];
		int * rowStart = new int[_colsize];
		//初始化rowCount和rowStart为0
		memset(rowCount, 0, sizeof(int)* _colsize);
		memset(rowStart, 0, sizeof(int) * _colsize);
		//初始化
		size_t index = 0;
		while (index < _a.size())
		{
			rowCount[_a[index]._col]++;
			++index;
		}
		rowStart[0] = 0;
		for (size_t i = 1; i < _colsize; i++)
		{
			rowStart[i] = rowStart[i - 1] + rowCount[i - 1];
		}

		ret._a.resize(_a.size());//复制顺序表_a，容量相同
		index = 0;
		Triple<T> tmp;
		while (index < _a.size())
		{
			size_t rowIndex = _a[index]._col;//行数
			size_t row = rowStart[rowIndex];//当前行的起始位置

			//交换行和列
			tmp._col = _a[index]._row;
			tmp._row = _a[index]._col;
			tmp._value = _a[index]._value;

			ret._a[row] = tmp;//将tmp放入ret计算好的位置
			rowStart[row]++;
			index++;
		}
		delete[] rowCount;
		delete[] rowStart;
		return ret;
	}

此函数的时间复杂度为O(col + _a.size())；和普通转置相比，效率提高了很多。

最后，附上完整代码（稀疏矩阵）：

#pragma once

#include <iostream>
#include <vector>
#include <assert.h>
using namespace std;

template<typename T>
struct Triple//三元组
{
	Triple<T>::Triple()//无参的构造函数
	{

	}

	Triple(size_t row, size_t col, T value)
		:_row(row)
		,_col(col)
		,_value(value)
	{

	}

	size_t _row;//行
	size_t _col;//列
	T _value;//值

};

template<typename T>
class SparseMatrix
{
public:

	SparseMatrix()//无参的构造函数
	{

	}
        //用vector顺序表来存储三元组的信息
	SparseMatrix(T * a, size_t m, size_t n, const T & invalid)
		:_rowsize(m)
		,_colsize(n)
		,_invalid(invalid)
	{
		for (size_t i = 0; i < m; i++)
		{
			for (size_t j = 0; j < n; j++)
			{
				if (a[i*n + j] != invalid)
				{
					Triple<T> cur(i, j, a[i*n + j]);
					_a.push_back(cur);
				}
			}
		}
	}

	void Display()//打印矩阵
	{
		size_t index = 0;
		for (size_t i = 0; i < _rowsize; i++)
		{
			for (size_t j = 0; j < _colsize; j++)
			{
				if ((index < _a.size()) && _a[index]._row == i&&_a[index]._col == j)
				{
					cout << _a[index]._value << " ";
					index++;
				}
				else
				{
					cout << _invalid << " ";
				}
			}
			cout << endl;
		}	
		cout << endl;
	}

	//普通转置
	SparseMatrix<T> Transport()
	{
		assert(_a.size() 》 0);
		//创建新的矩阵，交换行列的值
		SparseMatrix<T> ret;
		ret._rowsize = _colsize;
		ret._colsize = _rowsize;
		ret._invalid = _invalid;
		//两次循环
		for (size_t i = 0; i < _colsize; i++)//按原矩阵的列扫描
		{
			size_t index = 0;
			while (index < _a.size())
			{
				if (_a[index]._col == i)
					//如果三元组中的列值=i时
					//交换行列的值，放入新的矩阵
				{
					Triple<T> tmp(_a[index]._col, _a[index]._row, _a[index]._value);
					ret._a.push_back(tmp);
				}
				index++;
			}
			if (_a.size() == ret._a.size())
			{
				break;//两个容器的大小相同时，break
			}
		}
		return ret;
	}

	//快速转置
	SparseMatrix<T> FastTransport()
	{
		assert(_a.size() > 0);
		SparseMatrix<T> ret;

		ret._rowsize = _colsize;//行列值互换
		ret._colsize = _rowsize;
		ret._invalid = _invalid;

		int * rowCount = new int[_colsize];
		int * rowStart = new int[_colsize];
		//初始化rowCount和rowStart为0
		memset(rowCount, 0, sizeof(int)* _colsize);
		memset(rowStart, 0, sizeof(int) * _colsize);
		//初始化
		size_t index = 0;
		while (index < _a.size())
		{
			rowCount[_a[index]._col]++;
			++index;
		}
		rowStart[0] = 0;
		for (size_t i = 1; i < _colsize; i++)
		{
			rowStart[i] = rowStart[i - 1] + rowCount[i - 1];
		}

		ret._a.resize(_a.size());//复制顺序表_a，容量相同
		index = 0;
		Triple<T> tmp;
		while (index < _a.size())
		{
			size_t rowIndex = _a[index]._col;//行数
			size_t row = rowStart[rowIndex];//当前行的起始位置

			//交换行和列
			tmp._col = _a[index]._row;
			tmp._row = _a[index]._col;
			tmp._value = _a[index]._value;

			ret._a[row] = tmp;//将tmp放入ret计算好的位置
			rowStart[row]++;
			index++;
		}
		delete[] rowCount;
		delete[] rowStart;
		return ret;
	}

protected:
	vector <Triple<T>> _a;//容器
	size_t _rowsize;//行
	size_t _colsize;//列
	T _invalid;//非法值
};


void Test()
{
	int array[5][4] =
	{
		{ 1, 0, 3, 0, },
		{ 0, 0, 0, 0, },
		{ 0, 0, 0, 0, },
		{ 1, 0, 3, 0, },
		{ 0, 0, 0, 0, },
	};
	SparseMatrix<int> sm((int*)array, 5, 4, 0);
	sm.Display();

	SparseMatrix<int> sm1;
	sm1 = sm.FastTransport();
	cout << "转置后的矩阵为： " << endl << endl;
	sm1.Display();
}

wKioL1cUhT3hX2QwAAALrbRRIoc772.png

本文出自 “不断进步的空间” 博客，请务必保留此出处http://10824050.blog.51cto.com/10814050/1765046

windyblankboy
关注
特殊矩阵压缩存储
CYBCLOUD的博客
08-27 307
目录 1.对称矩阵的压缩存储 2.三角矩阵的压缩存储 3. 三对角矩阵的压缩存储 4.稀疏矩阵的压缩存储 1.对称矩阵的压缩存储 2.三角矩阵的压缩存储 3. 三对角矩阵的压缩存储 4.稀疏矩阵的压缩存储 ...
矩阵的压缩存储--特殊矩阵--三角矩阵
MyCyber
12-10 3023
矩阵的压缩存储–特殊矩阵–三角矩阵三角矩阵大体分为三类：对称矩阵、下三角矩阵和上三角矩阵。#include <stdio.h> #include <stdlib.h> #define N 100 int a[N][N], sa[2*N]; int main(void) { int i, j, k; int n, m; printf("请输入矩阵的行数和列数： ");
特殊矩阵的压缩存储算法2
09-25
编写一个程序，实现对称矩阵、上（下）三角矩阵、三对角矩阵的压缩存储，要求具有如下功能： （1）输入：以行序为主序输入矩阵的全部元素，压缩存储于一维数组中。 （2）输出：顺序输出压缩存储于一维数组中的矩阵元素。 （3）简单算术运算：利用压缩存储的数据实现两个特殊矩阵（属于同一类特殊矩阵）的加法运算，并输出运算结果。
特殊矩阵压缩存储与计算-结课作业
10-07
针对多种特殊矩阵(对称矩阵、三角矩阵、对角矩阵)进行压缩存储，并能显示压缩后的相关地址和值
特殊矩阵压缩存储代码.cpp
11-29
https://blog.csdn.net/swq463/article/details/85851718 对应的代码
特殊矩阵压缩存储算法设计与实现
特殊矩阵的压缩存储是一种优化矩阵存储和计算效率的方法，可以降低矩阵存储的空间复杂度，并提高矩阵运算的效率。本文旨在设计并实现特殊矩阵的压缩存储算法，包括对称矩阵、三角矩阵和对角矩阵的压缩存储方法，以及...
数据结构-特殊矩阵压缩存储
这份PPT涵盖了数据结构的基础知识，特别是特殊矩阵的压缩存储，同时也强调了数据结构在实际应用中的重要性和算法设计的考虑因素。对于学习数据结构和算法的学生来说，这是一个非常有价值的资源。
特殊矩阵的压缩存储.cpp
06-16
特殊矩阵的压缩存储，包含对称矩阵，上下三角矩阵，对角矩阵，稀疏矩阵
矩阵压缩1
05-17
矩阵压缩<br/>用结构体数组来处理,结构体数组中包含两种结构;
编程基础 - 特殊矩阵的压缩存储 (Compressed Storage of Special Matrix)
DarkRabbit的专栏
04-26 657
本文将用C++实现特殊方阵和稀疏矩阵的压缩存储。 在查看本文之前，需要一些程序语言的基础，还要对“矩阵”与“二维数组”有一定了解。
特殊矩阵的压缩存储（节约内存空间）
ChanCherry的博客
03-20 907
边看网课边记的笔记，比较简单，以后遇到详细的再补充，也欢迎大家评论补充！ 特殊矩阵简介 存储方案 三角矩阵和带状矩阵：顺序存储； 稀疏矩阵：（1）三元组顺序表（顺序存储） （2）十字链表（链式存储） 1. 三角矩阵 三角矩阵分为上三角矩阵和下三角矩阵，只需要存储非零元素。 第i行有i个非零元素。于是我们可以得到： LOC(i,j) = LOC(1,1) + 前i-1行非零元素个数*size...
数据结构学习笔记之用数组对特殊矩阵压缩存储
御承扬的博客
07-20 730
用数组对特殊矩阵压缩存储一、数组1、定义2、与线性表的关系3、存储结构二、特殊矩阵的压缩存储1、特殊矩阵2、对称阵的压缩存储3、三角阵的压缩存储 一、数组 1、定义 数组是由 n(n>=1) 个相同类型的元素构成的有限序列，每个元素在 n 个线性关系中的序号称为该元素的下标，下标的取值范围称为数组的维界。 2、与线性表的关系 数组可以视为线性表的推广，一维数组就是一个线性表，二维数组则是一个元素为定长线性表的线性表，以此类推。 数组一旦定义，其维数和维界便固定下来了，除去结构的初始化和销毁，数组
3.4特殊矩阵和压缩矩阵
BossHAO的博客
08-20 773
3.4特殊矩阵和压缩矩阵 类比数组： 一维数组： 二维数组，采用映射的方法：按行优先和按列优先 行优先： 列优先： 矩阵的压缩存储 矩阵的压缩存储：指多个值相同的元素只分配一个存储空间，队零元素不分配存储空间。 特殊矩阵：指具有许多相同矩阵元素或零元素，并且这些相同矩阵元素或者零元素的分布具有一定规律的矩阵。（对称矩阵、上（下）三角矩阵、对角矩阵） 对称矩阵 ：若一个n阶方阵A[1…n][1...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值