数据结构——特殊矩阵

在线性代数里面，我们已经学过什么叫作方阵，即列数和行数相等的矩阵。

对于特殊的方阵，我们不必将每一个元素都保存下来，在说这些矩阵之前，我们先来讲两种数组结构。

1.一维数组

所谓一维数组，就是利用物理的连续的一段存储空间来存储相同类型的一些元素。

有些语言的数组是从0下标开始的，因此寻找到一个元素i的地址只需要通过函数address=起始地址+i*单个元素的存储空间。

而有些语言是从1开始的，因此它的函数为address=起始地址+（i-1）*单个元素的存储空间，相比之下，它的函数就比上面的函数复杂不少。

但无论下标从0开始还是从1开始，我们寻找一维数组的每个元素都是通过函数来找到我们想要的元素地址。

因此，我们寻找每个元素所耗费的时间是相同的，即随机存取。

2.二维数组

对于二维数组，其实我们还是采用了一维数组的存储方式，即利用物理的连续的一段存储空间来存储相同类型的一些元素。

但有些语言采用行优先策略，即按行存储在一维数组的存储空间上。

例如：数组a有n行n列。则其实际存储的空间上为a[0][0],a[0][1]……a[0][n-1]，a[1][0],a[1][1],……a[n-1][n-1]。

这时，假设二维数组q有m行n列，因此q[i][j]寻址函数为address=起始地址+（i*m+j）*单个元素的存储空间。

也有一些语言采用列优先，即按列存储在一维数组的存储空间上。

数组a有n行n列。则其实际存储的空间上为a[0][0],a[1][0]……a[n-1][0]，a[0][1],a[1][1],……a[n-1][n-1]。

这时，假设二维数组q有m行n列，因此q[i][j]寻址函数为address=起始地址+（j*n+i）*单个元素的存储空间

下面开始介绍特殊矩阵，下面都采用0开始的下标。

1.对称矩阵

对称矩阵即关于左上角到右下角这一条线（对称线）相对称的矩阵。

我们可以只保存对称线以下即下三角区和位于对称线上的数。

根据数学数列知识，存储的矩阵有n行n列，则按行存储需要存1+2+……+n=n(n+1)/2。则最后一个元素下标k为n(n+1)/2-1。

对于用一维数组利用上面的方法存储这个矩阵，是非常容易的。然而，我们存储这个矩阵是为了用这个矩阵，我们会传入i和j值，然后把对应的一维数组里的值给取出来。

设这个值所在位置下标为k，则其是第(1+2+……+i-1+i)+j+1即i*(i+1)/2+j+1个值，所以下标k=i*(i+1)/2+j。

如上图，假如我们要取i为2，j为1的值1，则其是（1+2）+1+1个值，因此其下标k为4。 

对于对称矩阵，我们知道aij=aji。

因此，如果，j>i时，可以利用aij=aji，转化为k=j(j+1)/2+i。

综上：

2.三角矩阵

上三角矩阵就是上三角区元素不同，其他相同的矩阵，而下三角矩阵相反。

对比对称矩阵，只需要多出一个内存保存相同的元素，因此需要存储n（n-1）/2+1,我们将最后一个数组元素存储多出来的那个元素，其下标为n（n-1）/2。

从对称矩阵容易得到下三角矩阵：

 

上三角矩阵，我们可以将其关于对称线翻转。此时，i和j互换。

只需将上式i和j变换即可。

3.三对角矩阵

三对角矩阵又叫带状矩阵，其特点是行标i和列标j有| i-j |>1时为0，其他情况不为0。

有两种按行优先和列优先存储方法。

方法一：

方法二：

4.稀疏矩阵

稀疏矩阵就是指矩阵中零元素个数远远多于非零元素的个数，且非零元素分布无规律。

三元组表示法：

可以将稀疏矩阵每个非零元素表示成如下三元组：

需要注意的是，三元组存储矩阵不一定需要的存储空间比原来更少，因为它还要存储行列号。

具体问题具体分析。

相关三元组操作的代码如下：

#pragma once
#include
#include
template
class triple
{
	struct Node
	{
		int row;
		int col;
		T data;
		Node(int r=0, int c=0,const T& d=0):row(r),col(c),data(d){}
		void setNodeValue(int r, int c, const T& d)
		{
			row = r;
			col = c;
			data = d;
		}
		void operator=(const Node& obj) 
		{
			if (this == &obj)
				return;
			row = obj.row; 
			col = obj.col;
			data = obj.data;
		}
	};
	Node* matrix;//三元组表
	int numRow;//矩阵行数
	int numCol;//矩阵列数
	int size;//三元组表当前长度
	int max_size;
public:
	triple(int first, int second, int maxSize = 10);
	~triple() { delete []matrix; }
	void setValue(int i, int j, const T& d);
	T getValue(int i, int j);
	void print();
	//转置矩阵的三种方法
	void transform1();
	void transform2();
	void quicktransform();
	void resize();
};
template
triple::triple(int first, int second, int maxSize )
{
	if (first <= 0 || second <= 0 || maxSize < 0)
		throw("error");
	numRow = first;
	numCol = second;
	size = 0;
	max_size = maxSize > numRow * numCol ? numRow * numCol :maxSize ;
	matrix = new Node[maxsize];
}

template
void triple::print()
{
	for (int i = 0; i < size; i++)
		std::cout << "row:" << matrix[i].row << " col:" << 
		matrix[i].col << " value:" << matrix[i].data << std::endl;
}

template
void triple::resize()
{
	if (numCol * numRow == size)
		throw("resize error");
	Node* p = matrix;
	max_size = max_size *2>numRow*numCol?numRow * numCol:max_size*2;
	matrix = new Node[2 * max_size];
	for (int i = 0; i < size; i++)
		matrix[i] = p[i];
	delete[] p;
}

template
void triple::setValue(int i, int j, const T& d)
{
	if (d == 0) return;
	if (i < 0 || j < 0||i>=numRow||j>=numCol) throw("setValue error");
	if (size >= max_size) resize();
	int m=0;
	for ( m = 0; m < size; m++)
	{
		//应该插入的地方
		if (matrix[m].row > i || (matrix[m].row == i) && (matrix[m].col > j))
			break;
		else if (matrix[m].row == i && matrix[m].col == j)//有了直接赋值
		{
			matrix[m].data = d;
			return;
		}
	}
	for (int n = size - 1; n > m; n--)
		matrix[n] = matrix[n - 1];
	matrix[m].setNodeValue(i,j, d);
	size++;
}

template
T triple::getValue(int i, int j)
{
	if (i < 0 || j < 0 || i >= numRow || j >= numCol) throw("getValue error");
	for (int m = 0; m < size; m++)
	{
		if (matrix[m].row == i && matrix[m].col == j)
			return matrix[m].data;
	}
	return -1;
}

template
void triple::transform1()
{
	//方法一：先换后排序
	auto f = [](const Node& a, const Node& b) {return (a.row > b.row) ||
		(a.row == b.row && a.col > b.col); };
	std::priority_queue, decltype(f)> a(f);
	for (int i = 0; i < size; i++)
	{
		int temp = matrix[i].row;
		matrix[i].row = matrix[i].col;
		matrix[i].col = temp;
		a.push(matrix[i]);
	}
	for (int i = 0; i < size; i++)
	{
		matrix[i] = a.top();
		a.pop();
	}
	return;
}
template
void triple::transform2()
{
	//按列插入，行相对的也是从小到大的。
	Node* p = new Node[size];
	for (int i = 0; i < size; i++)
		p[i] = matrix[i];
	std::vector visit(size, false);//标记是否改过
	int count = 0;
	for (int i = 0; i < numCol; i++)
	{
		for (int j = 0; j < size; j++)
		{
			if (p[j].col == i&&!visit[j])
			{
				int temp = p[j].row;
				p[j].row = p[j].col;
				p[j].col = temp;
				matrix[count++] = p[j];
				visit[j] = true;
			}
		}
	}
	return;
}
template
void triple::quicktransform()
{
    //顺序取，直接存
    //需计算每列第一个元素，每列有多少个元素
	int* position = new int[numCol];
	position[0] = 0;
	int* num = new int[numCol];
	Node* temp = new Node[size];
	for (int i = 0; i < size; i++)
		temp[i] = matrix[i];
    
	for (int i = 0; i < numCol; i++)//置零
		num[i] = 0;

	for (int i = 0; i < size; i++)//数每列的个数
		num[matrix[i].col]++;

	for (int i = 1; i < numCol; i++)//每列第一个元素位置等于前一列第一个元素位序加数量
		position[i] = position[i - 1] + num[i - 1];

	for (int i = 0; i < size; i++)
	{
		int t = temp[i].row;
		temp[i].row = temp[i].col;
		temp[i].col = t;
		matrix[position[temp[i].row]++] = temp[i];
	}
}

十字链表表示法：

每个元素有行标，列标，数据域和两个指针域分别指向向下向右的元素，分别称向下域和向右域。

且上下左右分别构成一个循环链表，这两个链表有头结点，每一行的头结点行标为该行，

列标为-1，数据域为0，每一列头结点列表为该列，行标为-1，数据域为0。

最左上角行标表示有多少行，列标可以表示有多少列，数据域表示有多少个元素。

一图抵千言：

5.广义表

广义表就是数组里每个元素可能是一个广义表（称为子表），或者仅仅是一个不可再分的元素（这个元素称为原子）。

例如：L={ {1，2，3，{5，6}}，4 }，其中4是一个原子，而{1，2，3，{5，6}}是一个子表。

1，2，3又是子表的原子，{5，6}又是子表的子表。

广义表的表头是第一个元素。奇怪的是，它的表尾是除了第一个元素，其他剩余的元素组成的一个新的广义表。

表头和表尾假设分别用head和tail函数表示。

例如：L={{1，2，3}，4，5}。

则表头head（L）={1，2，3}，tail={4,5}。