矩阵及其压缩存储

最新推荐文章于 2024-07-25 19:44:34 发布
最新推荐文章于 2024-07-25 19:44:34 发布
阅读量2.2k 收藏 3
点赞数
分类专栏： C++ 文章标签： 矩阵 压缩存储 转置矩阵
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yiyi0116/article/details/53940650
版权

一.对称矩阵及对称矩阵的压缩存储
1.对称矩阵：设一个N*N的方阵A，A中任意元素Aij，当且仅当Aij == Aji(0 <= i <= N-1 && 0 <= j <= N-1)，则矩阵A是对称矩阵。以矩阵的对角线为分隔，分为上三 角和下三角。
2.压缩存储称矩阵存储时只需要存储上三角/下三角的数据，所以最多存 储n(n+1)/2个数据。 对称矩阵和压缩存储的对应关系：下三角存储i>=j,SymmetricMatrix[i][j] == Array[i*(i+1)/2+j]

这里写图片描述

3.代码测试：

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

//对称矩阵
template<class T>
class SymmetricMatrix
{
public:
    SymmetricMatrix(T* a, size_t n)
        :_a(new T[n*(n + 1) / 2])
        , _n(n)
    {
        size_t index = 0;
        for (size_t i = 0; i < n; i++)
        {
            for (size_t j = 0; j < n; j++)
            {
                if (i >= j)//下三角
                {
                    _a[index++] = a[i*n + j];
                }
                else
                {
                    break;
                }
            }
        }
    }

    T& Access(size_t i, size_t j)
    {
        if (i >= j)
        {
            return _a[i*(i + 1) / 2 + j];
        }
        else
        {
            swap(i, j);
            return _a[i*(i + 1) / 2 + j];
        }
    }
    void Disply()
    {
        for (size_t i = 0; i < _n; i++)
        {
            for (size_t j = 0; j < _n; j++)
            {
                cout << Access(i, j) << " ";
            }
            cout << endl;
        }
        cout << endl;
    }
protected:
    T* _a;
    size_t _n;
};

void TestSymmetricMatrix()
{
    int a[5][5] =
    {
        { 0, 1, 2, 3, 4 },
        { 1, 0, 1, 2, 3 },
        { 2, 1, 0, 1, 2 },
        { 3, 2, 1, 0, 1 },
        { 4, 3, 2, 1, 0 },
    };
    SymmetricMatrix<int> s((int*)a, 5);
    s.Disply();
}

int main()
{
    //TestSymmetricMatrix();
    TestSparseMatrix();
    system("pause");
    return 0;
}

这里写图片描述

二.稀疏矩阵
1.稀疏矩阵：M*N的矩阵，矩阵中有效值的个数远小于无效值的个数，且这些数据的分布没 有规律。
2.稀疏矩阵的压缩存储： 压缩存储值存储极少数的有效数据。使用{row,col,value}三元组存储每一个有效 数据，三元组按原矩阵中的位置，以行优先级先后顺序依次存放。

这里写图片描述

3.代码测试：

//稀疏矩阵
template<class T>
struct Triple
{
    Triple(size_t r,size_t c,T& value)
        :_r(r)
        , _c(c)
        , _value(value)
    {}
    Triple()
    {}
    T _value;
    size_t _r;
    size_t _c;
};

template<class T>
class SparseMatrix
{
public:
    class SparseMatrix(T* a,size_t row,size_t col,const T& invalid)
        :_a(NULL)
        , _row(row)
        , _col(col)
        , _invalid(invalid)
    {
        for (size_t i = 0; i < row; i++)
        {
            for (size_t j = 0; j < col; j++)
            {
                if (a[i*col + j] != invalid)//此时数据为有效值
                {
                    _a.push_back(Triple<T>(i, j, a[i*col + j]));
                }
            }
        }
    };
    void Disply()
    {
        size_t index = 0;
        for (size_t i = 0; i < _row; i++)
        {
            for (size_t j = 0; j < _col; j++)
            {
                if (index < _a.size() && _a[index]._r == i&&_a[index]._c == j)
                {
                    cout << _a[index]._value << " ";
                    index++;
                }
                else
                {
                    cout << _invalid << " ";
                }
            }
            cout << endl;
        }
        cout << endl;
    }
protected:
    vector < Triple<T>> _a;//有效值
    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> s1((int*)array, 6, 5, 0);
    s1.Disply();
}

这里写图片描述

三.矩阵的转置
将原矩阵的行、列对换，也就是将[i][j]和[j][i]位置上的数据对换。

这里写图片描述

代码测试：

//转置矩阵
template <typename T>
struct Triple//三元组  
{
    Triple(size_t r = 0, size_t c = 0, T value = T())
        :_r(r)
        , _c(c)
        , _value(value)
    {}

    size_t _r;
    size_t _c;
    T _value;
};

template <typename T>
class SparseMatrix
{
public:
    SparseMatrix()
        :_a(NULL)
        , _row(0)
        , _col(0)
        , _invalid(T())
    {}
    SparseMatrix(T* arr, size_t row, size_t col, const T& invalid)
        :_a(NULL)
        , _row(row)
        , _col(col)
        , _invalid(invalid)
    {
        size_t index = 0;
        for (size_t i = 0; i < row; i++)
        {
            for (size_t j = 0; j < col; j++)
            {
                if (arr[i*col + j] != invalid)//此时为有效数据
                {
                    _a.push_back(Triple<T>(i, j, arr[i*col + j]));
                }
            }
        }
    }
    void Disply()
    {
        size_t index = 0;
        for (size_t i = 0; i < _row; i++)
        {
            for (size_t j = 0; j < _col; j++)
            {
                if (index < _a.size()
                    && _a[index]._r == i
                    && _a[index]._c == j)
                {
                    cout << _a[index]._value << " ";
                    index++;
                }
                else
                {
                    cout << _invalid << " ";
                }
            }
            cout << endl;
        }
        cout << endl;
    }
    SparseMatrix<T> Transport()
    {
        SparseMatrix<T> st;
        st._row = _col;
        st._col = _row;
        st._a.reserve(_a.size());
        for (size_t i = 0; i < _col; ++i)
        {
            size_t index = 0;
            while (index < _a.size())
            {
                if (_a[index]._c == i)
                {
                    Triple<T> tmp(_a[index]._c, _a[index]._r, _a[index]._value);
                    st._a.push_back(tmp);
                }
                ++index;
            }
        }
        return st;
protected:
    vector<Triple<T>> _a;
    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> s1((int*)array, 6, 5, 0);
    s1.Disply();

    SparseMatrix<int> s2;
    s2 = s1.Transport();
    s2.Disply();
}

这里写图片描述

四.矩阵的快速转置

这里写图片描述

RowCounts{2,0,2,0,2} //统计转置后矩阵每一行的有效个数
RowStart{0,2,2,4,4} //统计转置后矩阵每一行在压缩矩阵中存储的开始位置

1.算法：
a.统计出转置之后的矩阵每一行有效值的个数count,并将有效数据直接定位到新三元组的对应位置处，此时的时间复杂度为O(2*有效值的个数+N)
b.用count统计新矩阵每一行的有效值的个数统计即原来矩阵的每一列的有效值的个数,通过遍历原来的三元组，将原来三元组的列下标作为count的下标，只要原来三元组的列存在有效值该count的对应下标就+1.
c.start找到新矩阵的每一行的第一个元素在新三元组的存储下标.进行下一步
d.再次遍历原来的三元组，将该数据直接放入新三元组对应的下标处,此时将start位置的存储数据+1,防止插入到相同的位置覆盖以前存放的数据

2.代码测试

template <typename T>
struct Triple//三元组  
{
    Triple(size_t r = 0, size_t c = 0, T value = T())
        :_r(r)
        , _c(c)
        , _value(value)
    {}

    size_t _r;
    size_t _c;
    T _value;
};

template <typename T>
class SparseMatrix
{
public:
    SparseMatrix()
        :_a(NULL)
        , _row(0)
        , _col(0)
        , _invalid(T())
    {}
    SparseMatrix(T* arr, size_t row, size_t col, const T& invalid)
        :_a(NULL)
        , _row(row)
        , _col(col)
        , _invalid(invalid)
    {
        size_t index = 0;
        for (size_t i = 0; i < row; i++)
        {
            for (size_t j = 0; j < col; j++)
            {
                if (arr[i*col + j] != invalid)//此时为有效数据
                {
                    _a.push_back(Triple<T>(i, j, arr[i*col + j]));
                }
            }
        }
    }
    void Disply()
    {
        size_t index = 0;
        for (size_t i = 0; i < _row; i++)
        {
            for (size_t j = 0; j < _col; j++)
            {
                if (index < _a.size()
                    && _a[index]._r == i
                    && _a[index]._c == j)
                {
                    cout << _a[index]._value << " ";
                    index++;
                }
                else
                {
                    cout << _invalid << " ";
                }
            }
            cout << endl;
        }
        cout << endl;
    }

    SparseMatrix<T> FastTransport()//快速转置矩阵
    {
        SparseMatrix<T> fast;
        fast._row = _col;
        fast._col = _row;
        fast._a.resize(_a.size());
        int *count = new int[_col];
        memset(count, 0, sizeof(int)* _col);
        for (size_t i = 0; i < _a.size(); ++i)
        {
            int col1 = _a[i]._c;
            ++count[col1];
        }
        int *start = new int[_col];
        memset(start, 0, sizeof(int)* _col);

        size_t i = 0;
        start[i] = 0;
        for (i = 1; i < _col; i++)
        {
            start[i] = start[i - 1] + count[i - 1];
        }
        for (size_t i = 0; i < _a.size(); i++)
        {
            int col2 = _a[i]._c;
            size_t tmp = start[col2];
            fast._a[tmp]._r = _a[i]._c;
            fast._a[tmp]._c = _a[i]._r;
            fast._a[tmp]._value = _a[i]._value;
            ++start[col2];
        }
        delete[]start;
        delete[]count;
        return fast;
    }

protected:
    vector<Triple<T>> _a;
    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> s1((int*)array, 6, 5, 0);
    s1.Disply();

    SparseMatrix<int> s3;
    s3 = s1.FastTransport();
    s3.Disply();
}

这里写图片描述

yiyi0116
关注
专栏目录
对角矩阵压缩存储
08-05
### 对角矩阵压缩存储详解 #### 一、对角矩阵概览 对角矩阵是一种特殊类型的矩阵，其特征在于非零元素主要分布在主对角线及其附近的一系列对角线上，而其他位置上的元素均为零。具体而言，这类矩阵可以分为几种...
矩阵的压缩存储
丹丹的后花园
11-23 7698
对称矩阵、三角阵、带状矩阵（对角矩阵）的压缩存储方法；稀疏矩阵的四种常用的压缩存储方法：三元组、伪地址、邻接表、十字链表这四种表示方法，一文打尽。
【数据结构】特殊矩阵的压缩存储|保姆级详解+图解
Yaoyao2024的博客
04-05 7771
在线性代数这门学科中已经学习了矩阵。在高级计算机语言中，矩阵常用二维数组表示。所谓**“压缩存储”**，目的在于节省空间！体现在，为多个值相同的元素只分配一个存储空间，多元素值为0的元素不分配空间二维数组A[n][n]和的写法是等价的。如果数组写法为,则说明指定了下标是从1开始存储元素。二维数组元素写为a[i][j],注意数组元素下标i和j通常是从0开始的。矩阵元素通常写为a i,j或者a(i),(j)，注意这时的i和j代表的行号和列号，都是从1开始的！这里我们讨论两种特殊矩阵。
特殊矩阵的压缩存储（公式详解）
最新发布
kusunoki的博客
07-25 716
在数据结构中需要考虑如何将矩阵更有效地存储在内存中，并能方便地提取矩阵中的元素。本文分析了如何将对称矩阵、三角矩阵以及三对角矩阵压缩至一维数组中，并对部分公式进行了分析和推导。
5.3矩阵的压缩存储（稀疏矩阵转置和快速转置）
热门推荐
IT1995的博客
02-09 3万+
5.3矩阵的压缩存储（稀疏矩阵转置和快速转置）
稀疏矩阵的存储压缩
01-20
稀疏矩阵的存储压缩 稀疏矩阵 (Sparse Matrix) 用三元组表表示的稀疏矩阵及其转置 稀疏矩阵转置算法思想 设矩阵列数为 Cols对矩阵三元组表扫描Cols 次第 k 次检测列号为 k 的项
3.4 特殊矩阵的压缩存储1
08-03
因此，压缩存储对称矩阵通常只保留主对角线及其下方的元素（或者主对角线及其上方的元素）。 为了实现这种压缩存储，我们可以定义一个新的数据结构，比如一维数组或链表，只用来存储对角线及以下的元素。对于一个n...
C++ 数据结构之对称矩阵及稀疏矩阵的压缩存储
01-01
对称矩阵及稀疏矩阵的压缩存储 1.稀疏矩阵 　对于那些零元素数目远远多于非零...//稀疏矩阵及其压缩存储 #pragma once #include #include using namespace std; template struct Triple { size_t _r; size_t _
特殊矩阵的压缩存储算法的实现 课程设计说明书.doc
10-07
《特殊矩阵的压缩存储算法的实现》课程设计说明书是一份旨在教授学生如何使用C语言实现特殊矩阵（如对称矩阵、三角矩阵、对角矩阵）压缩存储的文档。设计目标旨在提升学生对数据结构和算法的理解，软件开发技能，...
数据结构与算法之矩阵的压缩存储
five-five
06-12 6070
M 行 N 列的二维数组 b[M][N] 中，若按照行优先存储，则 的存储地址=可用二维数组存储注意：描述矩阵元素时，行、列号通常从 1 开始；而描述数组时通常下标从 0 开始（具体看题目给出的条件，注意审题！）分类：稀疏矩阵方阵：某些特殊矩阵可以压缩存储空间定义：若 n 阶方阵中任意一个元素 a[i][j]=a[j][i]，则该矩阵称为对称矩阵普通存储：n*n 二维数组压缩存储策略：只存储主对角线 + 下三角区 以 该策略 为例，按行优先原则将各元素存入一维数组中。 等差数列公式： ^7kygmb可以实
矩阵压缩储存
shi_zi_183的博客
10-01 450
矩阵压缩储存 矩阵是许多科学与工程计算问题中研究的数学对象。我们感兴趣的不是矩阵本身而是如何储存矩阵的元，从而使矩阵的各种运算能够有效地进行。 矩阵压缩需要矩阵具有某些相同的元素或者零元素，假若值相同的元素或者零元素在矩阵中的分布具有一定规律，则我们称此类矩阵为特殊矩阵；反之，成为稀疏矩阵。下面分别讨论他们的压缩储存。 特殊矩阵 对称矩阵若n阶矩阵A中的元满足aij=aji 1≤i,j≤na_{ij}=a_{ji}\ 1\le i,j\le naij​=aji​ 1≤i,j≤n 则称为n
4.1.3、稀疏矩阵压缩存储（3 种方式）
融码一生：专注 Python、C/C++、Linux、机器学习 & 深度学习、NLP、算法领域分享
04-14 2002
数据结构提供针对某些特殊矩阵的压缩存储结构。特殊矩阵主要分为：
【数据结构】矩阵的压缩存储
m0_61628700的博客
03-07 1321
是第i行前1~i-1行的所有元素数量；非常量区域和对称矩阵存储方法一毛一样。如何将数组下标k转换为矩阵下标i，j？如何把矩阵下标转化为一维数组下标？元素在第i行的前的元素数量。上三角区域或者下三角区域为一常量。只存储上或下三角区和主对角线。行优先：优先存放一行的数据。列优先：优先存放一列的数据。只要存储值不为0的元素就好。非零元素远少于矩阵元素个数。​ 会失去随机存储的特性。2.链式存储——十字链表法。若n阶方阵中任意一个元素。在数组最后存储常量的值。
数构（C语言）——第四章、矩阵的压缩存储（下）
weixin_64215932的博客
05-06 2963
一、矩阵的压缩存储 （一）、数组的存储结构 1、一维数组 定义：ElemType a[MaxSize]; //ElemType型一维数组 各数组元素大小相同，且物理上连续存放 数组元素a[i]的存放地址=起始地址+i*sizeof(ElemType) 2、二维数组 定义：ElemType b[M][N]; //M行N列的二维数组 存储方式：行优先存储或列优先存储 M行N列的二维数组b[M][N]中， 若按行优先存储，则b[i][j]的存储地址=起始地址+(i*N+j)sizeof(ElemType) 若按
【数据结构】特殊矩阵的压缩存储——对称矩阵、三角矩阵、稀疏矩阵……
蒙奇D索大的博客
05-01 1307
【数据结构】第三章——栈、队列与数组 详细介绍特殊矩阵在内存中的压缩存储……
矩阵的压缩存储方法及实现
IbtnLisp的博客
09-16 534
常见的稀疏矩阵压缩存储方法有三种：行压缩存储（Compressed Row Storage，CRS）、列压缩存储（Compressed Column Storage，CCS）和坐标列表（Coordinate List，COO）。在计算机科学和数学领域中，矩阵是一种常见的数据结构，用于表示和处理多维数据。然而，对于大型矩阵来说，存储和处理所需的内存和计算资源可能会非常昂贵。为了解决这个问题，矩阵的压缩存储方法应运而生。本文将介绍一些常见的矩阵压缩存储方法，并提供相应的源代码实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值