特殊矩阵——对称矩阵(Symmetric Matrix)

最新推荐文章于 2024-06-11 16:04:38 发布

Cainv89

最新推荐文章于 2024-06-11 16:04:38 发布

阅读量2.8w

点赞数 10

CC 4.0 BY-SA版权

分类专栏： C++数据结构文章标签：数据结构二维数组对称矩阵对称矩阵的特性对称矩阵的压缩存储

本文链接：https://blog.youkuaiyun.com/cainv89/article/details/51759531

C++数据结构专栏收录该内容

30 篇文章

订阅专栏

本文介绍对称矩阵的概念、性质及压缩存储方法，包括按行优先或列优先方式存储上三角阵或下三角阵，同时提供C++实现代码。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

特殊矩阵——对称矩阵(Symmetric Matrix)

注：压缩存储的矩阵可以分为特殊矩阵和稀疏矩阵。对于那些具有相同元素或零元素在矩阵中分布具有一定规律的矩阵，被称之为特殊矩阵。对于那些零元素数据远远多于非零元素数目，并且非零元素的分布没有规律的矩阵称之为稀疏矩阵。

1. 对称矩阵的概念

元素以主对角线为对称轴对应相等的矩阵。

2. 对称矩阵的特性

对角矩阵都是对称矩阵，对称矩阵必须是方形矩阵。
设一个n*n的方阵A，对于矩阵A中的任一元素 $a_{ij}$ ，当且仅当 $a_{ij}$ = $a_{ji}$ 时(0≤i≤n-1，0≤j≤n-1)时，矩阵A为对称矩阵。

3. 对称矩阵的压缩存储

可以利用对称矩阵的上述特性，只存储对角线及对角线以下的元素，或者只存储对角线及对角线以上的元素，前者称之为下三角阵，后者称之为上三角阵。
对一个n*n的对称方阵A，元素总数有 $n^2$ 个，而上三角阵或下三角阵的元素共有n+(n-1)+(n-2)+……+2+1=n*(n+1)/2个元素。因此，存储对称方阵时最多只需存储n*(n+1)/2个元素。
利用对称矩阵的对称性，可以用一维数组B存储对称矩阵A(这主要要区分四种存储方式：行优先方式存储下三角阵、行优先方式存储上三角阵、列优先方式存储下三角阵和列优先方式存储上三角阵)。
(1)行优先方式存储下三角阵

(2)行优先方式存储上三角阵

(3)列优先方式存储下三角阵

(4)列优先方式存储上三角阵

4. 特殊矩阵的实现

文件：SymmetricMatrix.h


#include <iostream>


using namespace std;

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

#define GetTotalLen(n) n * (n + 1) / 2              


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

#define GetIndexRowLower(i, j) ((i + 1) * i) / 2 + j    


//按行优先方式存放上三角阵时，矩阵元素下标对应的一维数组的下标
//n * i + j - ((i + 1) * i) / 2 =>((2 * n - i - 1) * i) / 2 + j

#define GetIndexRowUpper(n, i, j) ((2 * n - i - 1) * i) / 2 + j 


//按列优先方式存放下三角阵时，矩阵元素下标对应的一维数组的下标
//n * j + i - ((j + 1) * j) / 2 =>((2 * n - j - 1) * j) / 2 + i 

#define GetIndexColLower(n, i, j) ((2 * n - j - 1) * j) / 2 + i 


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

#define GetIndexColUpper(i, j) ((j + 1) * j) / 2 + i    


class SymmetricMatrix
{
public:
    SymmetricMatrix(int order);

    ~SymmetricMatrix();

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

    void destroy();                         //销毁矩阵

    void transpos();                        //矩阵转置

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

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

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

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

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

    bool is_symmetric();                    //判断矩阵是否为对称矩阵

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

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

文件：SymmetricMatrix.cpp


#include "SymmetricMatrix.h"


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

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

void SymmetricMatrix::create()
{
    for (int i = 0; i < _order; i++)
    {
        _matrix[i] = new int[_order];
        for (int j = 0; j < _order; j++)
        {
            _matrix[i][j] = i + j;
        }
    }
}

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

void SymmetricMatrix::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 SymmetricMatrix::get_order()
{
    return _order;
}

int* SymmetricMatrix::compressed_storage_row_lower()
{
    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 <= i; j++)
        {
            index = GetIndexRowLower(i, j);
            a[index] = _matrix[i][j];
        }   
    }
    return a;
}

int* SymmetricMatrix::compressed_storage_row_upper()
{
    int index = 0;
    int total_count = GetTotalLen(_order);
    int *a = new int[total_count];
    for (int i = 0; i < _order; i++)
    {
        for (int j = i; j < _order; j++)
        {
            index = GetIndexRowUpper(_order, i, j);
            a[index] = _matrix[i][j];
        }   
    }
    return a;
}

int* SymmetricMatrix::compressed_storage_col_lower()
{
    int index = 0;
    int total_count = GetTotalLen(_order);
    int *a = new int[total_count];
    for (int j = 0; j < _order; j++)
    {
        for (int i = j; i < _order; i++)
        {
            index = GetIndexColLower(_order, i, j);
            a[index] = _matrix[i][j];
        }
    }
    return a;
}

int* SymmetricMatrix::compressed_storage_col_upper()
{
    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 <= j; i++)
        {
            index = GetIndexColUpper(i, j);
            a[index] = _matrix[i][j];
        }
    }
    return a;
}

bool SymmetricMatrix::is_symmetric()
{
    for (int i = 0; i < _order; i++)
    {
        for (int j = 0; j < _order; j++)
        {
            if (_matrix[i][j] != _matrix[j][i])
            {
                return false;
            }
        }
    }
    return true;
}

ostream& operator<<(ostream& os, SymmetricMatrix& m)
{
    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;
}

文件：main.cpp


#include "SymmetricMatrix.h"


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

    SymmetricMatrix matrix(n);
    if (true == matrix.is_symmetric())
    {
        cout << "$ 输出对称矩阵：" << endl;
        cout << matrix;//或operator<<(cout, matrix);
    }

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

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

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

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

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

    system("pause");
    return 0;
}