C++编写对角矩阵的压缩存储

对角矩阵是一种特殊的矩阵，只有主对角线上的元素不为零，其他元素均为零。由于对角矩阵中大部分元素为零，可以采用压缩存储方式来节省存储空间。

一种常见的对角矩阵的压缩存储方式是采用一维数组来存储主对角线上的元素。具体地，设对角矩阵为 $A_{n\times n}$，则对角线上的元素可以表示为 $a_{i,i}(i=1,2,\cdots,n)$。则对角矩阵的压缩存储方式如下：

int main(){
    int n = 5;
    int a[5] = {1, 2, 3, 4, 5}; // 假设矩阵对角线上的元素为 1, 2, 3, 4, 5
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (i == j) {
                cout << a[i] << " "; // 输出对角线上的元素
            } else {
                cout << 0 << " "; // 输出其他元素
            }
        }
        cout << endl;
    }
    return 0;
}

输出结果为：

1 0 0 0 0 
0 2 0 0 0 
0 0 3 0 0 
0 0 0 4 0 
0 0 0 0 5 

在实际应用中，对角矩阵的压缩存储方式可以进一步优化，采用只存储非零元素的方式，从而进一步节省存储空间。

相关问题

c++实现多对角矩阵的压缩存储

多对角矩阵是一种特殊的稀疏矩阵，只有主对角线及其上下若干条对角线上有非零元素，其余元素均为零。因此，可以采用压缩存储方式来节省存储空间。常用的压缩存储方式有三对角矩阵、对称三对角矩阵和块对角矩阵等。

对于多对角矩阵，我们可以采用对角线压缩存储方式。具体来说，就是将矩阵中的每条对角线都保存在一个一维数组中，然后将这些数组按照对角线的位置排列起来，形成一个二维的压缩矩阵。这样，对于一个 $n\times n$ 的多对角矩阵，压缩后的存储空间为 $O(n)$。

下面是一个 C++ 实现多对角矩阵压缩存储的示例代码：

#include <iostream>
#include <vector>
using namespace std;

class DiagonalMatrix {
private:
    vector<int> diagonal;   // 对角线数组
    int n;                  // 矩阵维度
public:
    DiagonalMatrix(int n) {
        this->n = n;
        diagonal.resize(2 * n - 1, 0);   // 初始化对角线数组大小
    }
    void set(int i, int j, int value) {
        if (i < 1 || i > n || j < 1 || j > n) {
            cout << "Invalid index!" << endl;
            return;
        }
        if (i == j) {
            diagonal[n - 1 + i - 1] = value;  // 主对角线
        } else if (i - j == 1) {
            diagonal[i - 2] = value;          // 上一条对角线
        } else if (j - i == 1) {
            diagonal[n + j - 2] = value;      // 下一条对角线
        } else {
            cout << "Invalid index!" << endl;
            return;
        }
    }
    int get(int i, int j) {
        if (i < 1 || i > n || j < 1 || j > n) {
            cout << "Invalid index!" << endl;
            return 0;
        }
        if (i == j) {
            return diagonal[n - 1 + i - 1];  // 主对角线
        } else if (i - j == 1) {
            return diagonal[i - 2];          // 上一条对角线
        } else if (j - i == 1) {
            return diagonal[n + j - 2];      // 下一条对角线
        } else {
            return 0;
        }
    }
};

int main() {
    DiagonalMatrix mat(5);
    mat.set(1, 1, 1);
    mat.set(2, 2, 2);
    mat.set(3, 3, 3);
    mat.set(4, 4, 4);
    mat.set(5, 5, 5);
    mat.set(1, 2, 6);
    mat.set(2, 3, 7);
    mat.set(3, 4, 8);
    mat.set(4, 5, 9);
    cout << mat.get(1, 2) << endl;  // output: 6
    cout << mat.get(2, 3) << endl;  // output: 7
    cout << mat.get(3, 2) << endl;  // output: 0 (非对角线元素)
    return 0;
}

c++对称矩阵压缩存储

在C++中，对称矩阵是一种特殊的矩阵，它的元素满足上三角（或下三角）的所有元素与其对角线上的元素相等。由于对称矩阵有这个特性，我们可以只存储下三角或者上三角的部分，再加上对角线上的元素，这样就能实现空间的高效压缩存储。

具体实现方法通常有以下两种：

1. **压缩行存储（Compressed Row Storage, CRS）**:
- 只存储下三角部分的非零元素，每个行从左到右存储，对角线上的元素单独记录。
- 用一个一维数组表示所有行的元素，另一个一维数组指示每个元素在原矩阵中的列位置（即列索引减去当前行号）。

2. **压缩列存储（Compressed Column Storage, CCS）**:
- 只存储下三角部分的非零元素，但按照列进行压缩，每个列从上到下存储。
- 类似于CRS，一个一维数组存放元素值，另一个一维数组标识元素所在的行索引。

这两种方法都能节省存储空间，特别是当矩阵很稀疏时，效果显著。在C++中，使用标准库如`std::vector`和自定义数据结构可以方便地实现这些存储策略。