稀疏矩阵-压缩存储-列转置法- 一次定位快速转置法

稀疏矩阵的压缩存储

压缩存储值存储极少数的有效数据。使用{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;

}