特殊矩阵——三对角矩阵(Tridiagonal Matrix)

特殊矩阵——三对角矩阵(Tridiagonal Matrix)

1. 三对角矩阵的概念

2. 三对角矩阵的特性

3. 三对角矩阵的压缩存储

4. 三对角矩阵的实现

#include <iostream>

using namespace std;

//压缩存储后，存储对称方阵时最多只需存储n*(n+1)/2个元素

#define GetTotalLen(n) 3 * n - 2

//按行优先方式存放三对角矩阵，矩阵元素下标对应的一维数组的下标

#define GetIndexRow(i, j) 2 * i + j

//按列优先方式存放三对角矩阵，矩阵元素下标对应的一维数组的下标

#define GetIndexCol(i, j) 2 * j + i

class TridiagonalMatrix
{
public:
TridiagonalMatrix(int order);

~TridiagonalMatrix();

public:
void create();                      //创建矩阵

void destroy();                     //销毁矩阵

void transpos();                    //矩阵转置

int get_order();                    //获取矩阵阶数

int* compressed_storage_row();      //压缩存储特殊矩阵——三对角矩阵，按行优先方式存放

int* compressed_storage_col();      //压缩存储特殊矩阵——三对角矩阵，按列优先方式存放

bool is_tridiagonal();              //判断矩阵是否为三对角矩阵

public:
friend ostream& operator<<(ostream& os, TridiagonalMatrix& m);    //输出矩阵

private:
int _order;
int **_matrix;
};

#include "TridiagonalMatrix.h"

#include <math.h>

TridiagonalMatrix::TridiagonalMatrix(int order)
: _order(order), _matrix(new int*[order])
{
create();
}

TridiagonalMatrix::~TridiagonalMatrix()
{
destroy();
}

void TridiagonalMatrix::create()
{
for (int i = 0; i < _order; i++)
{
_matrix[i] = new int[_order];
for (int j = 0; j < _order; j++)
{
if (abs(i-j) > 1)
{
_matrix[i][j] = 0;
}
else
{
_matrix[i][j] = 1;
}
}
}
}

void TridiagonalMatrix::destroy()
{
for (int i = 0; i < _order; i++)
{
delete[] _matrix[i];
}
delete[] _matrix;
_matrix = NULL;
}

void TridiagonalMatrix::transpos()
{
int temp = 0;
for (int i = 0; i < _order; i++)
{
for (int j = 0; j < _order; j++)
{
temp = _matrix[i][j];
_matrix[i][j] = _matrix[j][i];
_matrix[j][i] = temp;
}
}
}

int TridiagonalMatrix::get_order()
{
return _order;
}

int* TridiagonalMatrix::compressed_storage_row()
{
int index = 0;
int total_count = GetTotalLen(_order);
int *a = new int[total_count];
for (int i = 0; i < _order; i++)
{
for (int j = 0; j < _order; j++)
{
if (abs(i-j) <= 1)
{
index = GetIndexRow(i, j);
a[index] = _matrix[i][j];
}
}
}
return a;
}

int* TridiagonalMatrix::compressed_storage_col()
{
int index = 0;
int total_count = GetTotalLen(_order);
int *a = new int[total_count];
for (int j = 0; j < _order; j++)
{
for (int i = 0; i < _order; i++)
{
if (abs(i - j) <= 1)
{
index = GetIndexCol(i, j);
a[index] = _matrix[i][j];
}
}
}
return a;
}

bool TridiagonalMatrix::is_tridiagonal()
{
for (int i = 0; i < _order; i++)
{
for (int j = 0; j < _order; j++)
{
if ((abs(i-j) > 1) && (_matrix[i][j] != 0))
{
return false;
}
}
}
return true;
}

ostream& operator<<(ostream& os, TridiagonalMatrix& m)
{
os << "三对角矩阵：" << endl;
for (int i = 0; i < m._order; i++)
{
for (int j = 0; j < m._order; j++)
{
os << m._matrix[i][j] << " ";
}
os << endl;
}
return os;
}

#include "TridiagonalMatrix.h"

int main()
{
int n = 0;
cout << "请输入三对角矩阵的阶数，n = ";
cin >> n;

TridiagonalMatrix matrix(n);
if (true == matrix.is_tridiagonal())
{
cout << "$ 输出三对角矩阵：" << endl;
cout << matrix;//或operator<<(cout, matrix);
}

matrix.transpos();
if (true == matrix.is_tridiagonal())
{
cout << "$ 输出转置后的三对角矩阵：" << endl;
cout << matrix;//或operator<<(cout, matrix);
}

cout << "\n$ 输出压缩存储后的一维数组(按行优先方式存放)：" << endl;
int *arrayr = matrix.compressed_storage_row();
for (int i = 0; i < GetTotalLen(matrix.get_order()); i++)
{
cout << arrayr[i] << " ";
}
cout << endl;
delete[] arrayr;

cout << "\n$ 输出压缩存储后的一维数组(按列优先方式存放)：" << endl;
int *arrayc = matrix.compressed_storage_col();
for (int i = 0; i < GetTotalLen(matrix.get_order()); i++)
{
cout << arrayc[i] << " ";
}
cout << endl;
delete[] arrayc;

system("pause");
return 0;
}