稀疏矩阵的压缩存储与转置与加法

最新推荐文章于 2022-11-17 21:51:17 发布
最新推荐文章于 2022-11-17 21:51:17 发布
阅读量1.8k 收藏 13
点赞数 3
分类专栏： 数据结构 文章标签： 存储 压缩
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zyl_1102179268/article/details/70477495
版权

稀疏矩阵

什么是稀疏矩阵：
稀疏矩阵：在M*N的矩阵中，有效元素的个数远小于无效元素的个数(一般是：有效/无效 < 0.05)，且这些数据的分布没有规律。可能表述的不是很完美，所以稀疏矩阵>
例如：
这里写图片描述
从上图中我们可以看到，其中只有6个有效元素，用红色标记起来。
根据上面我们刚说过的特征，我们可以看到其中0特别多，而别的数据却很少，其实我们一般把0称为是无效元素，其他的称为有效元素，和我们在上个对称矩阵的压缩存储中所说，存储这么多无效元素干嘛，浪费内存(内存条那么贵是吧？？？)，所以我们只需要存储有效元素就可以了。但是这个稀疏矩阵没有任何规律我们不能像对称矩阵那样存储，所以就要特别的存储办法。

稀疏矩阵的压缩存储

我们了解到稀疏矩阵后，现在考虑怎么存储稀疏矩阵中的有效元素，我们从图中可以看到，其中有效元素的分布是没有任何规律的(虽然我给的其实还是有点规律的),从稀疏矩阵的严格定义中来说是没有规律的，所以存储他们还是要借用一些别的力量，它存储的是有效元素(行坐标，列坐标，值大小)，所以我们就能够想到用结构体来封装一个存储单元。

    template<class T>
    struct Trituple
    {
        Trituple(int row = 0, int col = 0, const T& value = T())
        : _row(row)
        , _col(col)
        , _value(value)
        {}

        size_t _row;//有效元素的行
        size_t _col;//有效元素的列
        T _value;//有效元素的值
    };

我们意见给出了它的存储结构，如何利用他来存储数据元素我们在下面的代码中实现：

    SparseMatrix(T* array, size_t row, size_t col, const T& invalid)
        : _row(row)
        , _col(col)
        , _invalid(invalid)
    {
        for (int i = 0; i < row; i++)
        {
            for (int j = 0; j < col; j++)
            {
                if (array[i*col + j] != invalid)//判断是否为无效值，
                {
                    Trituple<T> tmp(i, j, array[i*col + j]);//将有效值存放在三元组中
                    _sm.push_back(tmp); //借用vector来存储数据
                }
            }
        }
    }

稀疏矩阵的转置

上面我们已经介绍了稀疏矩阵，和稀疏矩阵的压缩存储，下面来说一下稀疏矩阵的转置，直接上图来看一下转置后的效果
这里写图片描述
从图中我们可以看到从6行5列变为了5行6列，其实就是将[i][j]与[j][i]位置上的数据进行了交换；一般我们在存储的时候选择的是行优先；

行优先：1 3 5 1 3 5(一行一行的存储)
列优先：1 1 3 3 5 5(一列一列的存储)

从上面行列优先的区别我们可看到的是，行优先存储完后它的新行上面的元素和列优先是一模一样的，所以我们可以在逆置的时候采用列优先从而达到显示出来的是行优先。（完美）
So：

普通转置

因为我们已经将矩阵的有效元素存储在_sm中了，所以我们需要一个新的_sm2来存储按照列优先排列的元素，所以：

第一列遍历(_sm2)中存储：1，1；
第二列遍历(_sm2)中存储：1，1；
第三列遍历(_sm2)中存储：1，1，3，3；
第四列遍历(_sm2)中存储：1，1，3，3；
第五列遍历(_sm2)中存储：1，1，3，3，5，5；

所以这就是新的压缩存储数组；

    SparseMatrix<T> Transport()//时间复杂度 O(列数*有效元素的个数+有效元素的个数)
    {
        vector<Trituple<T>> _sm2;
        size_t n = _sm.size();
        _sm2.resize(n);
        size_t count = 0;

        for (size_t i = 0; i < n; i++)
        {
            for (size_t j = 0; j < n; j++)
            {
                if (_sm[j]._col == i)   //把_sm中列为i的数找出来作为将来的行，以列优先达到复位是的行优先
                {
                    _sm2[count] = _sm[j]; //将数据保存在_sm2中返回是就是按照行优先来计算的
                    swap(_sm2[count]._row, _sm2[count]._col);//交换坐标
                    count++;
                }
            }
        }
        for (size_t i = 0; i < n; i++)
        {
            _sm[i] = _sm2[i];//在operator中调用默认的_sm是第一个的，所以还是按照原来的有效值存储顺序打印的，只是将行列交换后，原来每个行列的大小不一样而已，没有改变实质值；
        }
        swap(_row, _col);
        return *this;
    }

快速转置

在快速转置中，我们是用空间上的占用换取时间上的节省(有没有觉得很熟悉？？？(为什么要内存对齐？？？))
我们需要两个数组

Count[]//统计转置后矩阵每一行的个数(原矩阵每一列的个数)
Strant[]//统计转置后的矩阵每行在矩阵压缩中存储的位置(统计原矩阵中每一列第一个元素在_sm2中存储的位置)

我们通过存储后_sm中存储的是：1 3 5 1 3 5；

第一次遍历遇到1的时候放在_sm2: 1, , , , , 。
第二次遍历遇到3的时候放在_sm2: 1， ， 3， ， ， 。
第三次遍历遇到5的时候放在_sm2: 1， ， 3， ， 5， 。
第四次遍历遇到1的时候放在_sm2: 1，1 ， 3， ，5 ， 。
第五次遍历遇到3的时候放在_sm2: 1，1 ， 3，3 ，5 ， 。
第六次遍历遇到3的时候放在_sm2: 1， 1， 3，3 ，5 ，5 。

所以我们遍历一次就可以了。我们已经计算出了_sm2中的数据下面计算Count[]的数据；
因为在Count[]中我们存储的是原来_sm中每列上面的数据个数，因此直接计算它的统计列就可以；
在Strant[]中我们计算的是每一列第一个元素在_sm2中存储的位置，所以我们计算的时候，只需要用上一组的数据个数加上它的它的上一列开头的位置，才能计算出这一列的位置；
这里写图片描述
Count[] = 2, 0, 2, 0, 2;
Start[n] = Start[n-1]+Count[n-1];
所以很好计算的；就是不太好理解(我也是参考了好几个人的写法，才大概理解了这个写法)；
参看代码：

    SparseMatrix<T> FastTransport()
    {
        vector<Trituple<T>> _sm2;
        size_t n = _sm.size();
        _sm2.resize(n);

        size_t Count[5] = {0};//统计转置后矩阵每一行的个数(原矩阵每一列的个数)
        size_t Start[5] = {0};//统计转置后的矩阵每行在矩阵压缩中存储的位置(统计原矩阵中每一列第一个元素在_sm2中存储的位置)
        for (size_t i = 0; i < n; i++)
        {
            Count[_sm[i]._col]++;  //因为在Count初始化的时候全部初始化为0，所以在Count[_sm[i]._col]中找到第几列的时候就是给第几列++;计算出每列的元素个数；
        }
        for (size_t i = 1; i < _col; i++)
        {
            Start[i] = Start[i - 1] + Count[i - 1];
        }

        for (size_t i = 0; i < n; i++)
        {
            _sm2[Start[_sm[i]._col]] = _sm[i];//利用Start+Count计算出_sm2中每个元素的位置；
            swap(_sm2[Start[_sm[i]._col]]._col, _sm2[Start[_sm[i]._col]]._row);
            Start[_sm[i]._col]++;
        }

        for (size_t i = 0; i < n; i++)
        {
            _sm[i] = _sm2[i];
        }
        swap(_row, _col);
        return *this;
    }

这里写图片描述

两个稀疏矩阵的加法

简单介绍一下两个稀疏矩阵的加法，我们在矩阵加法的时候都是，两个矩阵的行列相同进行相加，所以，我们在完成代码编写的时候，要对有效元素的左边进行一个判断：

SparseMatrix<T> operator+(const SparseMatrix<T>& sp)//两个矩阵的行列数相同
    {
        vector<Trituple<T>> _tmp;
        size_t n1 = _sm.size();
        size_t n2 = sp._sm.size();
        _tmp.resize(n1 + n2);  //有点浪费空间

        int i = 0, j = 0, k = 0;
        while ((i < n1) && (j < n2))
        {
            if (_sm[i]._row == sp._sm[j]._row)//行相等
            {
                if (_sm[i]._col == sp._sm[j]._col)//列相等
                {
                    _tmp[k]._row = _sm[i]._row;
                    _tmp[k]._col = _sm[i]._col;
                    _tmp[k]._value = _sm[i]._value + sp._sm[j]._value;
                    i++;
                    j++;
                    k++;
                }
                else if (_sm[i]._col < sp._sm[j]._col) //_sm列小于sp列 ，小的先放入_tmp中
                {
                    _tmp[k]._row = _sm[i]._row;
                    _tmp[k]._col = _sm[i]._col;
                    _tmp[k]._value = _sm[i]._value;
                    i++;
                    k++;
                }
                else
                {
                    _tmp[k]._row = sp._sm[j]._row;
                    _tmp[k]._col = sp._sm[j]._col;
                    _tmp[k]._value = sp._sm[j]._value;
                    j++;
                    k++;
                }
            }
            else if (_sm[i]._row < sp._sm[i]._row)//_sm的行号小于sp,把这一行的数据都放进去
            {
                _tmp[k]._row = _sm[i]._row;
                _tmp[k]._col = _sm[j]._col;
                _tmp[k]._value = _sm[j]._value;
                i++;
                k++;
            }
            else
            {
                _tmp[k]._row = sp._sm[j]._row;
                _tmp[k]._col = sp._sm[j]._col;
                _tmp[k]._value = sp._sm[j]._value;
                j++;
                k++;
            }
        }

        _sm.resize(k);
        for (size_t i = 0; i < k; i++)
        {
            _sm[i] = _tmp[i];
        }
        return *this;
    }

下面来展示上述所有问题的完整代码，供大家参考：

#include<iostream>
using namespace std;
#include <vector>
template<class T>

class SparseMatrix
{
    template<class T>
    struct Trituple
    {
        Trituple(int row = 0, int col = 0, const T& value = T())
        : _row(row)
        , _col(col)
        , _value(value)
        {}

        size_t _row;//有效元素的行
        size_t _col;//有效元素的列
        T _value;//有效元素的值
    };

public:
    // 
    SparseMatrix(T* array, size_t row, size_t col, const T& invalid)
        : _row(row)
        , _col(col)
        , _invalid(invalid)
    {
        for (int i = 0; i < row; i++)
        {
            for (int j = 0; j < col; j++)
            {
                if (array[i*col + j] != invalid)//判断是否为无效值，
                {
                    Trituple<T> tmp(i, j, array[i*col + j]);//将有效值存放在三元组中
                    _sm.push_back(tmp); //借用vector来存储数据
                }
            }
        }
    }

    SparseMatrix()
        : _row(0)
        : _col(0)
        , _invalid(0)
    {}

    // 访问矩阵中的元素
    T& Acess(int row, int col)
    {
        size_t idx = 0;
        for (size_t i = 0; i < _row; i++)
        {
            for (size_t j = 0; j < _col; j++)
            {
                if (idx < _sm.size() && _sm[idx]._row == row && _sm[idx]._col == col)
                {
                    cout << _sm[idx]._value << endl;
                    return _sm[idx]._value;
                }
            }
        }
        cout << _invalid << endl;
        return _invalid;
    }
    template<class T>
    friend ostream& operator<<(ostream& _cout, const SparseMatrix<T>& sm)
    {
        size_t idx = 0;
        for (size_t i = 0; i < sm._row; i++)
        {
            for (size_t j = 0; j < sm._col; j++)
            {
                if (idx < sm._sm.size() && sm._sm[idx]._row == i && sm._sm[idx]._col == j)
                {
                    cout << sm._sm[idx++]._value << " ";
                }
                else
                {
                    cout << sm._invalid << " ";
                }
            }
            cout << endl;
        }
        cout << endl;
        return _cout;
    }



    //给出两种逆置方法的时间复杂度
    // 稀疏矩阵的转置
    SparseMatrix<T> Transport()//时间复杂度 O(列数*有效元素的个数+有效元素的个数)
    {
        vector<Trituple<T>> _sm2;
        size_t n = _sm.size();
        _sm2.resize(n);
        size_t count = 0;

        for (size_t i = 0; i < n; i++)
        {
            for (size_t j = 0; j < n; j++)
            {
                if (_sm[j]._col == i)   //把_sm中列为i的数找出来作为将来的行，以列优先达到复位是的行优先
                {
                    _sm2[count] = _sm[j]; //将数据保存在_sm2中返回是就是按照行优先来计算的
                    swap(_sm2[count]._row, _sm2[count]._col);//交换坐标
                    count++;
                }
            }
        }
        for (size_t i = 0; i < n; i++)
        {
            _sm[i] = _sm2[i];//在operator中调用默认的_sm是第一个的，所以还是按照原来的有效值存储顺序打印的，只是将行列交换后，原来每个行列的大小不一样而已，没有改变实质值；
        }
        swap(_row, _col);
        return *this;
    }

    // 稀疏矩阵的快速转置(时间复杂度：2*有效元素的个数+列数)
    SparseMatrix<T> FastTransport()
    {
        vector<Trituple<T>> _sm2;
        size_t n = _sm.size();
        _sm2.resize(n);

        size_t Count[5] = {0};//统计转置后矩阵每一行的个数(原矩阵每一列的个数)
        size_t Start[5] = {0};//统计转置后的矩阵每行在矩阵压缩中存储的位置(统计原矩阵中每一列第一个元素在_sm2中存储的位置)
        for (size_t i = 0; i < n; i++)
        {
            Count[_sm[i]._col]++;  //因为在Count初始化的时候全部初始化为0，所以在Count[_sm[i]._col]中找到第几列的时候就是给第几列++;计算出每列的元素个数；
        }
        for (size_t i = 1; i < _col; i++)
        {
            Start[i] = Start[i - 1] + Count[i - 1];
        }

        for (size_t i = 0; i < n; i++)
        {
            _sm2[Start[_sm[i]._col]] = _sm[i];//利用Start+Count计算出_sm2中每个元素的位置；
            swap(_sm2[Start[_sm[i]._col]]._col, _sm2[Start[_sm[i]._col]]._row);
            Start[_sm[i]._col]++;
        }

        for (size_t i = 0; i < n; i++)
        {
            _sm[i] = _sm2[i];
        }
        swap(_row, _col);
        return *this;
    }

    // 两个矩阵相加
    SparseMatrix<T> operator+(const SparseMatrix<T>& sp)//两个矩阵的行列数相同
    {
        vector<Trituple<T>> _tmp;
        size_t n1 = _sm.size();
        size_t n2 = sp._sm.size();
        _tmp.resize(n1 + n2);  //有点浪费空间

        int i = 0, j = 0, k = 0;
        while ((i < n1) && (j < n2))
        {
            if (_sm[i]._row == sp._sm[j]._row)//行相等
            {
                if (_sm[i]._col == sp._sm[j]._col)//列相等
                {
                    _tmp[k]._row = _sm[i]._row;
                    _tmp[k]._col = _sm[i]._col;
                    _tmp[k]._value = _sm[i]._value + sp._sm[j]._value;
                    i++;
                    j++;
                    k++;
                }
                else if (_sm[i]._col < sp._sm[j]._col) //_sm列小于sp列 ，小的先放入_tmp中
                {
                    _tmp[k]._row = _sm[i]._row;
                    _tmp[k]._col = _sm[i]._col;
                    _tmp[k]._value = _sm[i]._value;
                    i++;
                    k++;
                }
                else
                {
                    _tmp[k]._row = sp._sm[j]._row;
                    _tmp[k]._col = sp._sm[j]._col;
                    _tmp[k]._value = sp._sm[j]._value;
                    j++;
                    k++;
                }
            }
            else if (_sm[i]._row < sp._sm[i]._row)//_sm的行号小于sp,把这一行的数据都放进去
            {
                _tmp[k]._row = _sm[i]._row;
                _tmp[k]._col = _sm[j]._col;
                _tmp[k]._value = _sm[j]._value;
                i++;
                k++;
            }
            else
            {
                _tmp[k]._row = sp._sm[j]._row;
                _tmp[k]._col = sp._sm[j]._col;
                _tmp[k]._value = sp._sm[j]._value;
                j++;
                k++;
            }
        }

        _sm.resize(k);
        for (size_t i = 0; i < k; i++)
        {
            _sm[i] = _tmp[i];
        }
        return *this;
    }

private:
    vector<Trituple<T>> _sm;
    size_t _row;
    size_t _col;
    T _invalid;
};

void FunTest()
{
    int array[6][5] = {
        { 1, 0, 3, 0, 5 },
        { 0, 0, 0, 0, 0 },
        { 0, 0, 0, 0, 0 },
        { 1, 0, 3, 0, 5 },
        { 0, 0, 0, 0, 0 },
        { 0, 0, 0, 0, 0 } };

    int array1[6][5] = {
        { 0, 1, 0, 3, 6 },
        { 0, 0, 0, 0, 0 },
        { 0, 0, 0, 0, 0 },
        { 0, 1, 0, 3, 6 },
        { 0, 0, 0, 0, 0 },
        { 0, 0, 0, 0, 0 } };

    SparseMatrix<int> s((int*)array, 6, 5, 0);
    SparseMatrix<int> s1((int*)array1, 6, 5, 0);
    s.Acess(1, 1); //访问(1,1)元素
    cout << s << endl;
//  s.Transport();//进行逆置检测时只能检测一个
//  cout << s << endl;
    s.FastTransport();
    cout << s << endl;
    s.operator+(s1); //进行加法运算的时候必须把逆置复原
    cout << s << endl;
}

int main()
{
    FunTest();
    return 0;
}
thief thief
关注
  • 3
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
稀疏矩阵相加、相乘和转置（用三元组实现）
06-28
稀疏矩阵相加、相乘和转置（用三元组实现）
稀疏矩阵的运算-加、减、乘、转置(C-数据结构)
m0_61122217的博客
10-24 2055
以三元组的形式给出输入数据，选择对应的运算后给出对应输出结果(稀疏矩阵的运算器)
数组12——稀疏矩阵的压缩存储2——稀疏矩阵的相加
凌空的桨
12-18 1040
设有两个4*4的稀疏矩阵A和B,相加得到C，如图所示，请编写算法，要求利用三元组表示法实现两个稀疏矩阵的相加，并用矩阵形式输出结果。     【分析】 先比较两个稀疏矩阵的    先比较两个稀疏矩阵A和B的行号，如果行号相等，则比较列号;如果行号与列号都相等，则将对应的元素值相加，并将下标m与n下标都加1比较下一个元素;如果行号相等，列号不相等，则将列号较小的矩阵的元素赋给矩...
C++数据结构稀疏矩阵运算（含加减乘及快速转置）
m0_61886762的博客
10-20 3465
该函数实现的功能是矩阵的乘法，我们在线性代数中学习到的只有当前一项的列等于后一项的行时才可以进行相关的乘法，并且乘法规律则是第一行乘以第一列并且求和等于结果矩阵的1,1位置第一行乘以对应相乘第二列并且求和等于1.2位置以此类推。下面是稀疏矩阵的快速转置的实现，我们首先要定义两个数组来存储每一列具有多少个元素并且记录该列将转置到三元组的第几个位置，num数组则是存储一列具有多少个元素，position将记录转置到第几个位置。具体的实现内容则是进行循环将其相应位置进行加减法的运算即可。具有相应的报错处理。
数组：矩阵快速转置 矩阵相加 三元组顺序表/三元矩阵 随机生成稀疏矩阵 压缩矩阵【C语言，数据结构】（内含源代码）
最新发布
哦豁果奶的博客
11-17 3172
题目： 稀疏矩阵A，B均采用三元组顺序表表示，验证实现矩阵A快速转置算法，并设计、验证矩阵A、B相加得到矩阵C的算法。 题目分析： 1.从键盘输入矩阵的行数、列数，随机生成稀疏矩阵。 2.生成矩阵A、B后需先转换成三元顺序表，然后用三元顺序表来进行之后的操作。 3.在三元顺序表的基础上使用快速转置（非二维矩阵）。 4.得到三元矩阵相加的结果C。 5.不仅需要输出三元矩阵，还需要把结果转换成二维矩阵输出，以便题目观察结果。 6.程序执行的命令包括：(1)根据输入构造二维矩阵 (2)根据二维矩阵转换
稀疏矩阵的加法与转置
11-22
6. **稀疏矩阵转置**：`TransposeRLSMarix`函数实现矩阵的转置，转置过程中需要交换原矩阵的行下标和列下标，并重新组织三元组顺序表。 7. **主函数**：`main`函数是程序的入口点，调用上述函数完成矩阵的创建、...
xishujuzhen.rar_三元组加乘_稀疏矩阵 加_稀疏矩阵 转置_转置 稀疏矩阵
09-22
"转置_稀疏矩阵"是将原稀疏矩阵转置后，仍保持其三元组的存储形式，这样可以继续利用稀疏矩阵的优势进行高效运算。 在给定的压缩包文件中，"xishujuzhen.txt"可能包含了使用三元组表示的稀疏矩阵及其运算的示例代码...
数据结构稀疏矩阵的压缩存储
05-03
数据结构稀疏矩阵的压缩存储 数据结构稀疏矩阵的压缩存储是指在计算机科学和数学中，对稀疏矩阵进行压缩存储，以减少存储空间和提高计算效率的技术。稀疏矩阵是指矩阵中的大多数元素都是零的矩阵，这种矩阵在科学...
Java数据结构之稀疏矩阵定义与用法示例
08-28
稀疏矩阵支持多种运算，包括加法、减法、乘法和转置等。Java中可以使用加法运算符 (+) 来实现稀疏矩阵的加法运算。 public Triple plus(Triple term) { Triple tmp = new Triple(this); tmp.add(term); return ...
Python 稀疏矩阵-sparse 存储和转换
12-25
在科学与工程领域中求解线性模型时经常出现许多大型的矩阵，这些矩阵中大部分的元素都为0，被称为稀疏矩阵。用NumPy的ndarray数组保存这样的矩阵，将很浪费内存，由于矩阵的稀疏特性，可以通过只保存非零元素的相关...
稀疏矩阵的相加以及转置
07-14
数据结构之稀疏矩阵的相加以及转置，值得学习。
稀疏矩阵的压缩存储和转置
05-24
用三元组表示，实现了稀疏矩阵的压缩和存储
掌握稀疏矩阵的压缩存储存储方法。
10-29
一、 实验目的 1、 掌握稀疏矩阵的压缩存储存储方法。 2、 能利用三元组顺序表表示并实现稀疏矩阵。 3、 会利用三元组顺序表实现矩阵的加法运算。 二、 实验要求 1、 进行加法运算的两个矩阵由用户输入。并且用三元组顺序表表示。 2、 程序首先判断两个矩阵是否能够相加。若能，在进行运算后在屏幕上现实结果，否则给出相应信息。 3、 程序应能得到正确结果，用户界面显示良好。 4、 所写源代码编程风格良好，有详细注释。
稀疏矩阵的转置相加与相乘
10-22
稀疏矩阵的转置相加与相乘，简单的CSR存储方式下的稀疏矩阵基本运算
数据结构进阶(二)矩阵（稀疏矩阵）的压缩存储
热门推荐
IT全栈 华强工作室
05-02 6万+
矩阵（稀疏矩阵）的压缩存储注 本文转载地址:http://blog.163.com/zhoumhan_0351/blog/static/39954227201001112526244/ 为了节省存储空间并且加快处理速度，需要对这类矩阵进行压缩存储，压缩存储的原则是：不重复存储相同元素；不存储零值元素。一、相关概念㈠特殊矩阵 矩阵中存在大多数值相同的元,或非0元，且在矩...
利用三元组对稀疏矩阵进行压缩存储并实现矩阵的转置运算
平凡的博客
09-04 2万+
我们假设在m*n的矩阵中，有t个元素不为0，令a=t/(m*n),称a为矩阵的稀疏因子，通常认为a&lt;=0.05时称为稀疏矩阵。 为了节省存储空间，我们对稀疏矩阵进行压缩存储——只存储稀疏矩阵的非零元。因此，除了存储非零元的值之外，还必须同时记下它所在行和列的位置，反之，一个三元组(i, j, aij)惟一确定了矩阵A的一个非零元。由此，稀疏矩阵可由表示非零元的三元组及其行列数惟一确定。 ...
稀疏矩阵的压缩存储
Scrutiny的博客
05-02 1825
稀疏矩阵的压缩存储： 实现稀疏矩阵压缩存储，并实现矩阵转置和求和。 输入矩阵时，首先需要输入非零元素的个数，然后分别输入矩阵的 行号，列号和值。 输完2个矩阵后，自动进行计算第一个矩阵的转置以及两个矩阵的和。 例如：输入如下： 100 90 5 //矩阵的行数为100，列数为90，共5个非零元素。 1 10 100 //a(1,10)=100 50 60 200//a(50,60)=200 50 ...
稀疏矩阵的存储以及转置、加法、乘法操作实现
Curya的博客
09-09 3473
稀疏矩阵的存储以及转置、加法、乘法操作实现
稀疏矩阵的一些操作(相乘，求幂， 相加，转置)
daydream13580130043的博客
03-30 1669
矩阵相信大家都知道，而且一些常见操作，如相乘，相加相信大家也不陌生，就以矩阵相乘为例，计算机的常规实现也就是三层for吗 long[][] sum = new long[n][m]; for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) for (int k = 0; k < l; k++) ...
稀疏矩阵压缩存储与运算实验报告
实验目标是掌握数组应用，特别是稀疏矩阵的压缩存储方法，以及矩阵的基本运算，如转置和乘法。实验要求实现行逻辑链接顺序表或十字链表的存储，并编写相关算法。报告内容包括实验内容、目的、问题描述、实现过程、源...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值