稀疏矩阵的压缩存储

#include <vector>
#include <iostream>	
using namespace std;
template<class T>
class SparseMatrix
{
public:
	// 稀疏矩阵的压缩存储
	SparseMatrix(int* array, size_t row, size_t col, const T& invalid)
		: _row(row)
		, _col(col)
		, _invalid(invalid)
	{
		for (size_t i = 0; i < row; ++i)
		{
			for (size_t j = 0; j < col; ++j)
			{
				if (array[i*col+j] != invalid)
				{
					Trituple<T> a(i, j, array[i*col + j]);
					_sm.push_back(a);
				}
			}
		}
	}

	SparseMatrix()
	{}

	// 访问稀疏矩阵中row行col中的元素
	T& Access(int row, int col)
	{
		遍历数组两种方法
		1.for循环
		2.迭代器
		//vector<Trituple<T>>::iterator it = _sm.begin();

		//while (it != _sm.end())
		//{
		//	if (it->_row == row&&it->_col == col)
		//	{
		//		return it->_data;
		//	}
		//	it++;
		//}
		//return _invalid;
		for (size_t i = 0; i < _sm.size(); ++i)
		{
			if (_sm[i]._row == row&&_sm[i]._col == col)
			{
				return _sm[i]._data;
			}
			return _invalid;
		}
	}

	// 还原稀疏矩阵
	template<class T>
	friend ostream& operator<<(ostream& _cout, SparseMatrix<T>& s)//要申明为友元函数
	{
		int index = 0;
		for (size_t i = 0; i < s._row; ++i)
		{
			for (size_t j = 0; j < s._col; ++j)
			{
				if (index<s._sm.size() && i == s._sm[index]._row&&j == s._sm[index]._col)
				{
					_cout << s._sm[index++]._data << " ";
				}
				else
				{
					_cout << s._invalid << " ";
				}
			}
			_cout << endl;
		}
		return _cout;
	}

	// 实现稀疏矩阵的逆置，并给出时间复杂度
	//直接存储是有问题的，打印是按照行优先打印存储也要行优先存储
	SparseMatrix<T> Transprot()
	{
		SparseMatrix<T> sm;//定义一个逆转后的结构体
		sm._col = _row;
		sm._row = _col;
		sm._invalid = _invalid;
	    /*使用迭代器*/
		//for (int i = 0; i < _col; ++i)
		//{
		//	vector<Trituple<T>>::iterator it = _sm.begin();
		//	while (it != _sm.end())
		//	{
		//		if (i == it->_col)
		//		{
		//			sm._sm.push_back(Trituple<T>(it->_col, it->_row, it->_data));
		//		}
		//		it++;

		//	}
		//}
		//return sm;
		//时间复杂度O（M*N）
		for (size_t i = 0; i < _col; ++i)
		{
			size_t index = 0;
			while (index < _sm.size())
			{
				if (_sm[index]._col == i)
				{
					//三元组tmp存入满足下表i的元素
					Trituple<T> tmp(_sm[index]._col, _sm[index]._row, _sm[index]._data);
					sm._sm.push_back(tmp);
				}
				++index;//此处要++index而不是index++
			}
			
		}
		return sm;
	}

	// 实现稀疏矩阵的快速逆置，并给出时间复杂度
	SparseMatrix<T> FastTransprot()
	{
		SparseMatrix<T> sm;//定义一个逆转后的结构体
		sm._col = _row;
		sm._row = _col;
		sm._invalid = _invalid;
		sm._sm.reserve(_sm.size());//开辟有效元素个空间

		//1、统计原矩阵中每一列有多少个有效元素
		int* pCount = new int[_col];
		memset(pCount, 0, _col*sizeof(pCount[0]));
		for (int i = 1; i < _sm.size(); ++i)
		{
			pCount[_sm[i]._col]++;
		}

		//2、原矩阵的每一列在新矩阵中的起始位置
		int* pAddr = new int[_col];
		memset(pAddr, 0, _col*sizeof(pAddr[0]));
		for (int j = 1; j < _col; ++j)
		{
			pAddr[j] = pAddr[j - 1] + pCount[j - 1];
		}
		//3、放置元素到新的空间
		for (int i = 0; i < _sm.size(); ++i)
		{
			//Trituple<T> t(_sm[i]._col, _sm[i]._row, _sm[i]._data);
			//sm._sm[pAddr[_sm[i]._col]] = t;
			//pAddr[_sm[i]._col] ++;
			int & addr = pAddr[_sm[i]._col];
			sm._sm[addr] = Trituple<T>(_sm[i]._col, _sm[i]._row, _sm[i]._data);
			addr++;
		}

		return sm;
	}

	//	// 实现稀疏矩阵的加法操作
	//SparseMatrix<T> operator+(const SparseMatrix<T>& sp);

	//三元组
	template<class T>
	struct Trituple
	{
		Trituple(size_t row, size_t col, const T& data)
			: _row(row)
			, _col(col)
			, _data(data)
		{}

		Trituple()//无参数构造函数
		{}

		size_t _row;
		size_t _col;
		T _data;
	};
private:
	vector<Trituple<T>> _sm;
	size_t _row;
	size_t _col;
	T _invalid;
};
void TestSparseMatrix()
{
	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> sp((int*)array, sizeof(array) / sizeof(array[0]), sizeof(array[0]) / sizeof(array[0][0]), 0);

	cout << sp << endl;
	cout << endl;

	SparseMatrix<int> sp1 = sp.Transprot();

	cout << sp1 << endl;

	SparseMatrix<int> sp2 = sp.FastTransprot();
	
	cout << sp2 << endl;
}
int main()
{
	TestSparseMatrix();
	system("pause");
	return 0;
}