稀疏矩阵的压缩存储
压缩存储值存储极少数的有效数据。使用{row,col,value}三元组存储每一个有效数据，三元组按原矩阵中的位置，以行优先级先后顺序依次存放。
压缩存储：行优先一行一行扫 有效数据存入以为矩阵_arr
列转置法 : 从前向后遍历压缩矩阵，先找列号为0的存入 转置矩阵的压缩矩阵.然后从前向后找列号为1的 。。。直到转置矩阵的压缩矩阵大小和 原矩阵的一样大 这时就找完了
时间复杂度为 O(原矩阵列数 * 压缩矩阵长度)
一次定位快速转置法：
设置两个辅助矩阵 RowCounts 和 RowStart
RowCounts 记录 原矩阵每列的有效元素元素的个数 （这里Row指的是转置矩阵的行 RowCount指的也就是转置矩阵 的 行有效元个数）
RowStart 记录的是 原矩阵 每列首个有效元素 在 转置矩阵 的压缩矩阵中的坐标 （也就是 转置矩阵 的 每行首个有效元素 在 转置矩阵 的压缩矩阵中的 坐标）
RowStart[n]可以由 RowCount[n-1]和上一个RowStart[n-1]求得 n>0
RowStart[0] = 0;
利用 RowStart 可以实现 由 原矩阵 的压缩矩阵元素 到 转置矩阵的压缩矩阵 的一次快速定位
如：
#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <assert.h>
#include <vector>
#include <string>
using namespace std;
/***
*
* 稀疏矩阵
* 压缩存储
* 转置 （一般 和 快速转置）
* 2016-4-18
* bozi
******************/
// 三元组
template<class T>
struct Triple
{
size_t _row;
size_t _col;
T _value;
Triple()
{}
Triple(size_t row, size_t col, T value)
:_row(row)
,_col(col)
,_value(value)
{}
};
// 稀疏矩阵
template<class T>
class SparesMatrix
{
public:
SparesMatrix();
SparesMatrix(const T* array, size_t row, size_t col, const T& invalid);
SparesMatrix<T> Transport(); //列转置
SparesMatrix<T> FastTransport(); //快速转置
void Display() const;
protected:
vector<Triple<T> > _array; // 动态数组存储稀疏矩阵
size_t _rowMatrix;
size_t _colMatrix;
T _invalid; // 定义的无效值
};
template<class T>
SparesMatrix<T>::SparesMatrix()
{}
template<class T>
SparesMatrix<T>::SparesMatrix(const T* array, size_t row, size_t col, const T& invalid)
:_rowMatrix(row)
,_colMatrix(col)
,_invalid(invalid)
{
for (size_t i = 0; i < _rowMatrix; i++)
{
for (size_t j = 0; j < _colMatrix; j++)
{
if (array[i * col + j] != invalid)
{
// _array.push_back({i, j, array[i * col + j]});
_array.push_back(Triple<T>(i, j, array[i * col + j]));
}
}
}
}
template<class T>
void SparesMatrix<T>::Display() const
{
size_t arr_size = _array.size();
assert(arr_size != 0);
size_t index = 0;
for (size_t i = 0; i < _rowMatrix; i++)
{
for (size_t j = 0; j < _colMatrix; j++)
{
if (index < arr_size && _array[index]._row == i && _array[index]._col == j)
{
cout<<_array[index]._value<<" ";
index++;
}
else
{
cout<<_invalid<<" ";
}
}
cout<<endl;
}
cout<<endl;
}
// 转置 （列转置法）
template<class T>
SparesMatrix<T> SparesMatrix<T>::Transport()
{
size_t arr_size = _array.size();
assert(arr_size != 0);
SparesMatrix<T> ret;
ret._rowMatrix = _colMatrix;
ret._colMatrix = _rowMatrix;
ret._invalid = _invalid;
ret._array.reserve(arr_size); // 先开辟这么大的空间 提高效率 防止后面push_back()每次不够还要开辟
// 在原来的 行优先的 数组_array中，每次遍历一遍，找到这次列号与对应 的列j相等的元素 将这个元素行列互换 存入ret._array
// 相当于 将 原数组的 行优先 转化为 列优先
// 原数组的列优先 就相当于 转置后矩阵的 行优先
for (size_t j = 0; j < _colMatrix; j++)
{
size_t index = 0;
while (index < arr_size)
{
if (_array[index]._col == j)
{
//ret._array.push_back({_array[index]._col, _array[index]._row, _array[index]._value});
ret._array.push_back(Triple<T>(_array[index]._col, _array[index]._row, _array[index]._value));
}
index++;
}
if (arr_size == ret._array.size())
{
break;
}
}
return ret;
}
template<class T>
SparesMatrix<T> SparesMatrix<T>::FastTransport() // 快速转置
{
size_t arr_size = _array.size();
assert(arr_size > 0);
size_t index = 0;
SparesMatrix<T> ret;
ret._rowMatrix = _colMatrix;
ret._colMatrix = _rowMatrix;
ret._invalid = _invalid;
ret._array.resize(arr_size);// 调整大小 （不能用reserve(只是空间变大 但Size没变) 而resize 是调整大小 两个都变）
// 两张辅助表
// RowCounts 记录原矩阵 每列的 非零元素
// RowStart 记录原矩阵 列优先时 每列 首个非零元的 坐标
// 用这两张表 可以马上把 _array数组中的元素 定位到 ret._array(新表)中
int* RowCounts = new int[_colMatrix];
int* RowStart = new int[_colMatrix];
memset(RowCounts, 0, _colMatrix * sizeof(int));
memset(RowStart, 0, _colMatrix * sizeof(int));
// 初始化RowCounts
for (size_t i = 0; i < arr_size; i++)
{
RowCounts[_array[i]._col]++; //【好方法 统计可以用到】 由列号找到对应RowCounts
}
RowStart[0] = 0;
// 初始化 RowStart （由 RowCount 求出 RowStart）
for (size_t i = 1; i < _colMatrix; i++) // 注意i 从1开始
{
RowStart[i] = RowStart[i - 1] + RowCounts[i - 1];
}
// 根据RowStart 将原矩阵_array中的元素 一次 快速 的 对应到 ret.array
for (size_t i = 0; i< arr_size; i++)
{
//ret._array[RowStart[array[i]._col]++] = {_array[i]._col, _array[i]._row, _array[i]._value};
// RowStart[_array[i]._col]++ 更新下一个元素 在 ret._array中的 位置
ret._array[RowStart[_array[i]._col]++] = Triple<T>(_array[i]._col, _array[i]._row, _array[i]._value);
}
delete[] RowCounts;
delete[] RowStart;
return ret;
}
void testSparseMatrix()
{
int array[6][5] =
{
{1, 0, 3, 0, 5 },
{0, 0, 0, 0, 0,},
{0, 0, 0, 0, 0,},
{1, 0, 3, 0, 5 },
{0, 0, 0, 0, 0,},
{0, 0, 0, 0, 0,},
};
SparesMatrix<int> s1((int*)array, 6, 5, 0);
s1.Display();
SparesMatrix<int> s2;
s2 = s1.Transport();
cout<<"转置后的矩阵为："<<endl;
s2.Display();
SparesMatrix<int> s3;
s3 = s1.FastTransport();
cout<<"快速转置后的矩阵为："<<endl;
s3.Display();
}
int main()
{
testSparseMatrix();
return 0;
}