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)
		,_col(col)
		,_value(value)
	{}
};

template<class T>
class SparseMatrix
{
public:
	SparseMatrix(T* a = NULL, size_t M = 0, size_t N = 0, const T& invalid = T())
		:_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> t;
					t._row = i;
					t._col = j;
					t._value = a[i*N+j];

					_a.push_back(t);
				}
			}
		}
	}

	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<<" ";
				}
				else
				{
					cout<<_invalid<<" ";
				}
			}
			
			cout<<endl;
		}
	}

	//矩阵转置 时间复杂度为 O(有效数据的个数*原矩阵的列数)
	SparseMatrix<T> Transport()
	{
		SparseMatrix<T> sm;
		sm._colSize = _rowSize;
		sm._rowSize = _colSize;
		sm._invalid = _invalid;

		for (size_t i = 0; i < _colSize; ++i)
		{
			size_t index = 0;

			while (index < _a.size())
			{
				if (_a[index]._col == i)
				{
					Triple<T> t;
					t._row = _a[index]._col;
					t._col = _a[index]._row;
					t._value = _a[index]._value;

					sm._a.push_back(t);
				}

				++index;
			}
		}

		return sm;
	}

	//快速转置 时间复杂度为O(有效数据的个数+原矩阵的列数)
	SparseMatrix<T> FastTransport()
	{
		SparseMatrix<T> sm;
		sm._rowSize = _colSize;
		sm._colSize = _rowSize;
		sm._invalid = _invalid;

		int* RowCounts = new int[_colSize];
		int* RowStart = new int [_colSize];
		memset(RowCounts, 0, sizeof(int)*_colSize);
		memset(RowStart, 0, sizeof(int)*_colSize);
		
		size_t index = 0;
		while (index < _a.size())
		{
			++RowCounts[_a[index]._col];
			++index;
		}

		for (size_t i = 1; i < _colSize; ++i)
		{
			RowStart[i] = RowStart[i-1] + RowCounts[i-1];
		}

		index = 0;
		sm._a.resize(_a.size());
		while (index < sm._a.size())
		{
			Triple<T> t;
			t._row = _a[index]._col;
			t._col = _a[index]._row;
			t._value = _a[index]._value;

			sm._a[RowStart[_a[index]._col]] = t;

			++RowStart[_a[index]._col];
			++index;
		}

		delete[] RowCounts;
		delete[] RowStart;

		return sm;
	}
protected:
	vector<Triple<T>> _a;
	size_t _rowSize;
	size_t _colSize;
	T _invalid;
};

void Test()
{
	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}
	};

	SparseMatrix<int> sm1((int*)array, 6, 5, 0);
	sm1.Display();
	cout<<endl;
	//SprseMatrix<int> sm2 = sm1.Transport();
	SparseMatrix<int> sm2 = sm1.FastTransport();
	sm2.Display();
}

int main()
{
	Test();

	return 0;
}

本文出自 “zgw285763054” 博客，请务必保留此出处http://zgw285763054.blog.51cto.com/11591804/1775680

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

标签：矩阵   稀疏矩阵   

原文地址：http://zgw285763054.blog.51cto.com/11591804/1775680