三元组类与稀疏矩阵运算--c++【做题记录】

已于 2024-06-06 19:37:47 修改
阅读量453 收藏 10
点赞数 7
文章标签： 矩阵 c++ 算法
于 2024-03-15 19:59:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79790771/article/details/136748265
版权

实现三元组类

【题目要求】

按照给定的内容定义一个TripleMatrix类，每个TripleMatrix对象访问一个矩阵的信息。

 输入：第一行输入矩阵的行m，列n和非零元个数num 后续num行依次输入每个非零元的行，列和非零元的值 。

输出：首先显示三元组数组的内容，数字之间间隔一个空格。 然后以二维数组形式排列的稀疏矩阵效果，数字之间间隔一个空格。 输出稀疏矩阵的基本信息：行数，列数和非零元个数。

【测试样例】

【样例输入】

3 4 4

1 1 2

3 4 1

2 1 13

2 2 -1

【样例输出】

Print triple array.

row col item

1 1 2 2

1 13 2 2

-1 3 4 1

Print sparse matrix.

2 0 0 0

13 -1 0 0

0 0 0 1

line=3,column=4,nonzero number=4

【提示】

将输入的行、列、非零元素信息插入到三元组的思路提示：

  1. 如果是第一次输入，i=0时，则直接插入。
  2. 如果不是第一次输入，则应该考虑插入到什么位置，三元组数据的排序是优先考虑行，然后考虑列。
  3. 找到插入位置后，例如需要插入在j的地方，则需要考虑是否需要将已有三元组后续的元素后移，为j腾出空间，然后再插入。 需要考虑一些特殊的情况： 输入时行号列号不按顺序，输入重复的行号和列号，则重复输入的数据只记录后者。

【题解代码】

/*
用三元组存储稀疏矩阵，仅实现稀疏矩阵类并显示
*/
//用三元组存储稀疏矩阵(仅存储，不计算)

#include <iostream>
using namespace std;
#define MAX 100
#define ERROR 0
#define OK 1
typedef int Status;//函数结果状态类型
typedef struct{
    int row,col;    //三元组的行号、列号；
    int item;        //三元组的值;
}Triple;
//定义TripleMatrix类，每个TripleMatrix对象访问一个矩阵的信息
class TripleMatrix{
private:
    Triple data[MAX];//非零元三元组
    int mu,nu,num;   //矩阵的行数、列数和非零元个数
public:
    TripleMatrix();
    TripleMatrix(int m,int n);//创建对象时,完成属性的初始化
    ~TripleMatrix();
    Status setItem(int row,int col,int item);//根据行号，列号，非零元，在尾部添加一个三元组项
    int getItem(int row,int col);//根据行号列号，获得矩阵元素值
    void printMatrix();//按矩阵方式打印稀疏矩阵
    void printTriple();//打印三元组数组
};
//填写代码实现三元组类中的成员函数 
TripleMatrix::TripleMatrix()
{
    mu=0;
    nu=0;
    num=0;
}
TripleMatrix::TripleMatrix(int m,int n)
{
    nu=n;
    mu=m;
    num=0;
}
TripleMatrix::~TripleMatrix()
{
    //使用的是静态数组，可以不用析构函数
}
Status TripleMatrix::setItem(int row,int col,int item)
{
    if(row>mu||col>nu)//超范
        return ERROR;
    if(num==MAX)//即将超范
        return ERROR;
    if(item==0)//为0时不需要存储
        return OK;
    
    int index=0;
    while(index<num)
    {
        if(row>data[index].row)//要找的行和列比三元组中已有的行列大
            index++;
        else if(row==data[index].row&&col>data[index].col)//要找的行号相等，列不相等,继续找列
            index++;
        else{                 //找到了应该插入的位置
            break;
        }
    }
    if((row==data[index].row)&&col==data[index].col)//当前行列已有元素，用新插入的元素替换
        data[index].item=item;
    else                      //需要插入新元素
    {
        for(int i=num;i>index;i--)//先从后往前把后面所有的元素向后以腾出新元素的位置
        {
            data[i].row=data[i-1].row;            //可以简化成data[i]=data[i-1];
            data[i].col=data[i-1].col;
            data[i].item=data[i-1].item;
        }
        //再在index的位置存入新元素
        data[index].row=row;
        data[index].col=col;
        data[index].item=item;
        num++;
    }
    return OK;
}
int TripleMatrix::getItem(int row,int col)
{
    if(row>mu||col>nu)
        return 0;
    for(int i=0;i<num;i++)//如果行和列匹配三元组，返回非零元
    {
        if(data[i].row==row&&data[i].col==col)
        {
            return data[i].item;
        }
    }
}
void TripleMatrix::printMatrix()
{
    int tripleindex=0;
    cout<<"Print sparse matrix.\n";
    for(int i=1;i<=mu;i++)
    {
        for(int j=1;j<=nu;j++)
        {
            if(i==data[tripleindex].row&&j==data[tripleindex].col)
            {                                     //如果找到了行列号匹配的三元组就输出非零元
                cout<<data[tripleindex].item;   
                tripleindex++;
                if(j<nu)
                    cout<<" ";
            }
            else
                cout<<"0 ";
        }
        cout<<endl;
    }
    cout<<"line="<<mu<<",column="<<nu<<",nonzero number="<<num;
    return ;
}
void TripleMatrix::printTriple()
{
    cout<<"Print triple array."<<endl;
    cout<<"row col item"<<endl;
    for(int i=0;i<num;i++)
    {
        cout<<data[i].row<<" ";
        cout<<data[i].col<<" ";
        cout<<data[i].item<<endl;
    }
}

//输入函数
void inputMatrix(int m,int n,int num,TripleMatrix& triple)
{
    int row,col,item;
    for(int i=1;i<=num;i++)
    {
        cout<<"输入行列和非零元:\n";
        cin>>row>>col>>item;
        if(item!=0)
        {
            if(triple.setItem(row,col,item)==ERROR)
            {
                cout<<"行列号不正确，或三元数组满，不能正确存储"<<endl;
                break;
            }
        }
    }
}

int main(){
    int m,n,num;
    cout << "请输入矩阵的行，列和非零元个数:";
    cin >> m >> n >> num;
    TripleMatrix triple(m,n);
    inputMatrix(m,n,num,triple);
    triple.printTriple();
    triple.printMatrix();
    return 0;
}

稀疏矩阵加法

【题目要求】

实现稀疏矩阵的加法，输入任意两个稀疏矩阵A和B，求出它们的和矩阵C。

实现步骤是：

(1) 创建三个稀疏矩阵。

(2)实现加法运算。

(3)输出稀疏矩阵相加的结果。

[输入说明] 第一行输入第一个矩阵的行n，列m，非零元素个数num(行列的序号从1开始) 后续num行依次输入行row，列col和非零元item 接着输入第二个矩阵的行n，列m，非零元素个数num 后续num行依次输入行row，列col和非零元item

[输出说明] 需要对输入的两个矩阵进行检查，仅有行列相同的矩阵才能相加。 如果矩阵可以相加，则在矩阵相加后，打印矩阵内容。并显示矩阵行列数和非零元个数。 如果矩阵不能相加，则提示错误：Matrices cannot be added. 

【测试样例】

【输入数据1】

3 3 2

1 1 5

2 3 1

3 3 4

1 1 5

1 2 6

3 2 1

2 1 1

【输出数据1】

After add:

10 6 0

1 0 1

0 1 0

line=3,column=3,nonzero number=5

【输入数据2】

3 3 2

1 1 5

2 3 1

3 2 2

1 1 5

1 2 6

【输出数据2】

Matrices cannot be added.

【题解代码】

/*
用三元组存储稀疏矩阵，并完成加法（头歌使用的例子）
这个例子输入行号，列号，非零元，再存储
*/

#include <iostream>
using namespace std;

#define MAX 100
#define ERROR 0
#define OK 1
typedef int Status;//函数结果状态类型

typedef struct{
    int row,col;    //三元组的行号、列号；
    int item;        //三元组的值;
}Triple;

//定义TripleMatrix类，每个TripleMatrix对象访问一个矩阵的信息
class TripleMatrix{
private:
    Triple data[MAX];//非零元三元组
    int mu,nu,num;   //矩阵的行数、列数和非零元个数
public:
    TripleMatrix();
    TripleMatrix(int m,int n);//创建对象时,完成属性的初始化
    ~TripleMatrix();
    Status setItem(int row,int col,int item);//根据行号，列号，非零元，在尾部添加一个三元组项
    int getItem(int row,int col);//根据行号列号，获得矩阵元素值
    void printMatrix();//按矩阵方式打印稀疏矩阵
    void printTriple();//打印三元组数组
    void inputMatrix(int m,int n,int num,TripleMatrix& triple);
    friend bool matrixAdd(TripleMatrix a,TripleMatrix b,TripleMatrix& result);
};

TripleMatrix::TripleMatrix(){
    //初始化矩阵的行数、列数和非零元个数
    mu = 0;
    nu = 0;
    num = 0;
}
TripleMatrix::TripleMatrix(int m,int n)
{
    nu=n;
    mu=m;
    num=0;
}
//自己填写代码实现三元组类
TripleMatrix::~TripleMatrix()
{
    //使用的是静态数组，可以不用析构函数
}
Status TripleMatrix::setItem(int row,int col,int item)
{
    if(row>mu||col>nu)//超范
        return ERROR;
    if(num==MAX)//即将超范
        return ERROR;
    if(item==0)//为0时不需要存储
        return OK;

    int index=0;
    while(index<num)
    {
        if(row>data[index].row)//要找的行和列比三元组中已有的行列大
            index++;
        else if(row==data[index].row&&col!=data[index].col)//要找的行号相等，列不相等,继续找列
            index++;
        else{                 //找到了应该插入的位置
            break;
        }
    }
    if((row==data[index].row)&&col==data[index].col)//当前行列已有元素，用新插入的元素替换
        data[index].item=item;
    else                      //需要插入新元素
    {
        for(int i=num;i>index;i--)//先从后往前把后面所有的元素向后移腾出新元素的位置
        {
            data[i].row=data[i-1].row;            //可以简化成data[i]=data[i-1];
            data[i].col=data[i-1].col;
            data[i].item=data[i-1].item;
        }
        //再在index的位置存入新元素
        data[index].row=row;
        data[index].col=col;
        data[index].item=item;
        num++;
    }
    return OK;
}
int TripleMatrix::getItem(int row,int col)
{
    if(row>mu||col>nu)
        return 0;
    for(int i=0;i<num;i++)//如果行和列匹配三元组，返回非零元
    {
        if(data[i].row==row&&data[i].col==col)
        {
            return data[i].item;
        }
    }
    return 0;
}
void TripleMatrix::printMatrix()
{
    int tripleindex=0;
    int count=0;//记录非零元个数
    cout<<"Print sparse matrix.\n";
    for(int i=1;i<=mu;i++)
    {
        for(int j=1;j<=nu;j++)
        {
            if(i==data[tripleindex].row&&j==data[tripleindex].col)
            {                                     //如果找到了行列号匹配的三元组就输出非零元
                cout<<data[tripleindex].item;
                tripleindex++;
                count++;
                if(j<nu)
                    cout<<" ";
            }
            else{
                cout<<"0";
                if(j<nu)
                    cout<<" ";
            }
                
        }
        cout<<endl;
    }
    cout<<"line="<<mu<<",column="<<nu<<",nonzero number="<<count;
    return ;
}
void TripleMatrix::printTriple()
{
    cout<<"Print triple array."<<endl;
    cout<<"row col item"<<endl;
    for(int i=0;i<num;i++)
    {
        cout<<data[i].row<<" ";
        cout<<data[i].col<<" ";
        cout<<data[i].item;
        if(i<num-1)
            cout<<endl;
    }
}
//输入函数
void TripleMatrix::inputMatrix(int m,int n,int num,TripleMatrix& triple)
{
    int row,col,item;
    for(int i=1;i<=num;i++)
    {
        //cout<<"输入行列和非零元:\n";
        cin>>row>>col>>item;
        if(item!=0)
        {
            if(triple.setItem(row,col,item)==ERROR)
            {
                cout<<"行列号不正确，或三元数组满，不能正确存储"<<endl;
                break;
            }
        }
    }
}
/*
实现矩阵a与矩阵b的相加，结果放入矩阵result
如果矩阵可以相加，完成相加操作，结果放入result，并返回true
如果矩阵不能相加，返回false
*/
bool matrixAdd(TripleMatrix a,TripleMatrix b,TripleMatrix& result){
//
    if(a.mu!=b.mu||b.mu!=result.mu||a.nu!=b.nu||b.nu!=result.nu)
        return false;             //判断矩阵ab或result行列是否相等
    else{
        for(int i=1;i<=a.mu;i++)  //遍历行
        {
            for(int j=1;j<=a.nu;j++)   //遍历列
            {
                int item=a.getItem(i,j)+b.getItem(i,j);
                if(item!=0)
                    result.setItem(i,j,item);   //将非零元插入
            }
        }
        return true;
    }
}

/*加法的测试代码*/
int main(){
    int m,n,num;
    cout << "请输入第一个矩阵的行，列，非零元素个数:";
    cin >> m >> n >> num;
    cout << "第一个矩阵："<< endl;
    TripleMatrix tripleA(m,n);
    tripleA.inputMatrix(m,n,num,tripleA);
    // tripleA.printMatrix();

    cout<<"\n请输入第二个矩阵的行，列，非零元个数:";
    cin>>m>>n>>num;
    cout<<"第二个矩阵："<<endl;
    TripleMatrix tripleB(m,n);
    tripleB.inputMatrix(m,n,num,tripleB);
    // tripleB.printMatrix();

    TripleMatrix tripleResult(m,n);
    if(matrixAdd(tripleA,tripleB,tripleResult))
    {
        cout<<"After add:"<<endl;
        tripleResult.printMatrix();
    }
    else
        cout<<"Matrices cannot be added.";

    return 0;
}

稀疏矩阵乘法

【题目要求】

输入任意两个稀疏矩阵A和B，求出它们的乘积矩阵C。

实现步骤是：

(1) 创建三个稀疏矩阵。

(2) 实现乘法运算。

(3) 输出稀疏矩阵相乘的结果。

[输入说明] 第一行输入第一个矩阵的行n，列m，非零元素个数num 后续num行依次输入行row，列col和非零元item 接着输入第二个矩阵的行n，列m，非零元素个数num 后续num行依次输入行row，列col和非零元item

[输出说明] 需要对输入的两个矩阵进行检查，仅有符合矩阵相乘规则的矩阵才能相乘。 如果矩阵可以相乘，则在矩阵相乘后，打印矩阵内容。并显示矩阵行列数和非零元个数。 如果矩阵不能相乘，则提示错误：Matrices cannot be multiplied.

（这个题和上面的加法基本思路一样的，只需要改求和函数为求积函数即可）

【测试样例】

【输入数据】

3 3 2

1 1 5

2 3 1

3 2 2

1 1 2

3 1 4

【输出范例】

After Multiply:

10 0

4 0

0 0

line=3,column=2,nunzero number=2

【题解代码】



#include <iostream>
using namespace std;

#define MAX 100
#define ERROR 0
#define OK 1
typedef int Status;//函数结果状态类型

typedef struct
{
    int row,col;    //三元组的行号、列号；
    int item;        //三元组的值;
} Triple;

//定义TripleMatrix类，每个TripleMatrix对象访问一个矩阵的信息
class TripleMatrix
{
private:
    Triple data[MAX];//非零元三元组
    int mu,nu,num;   //矩阵的行数、列数和非零元个数
public:
    TripleMatrix();
    TripleMatrix(int m,int n);//创建对象时,完成属性的初始化
    ~TripleMatrix();
    Status setItem(int row,int col,int item);//根据行号，列号，非零元，在尾部添加一个三元组项
    int getItem(int row,int col);//根据行号列号，获得矩阵元素值
    void printMatrix();//按矩阵方式打印稀疏矩阵
    void printTriple();//打印三元组数组
    void inputMatrix(int m,int n,int num,TripleMatrix& triple);
    friend bool matrixAdd(TripleMatrix a,TripleMatrix b,TripleMatrix& result);
    friend bool matrixMulty(TripleMatrix a,TripleMatrix b,TripleMatrix &result);
};

TripleMatrix::TripleMatrix()
{
    //初始化矩阵的行数、列数和非零元个数
    mu = 0;
    nu = 0;
    num = 0;
}
TripleMatrix::TripleMatrix(int m,int n)
{
    nu=n;
    mu=m;
    num=0;
}
//自己填写代码实现三元组类
TripleMatrix::~TripleMatrix()
{
    //使用的是静态数组，可以不用析构函数
}
Status TripleMatrix::setItem(int row,int col,int item)
{
    if(row>mu||col>nu)//超范
        return ERROR;
    if(num==MAX)//即将超范
        return ERROR;
    if(item==0)//为0时不需要存储
        return OK;

    int index=0;
    while(index<num)
    {
        if(row>data[index].row)//要找的行和列比三元组中已有的行列大
            index++;
        else if(row==data[index].row&&col!=data[index].col)//要找的行号相等，列不相等,继续找列
            index++;
        else                  //找到了应该插入的位置
        {
            break;
        }
    }
    if((row==data[index].row)&&col==data[index].col)//当前行列已有元素，用新插入的元素替换
        data[index].item=item;
    else                      //需要插入新元素
    {
        for(int i=num; i>index; i--) //先从后往前把后面所有的元素向后移腾出新元素的位置
        {
            data[i].row=data[i-1].row;            //可以简化成data[i]=data[i-1];
            data[i].col=data[i-1].col;
            data[i].item=data[i-1].item;
        }
        //再在index的位置存入新元素
        data[index].row=row;
        data[index].col=col;
        data[index].item=item;
        num++;
    }
    return OK;
}
int TripleMatrix::getItem(int row,int col)
{
    if(row>mu||col>nu)
        return 0;
    for(int i=0; i<num; i++) //如果行和列匹配三元组，返回非零元
    {
        if(data[i].row==row&&data[i].col==col)
        {
            return data[i].item;
        }
    }
    return 0;
}
void TripleMatrix::printMatrix()
{
    int tripleindex=0;
    int count=0;//记录非零元个数
    // cout<<"Print sparse matrix.\n";
    for(int i=1; i<=mu; i++)
    {
        for(int j=1; j<=nu; j++)
        {
            if(i==data[tripleindex].row&&j==data[tripleindex].col)
            {
                //如果找到了行列号匹配的三元组就输出非零元
                cout<<data[tripleindex].item;
                tripleindex++;
                count++;
                if(j<nu)
                    cout<<" ";
            }
            else
            {
                cout<<"0";
                if(j<nu)
                    cout<<" ";
            }

        }
        cout<<endl;
    }
    cout<<"line="<<mu<<",column="<<nu<<",nonzero number="<<count;
    return ;
}
void TripleMatrix::printTriple()
{
    cout<<"Print triple array."<<endl;
    cout<<"row col item"<<endl;
    for(int i=0; i<num; i++)
    {
        cout<<data[i].row<<" ";
        cout<<data[i].col<<" ";
        cout<<data[i].item;
        if(i<num-1)
            cout<<endl;
    }
}
//输入函数
void TripleMatrix::inputMatrix(int m,int n,int num,TripleMatrix& triple)
{
    int row,col,item;
    for(int i=1; i<=num; i++)
    {
        //cout<<"输入行列和非零元:\n";
        cin>>row>>col>>item;
        if(item!=0)
        {
            if(triple.setItem(row,col,item)==ERROR)
            {
                cout<<"行列号不正确，或三元数组满，不能正确存储"<<endl;
                break;
            }
        }
    }
}

bool matrixMulty(TripleMatrix a,TripleMatrix b,TripleMatrix& result)
{
//
    int i,j,k;
    if(a.nu!=b.mu)           //判断是否满足可以相乘的条件，a列数等于b行数才能相乘
        return false;
    result.mu=a.mu;          //初始化result的行列值
    result.nu=b.nu;
    //乘法计算
    for(i=1; i<=a.mu; i++)
    {
        for(j=1; j<=b.nu; j++)
        {
            int sum=0;
            for(k=1; k<=a.nu; k++)
            {
                sum+=a.getItem(i,k)*b.getItem(k,j);
            }
            if(sum!=0)        //计算出来的值不为零才插入
                result.setItem(i,j,sum);
        }
    }
    return true;
}

int main()
{
    int m,n,num;
    cout << "请输入第一个矩阵的行，列，非零元素个数:";
    cin >> m >> n >> num;
    cout << "第一个矩阵："<< endl;
    TripleMatrix tripleA(m,n);
    tripleA.inputMatrix(m,n,num,tripleA);
    tripleA.printMatrix();

    cout<<"\n输入第二个矩阵行，列，非零元个数：";
    cin>>m>>n>>num;
    cout<<"第二个矩阵"<<endl;
    TripleMatrix tripleB(m,n);
    tripleB.inputMatrix(m,n,num,tripleB);
    tripleB.printMatrix();

    TripleMatrix tripleResult;
    if(matrixMulty(tripleA,tripleB,tripleResult))
    {
        cout<<"After Multiply:"<<endl;
        tripleResult.printMatrix();
    }
    else
        cout<<"Matrices cannot be multiplied.";

    return 0;
}

。

菜包小姐的先生
关注
  • 7
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C/C++ sparse matrix 稀疏矩阵算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-05 5384
稀疏矩阵算法（sparse matrix）是一种用于处理大多数元素为零的矩阵的算法。在稀疏矩阵中，非零元素的数量远远小于矩阵的总元素数。稀疏矩阵算法的目标是以更少的存储空间和计算复杂度来表示和操作这些矩阵。
三元组稀疏矩阵的定义、加法、乘法——C++类、静态数组实现
九桢的博客
11-21 2252
稀疏矩阵
三元组 c++
09-18
三元组 使用c++语言写出数据结构三元组，主要为基础数据结构课程资源
三元组 C++
m0_53176241的博客
12-16 5241
用1，2，3…9组成3元组<abc，def，ghi>，每个数字恰好使用一次。 要求三个数的比例为abc：def：ghi=1：2：3。输出所有3元组。 【输入格式】 无 【输出格式】 若干行,每行三个数表示一个三元组(每个数之间用一个空格分隔) #include <iostream> using namespace std; int main() { int a, b, c; for(a=123;a<=329;a++) { b = 2*a; c = 3*a; int
c++三元组
2301_76461941的博客
03-04 539
蓝桥杯真题
三元组（C++ 实现矩阵快速转置)
最新发布
qq_74156152的博客
10-16 1392
三元组稀疏矩阵是一种高效存储稀疏矩阵的方法。它通过记录矩阵中非零元素的行、列和值来表示一个稀疏矩阵。我们在三元组里存储的是每个元素的行、列以及值。任意输入一个稀疏矩阵M，用三元组顺序表压缩存储该稀疏矩阵M，然后求其转置矩阵T，并输出转置矩阵T。
C++面向对象实现稀疏矩阵的三元组表示
A Lucky Boy的博客
05-05 1593
/ 其中第一个三元组表示第二行第二列的元素为2，// 第二个三元组表示第三行第二列的元素为1，// 第三个三元组表示第四行第四列的元素为3。row_idx：存储非零元素的行坐标；col_idx：存储非零元素的列坐标；value：存储非零元素的值。
稀疏矩阵 c++ 三元组表
05-03
总结，稀疏矩阵通过三元组表的存储方式在处理大量零元素的矩阵时，既能节省存储空间，又能提高运算效率。C++中的实现可以通过自定义结构体或类，结合STL容器，提供灵活且高效的操作接口。在实际应用中，掌握稀疏矩阵...
稀疏矩阵运算器（C语言实现，代码完整，可读性很好）
06-27
1. 以“带行逻辑链接信息”的三元组顺序表表示稀疏矩阵，实现两个矩阵相加、 相减和相乘的运算。稀疏矩阵的输入形式采用三元组表示，而运算结果的矩阵则 以通常的阵列形式列出。 2. 首先应输入矩阵的行数和列数，并...
数据结构C语言版-稀疏矩阵的三元组顺序表存储表示和实现最新文档.doc
12-01
数据结构 C 语言版-稀疏矩阵的三元组顺序表存储表示和实现最新文档 本文档介绍了稀疏矩阵的三元组顺序表存储表示和实现的相关知识点。 1. 稀疏矩阵的定义： 稀疏矩阵是一种特殊的矩阵，在矩阵中只有少数元素为非...
三元组-稀疏矩阵的实现
06-22
三元组-稀疏矩阵的实现 在计算机科学和数学中，稀疏矩阵（Sparse Matrix）是一种特殊的矩阵结构，其特点是矩阵中非零元素的个数远远小于矩阵元素的总数，并且非零元素的分布没有规律。与之相区别的是，如果非零元素...
稀疏矩阵 c++
11-27
稀疏矩阵 创建 删除 加减等 稀疏矩阵 c++
17.稀疏矩阵和三元组稀疏矩阵压缩算法.ppt
03-02
17.稀疏矩阵和三元组稀疏矩阵压缩算法.ppt
c++ STL tuple简单使用
weixin_45063703的博客
11-22 586
c++ STL tuple简单使用可以把tuple理解为pair的扩展，tuple可以声明二元组，也可以声明三元组。tuple可以等价为结构体使用。
（c++)实现用三元组表存储矩阵，实现矩阵的输出，以及三元组表的快速转置功能
weixin_63160898的博客
11-01 1770
三元组表的操作
三元组(C++)
chengzhang41103的博客
05-03 1951
给定两个整数K，S 问有多少三元组(x,y,z)满足 1:0<=x,y,z<=K 2:x+y+z=S
C++ STL之tuple详解
行码棋
02-18 8982
C++STL之tuple详解
C++实现稀疏矩阵的操作，三元组存储---数据结构
Original_xin的博客
12-26 4778
顺序存储结构来表示三元组表，则可以的稀疏矩阵的一种压缩形式。三元组表又称有序的双下标法，它的特点是，非零元素在表中有序存储，因此便于进行依行顺序处理矩阵运算。 1.需求分析： （1） 输入的形式和输入值的范围：无需自己输入数据，程序是可以自动生成一个稀疏矩阵并输出在界面中。 （2）输出的形式：建立成功后会将三元组表中的数据按照每个元素所在的行号，列号输出元素值；稀疏矩阵的加法则基于三元组表，将两个三元组表的元素进行合并成一个三元组表，然后按照合成的三元组表输出稀疏矩阵信息。 （3） 程序所能达到的功能： 1

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值