第八周(2) 项目3.2-稀疏矩阵的三元组表示的实现及应用

最新推荐文章于 2022-10-26 22:32:02 发布
最新推荐文章于 2022-10-26 22:32:02 发布
阅读量298 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lt1095862229/article/details/78282408
版权

【项目 - 稀疏矩阵相加】 
　　采用三元组存储稀疏矩阵，设计两个稀疏矩阵相加的运算算法 
提示1：两个行数、列数相同的矩阵可以相加 
提示2：充分利用已经建立好的算法库解决问题

[参考解答1]　

#include <stdio.h>
#include "tup.h"
bool MatAdd(TSMatrix a,TSMatrix b,TSMatrix &c)
{
    int i,j;
    ElemType va,vb,vc;
    if (a.rows!=b.rows || a.cols!=b.cols)
        return false;                        //行数或列数不等时不能进行相加运算
    c.rows=a.rows;
    c.cols=a.cols;       //c的行列数与a的相同
    c.nums=0;
    for(i=0; i<M; i++)
        for(j=0; j<N; j++)
        {
            Assign(a,va,i,j);
            Assign(b,vb,i,j);
            vc=va+vb;
            if(vc)
                Value(c,vc,i,j);
        }
    return true;
}

int main()
{
    TSMatrix ta,tb,tc;
    int A[M][N]=
    {
        {0,0,1,0,0,0,0},
        {0,2,0,0,0,0,0},
        {3,0,0,0,0,0,0},
        {0,0,0,5,0,0,0},
        {0,0,0,0,6,0,0},
        {0,0,0,0,0,7,4}
    };
    int B[M][N]=
    {
        {0,0,10,0,0,0,0},
        {0,0,0,20,0,0,0},
        {0,0,0,0,0,0,0},
        {0,0,0,50,0,0,0},
        {0,0,20,0,0,0,0},
        {0,0,0,10,0,0,4}
    };
    CreatMat(ta,A);
    CreatMat(tb,B);
    printf("A:\n");
    DispMat(ta);
    printf("B:\n");
    DispMat(tb);
    if(MatAdd(ta, tb, tc))
    {
        printf("A+B:\n");
        DispMat(tc);
    }
    else
    {
        printf("相加失败\n");
    }
    return 0;
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61

[参考解答2] 
　　下面给出的解答，没有利用算法库中已经实现的Assign和Value两个基本运算，而是直接e采取了更为直接的方法去完成。用i和j两个变量扫描三元组a和b，按行序优先的原则进行处理，将结果存放于c中。当a的当前元素和b的当前元素的行号和列号均相等时，将它们的值相加，只有在相加值不为0时，才在c中添加一个新的元素。

#include <stdio.h>
#include "tup.h"
bool MatAdd(TSMatrix a,TSMatrix b,TSMatrix &c)
{
    int i=0,j=0,k=0;
    ElemType v;
    if (a.rows!=b.rows || a.cols!=b.cols)
        return 0;        //行数或列数不等时不能进行相加运算
    c.rows=a.rows;
    c.cols=a.cols;       //c的行列数与a的相同
    while (i<a.nums && j<b.nums)         //处理a和b中的每个元素
    {
        if (a.data[i].r==b.data[j].r)    //行号相等时
        {
            if(a.data[i].c<b.data[j].c)  //a元素的列号小于b元素的列号
            {
                c.data[k].r=a.data[i].r;//将a元素添加到c中
                c.data[k].c=a.data[i].c;
                c.data[k].d=a.data[i].d;
                k++;
                i++;
            }
            else if (a.data[i].c>b.data[j].c)//a元素的列号大于b元素的列号
            {
                c.data[k].r=b.data[j].r;      //将b元素添加到c中
                c.data[k].c=b.data[j].c;
                c.data[k].d=b.data[j].d;
                k++;
                j++;
            }
            else                    //a元素的列号等于b元素的列号
            {
                v=a.data[i].d+b.data[j].d;
                if (v!=0)           //只将不为0的结果添加到c中
                {
                    c.data[k].r=a.data[i].r;
                    c.data[k].c=a.data[i].c;
                    c.data[k].d=v;
                    k++;
                }
                i++;
                j++;
            }
        }
        else if (a.data[i].r<b.data[j].r) //a元素的行号小于b元素的行号
        {
            c.data[k].r=a.data[i].r;      //将a元素添加到c中
            c.data[k].c=a.data[i].c;
            c.data[k].d=a.data[i].d;
            k++;
            i++;
        }
        else                              //a元素的行号大于b元素的行号
        {
            c.data[k].r=b.data[j].r;      //将b元素添加到c中
            c.data[k].c=b.data[j].c;
            c.data[k].d=b.data[j].d;
            k++;
            j++;
        }
    }
    while (i<a.nums)         //a中尚有元素时
    {
        c.data[k].r=a.data[i].r;//将a元素添加到c中
        c.data[k].c=a.data[i].c;
        c.data[k].d=a.data[i].d;
        k++;
        i++;
    }
    while (j<b.nums)         //b中尚有元素时
    {
        c.data[k].r=b.data[j].r;      //将b元素添加到c中
        c.data[k].c=b.data[j].c;
        c.data[k].d=b.data[j].d;
        k++;
        j++;
    }
    c.nums=k;
    return true;
}

int main()
{
    TSMatrix ta,tb,tc;
    int A[M][N]=
    {
        {0,1,0,0,0,0,0},
        {0,2,0,0,0,0,0},
        {3,0,0,0,0,0,0},
        {0,0,0,5,0,0,0},
        {0,0,0,0,6,0,0},
        {0,0,0,0,0,7,4}
    };
    int B[M][N]=
    {
        {0,0,10,0,0,0,0},
        {0,0,0,20,0,0,0},
        {0,0,0,0,0,0,0},
        {0,0,0,50,0,0,0},
        {0,0,20,0,0,0,0},
        {0,0,0,10,0,0,4}
    };
    CreatMat(ta,A);
    CreatMat(tb,B);
    printf("A:\n");
    DispMat(ta);
    printf("B:\n");
    DispMat(tb);
    if(MatAdd(ta, tb, tc))
    {
        printf("A+B:\n");
        DispMat(tc);
    }
    else
    {
        printf("相加失败\n");
    }
    return 0;
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119

　　对比两种方案，“参考解答1”利用Assign和Value两个基本运算的方案，可以在只知道“矩阵加法是对应位置的元素相加”的基础上就可以求解；而“参考解答2”则不得不关注在数据存储层面的细节，以致于矩阵加法的规则都不容易看出来了。“参考解答2”中繁杂的代码，违反了程序设计中诸多的原则（例如模块化），相对“参考解答1”的简洁中透出的优雅，该不是学习者效仿的思维。

附：1楼评论中带bug的解答，原参考解答2。重点观察少了while (i<a.nums)、while (j<b.nums)两个循环，当a和b的最后一个元素不在同一行同一列时，会丢数据的。这个bug的漏网，和main函数中采用的测试数据不够好有关，让两个矩阵非0元素在同一行同一列，忽略了“边界”数据的重要性。 
　　与此同时，再次体会参考解答1的好处，缺少了一层抽象，对应的就是处处要考虑细节。智者千虑，必有一失，还是要运用上工程中的原则为好。

#include <stdio.h>
#include "tup.h"
bool MatAdd(TSMatrix a,TSMatrix b,TSMatrix &c)
{
    int i=0,j=0,k=0;
    ElemType v;
    if (a.rows!=b.rows || a.cols!=b.cols)
        return 0;        //行数或列数不等时不能进行相加运算
    c.rows=a.rows;
    c.cols=a.cols;       //c的行列数与a的相同
    while (i<a.nums && j<b.nums)         //处理a和b中的每个元素
    {
        if (a.data[i].r==b.data[j].r)    //行号相等时
        {
            if(a.data[i].c<b.data[j].c)  //a元素的列号小于b元素的列号
            {
                c.data[k].r=a.data[i].r;//将a元素添加到c中
                c.data[k].c=a.data[i].c;
                c.data[k].d=a.data[i].d;
                k++;
                i++;
            }
            else if (a.data[i].c>b.data[j].c)//a元素的列号大于b元素的列号
            {
                c.data[k].r=b.data[j].r;      //将b元素添加到c中
                c.data[k].c=b.data[j].c;
                c.data[k].d=b.data[j].d;
                k++;
                j++;
            }
            else                    //a元素的列号等于b元素的列号
            {
                v=a.data[i].d+b.data[j].d;
                if (v!=0)           //只将不为0的结果添加到c中
                {
                    c.data[k].r=a.data[i].r;
                    c.data[k].c=a.data[i].c;
                    c.data[k].d=v;
                    k++;
                }
                i++;
                j++;
            }
        }
        else if (a.data[i].r<b.data[j].r) //a元素的行号小于b元素的行号
        {
            c.data[k].r=a.data[i].r;      //将a元素添加到c中
            c.data[k].c=a.data[i].c;
            c.data[k].d=a.data[i].d;
            k++;
            i++;
        }
        else                              //a元素的行号大于b元素的行号
        {
            c.data[k].r=b.data[j].r;      //将b元素添加到c中
            c.data[k].c=b.data[j].c;
            c.data[k].d=b.data[j].d;
            k++;
            j++;
        }
        c.nums=k;
    }
    return true;
}

int main()
{
    TSMatrix ta,tb,tc;
    int A[M][N]=
    {
        {0,0,1,0,0,0,0},
        {0,2,0,0,0,0,0},
        {3,0,0,0,0,0,0},
        {0,0,0,5,0,0,0},
        {0,0,0,0,6,0,0},
        {0,0,0,0,0,7,4}
    };
    int B[M][N]=
    {
        {0,0,10,0,0,0,0},
        {0,0,0,20,0,0,0},
        {0,0,0,0,0,0,0},
        {0,0,0,50,0,0,0},
        {0,0,20,0,0,0,0},
        {0,0,0,10,0,0,4}
    };
    CreatMat(ta,A);
    CreatMat(tb,B);
    printf("A:\n");
    DispMat(ta);
    printf("B:\n");
    DispMat(tb);
    if(MatAdd(ta, tb, tc))
    {
        printf("A+B:\n");
        DispMat(tc);
    }
    else
    {
        printf("相加失败\n");
    }
    return 0;
}
拾柒先生
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构— 数组、特殊矩阵、稀疏矩阵
四季轮换叶，一路招摇胜
04-21 4181
数组：是一组具有相同数据类型的数据元素的集合。数组元素按某种次序存储在一个地址连续的内存单元空间中。三角矩阵分为：上三角矩阵、下三角矩阵。稀疏矩阵：具有较多的零元素，且非零元素的分布无规律的矩阵。...
python建立空矩阵_SciPy创建稀疏矩阵
weixin_39924486的博客
12-19 1159
3. SciPy创建稀疏矩阵严格意义上讲ndarray数据类型应属数组而非矩阵，而matrix才是矩阵，这个在NumPy创建matrix一章里有讲述，是最基本的矩阵matrix创建方法，忘记了可以回头看看。本章利用scipy.sparse模块下的类提供创建稀疏矩阵的方法，例如bsr_matrix稀疏矩阵类。什么是稀疏矩阵？按数据结构领域知名学者严老师的定义稀疏矩阵是一个矩阵里有小于5%非0数据的矩...
C语言数据结构两个稀疏矩阵相加
04-30
C语言数据结构之两个稀疏矩阵相加。代码中代码功能描述、输入输出说明和测试输出输入。
数据结构实践——稀疏矩阵相加
weixin_34281477的博客
10-07 1779
本文针对数据结构基础系列网络课程(5)：数组与广义表的实践项目。 【项目 - 稀疏矩阵相加】 　　采用三元组存储稀疏矩阵，设计两个稀疏矩阵相加的运算算法 提示1：两个行数、列数相同的矩阵可以相加 提示2：充分利用已经建立好的算法库解决问题 [参考解答1]（程序中使用的头文件”tup.h”见稀疏矩阵的三元组表示算法库）　 ...
数据结构——稀疏矩阵相加
yulingzheng的博客
11-06 6880
数据结构——稀疏矩阵三元组形式相加 一.稀疏矩阵的在C语言上的定义描述 typedef struct { int i,j;//该非零元的行列下标 ElemType e; }Triple; typedef struct { Triple data[MAXSIZE+1];//非零元三元组表，data[0]未用 int mu,nu,tu; //矩阵的行数，列数和非零元个...
稀疏矩阵的运算——矩阵相加
热门推荐
qq_45767547的博客
04-13 1万+
南昌航空大学实验报告 课程名称： 数据结构A 实验名称： 实验五 稀疏矩阵运算 班 级： XXX 学生姓名： XXX 学号： XXXXX 指导教师评定： XXX 签 名: XXX 一、实验目的 数组是一种常用的数据类型，本实验是有关两个稀疏矩阵进行相加的应用。 通过对本实验的学习，可以理解矩阵的相关操作方法。 二、实验内容 在本...
数据结构C语言之稀疏矩阵的加法
11-19
1、进行加法运算的两个矩阵由用户输入。并且用三元组顺序表表示。 2、程序首先判断两个矩阵是否能够相加。若能，在进行运算后在屏幕上现实结果，否则给出相应信息。
数据结构三元组实验报告_数据结构三元组表存储结构实现稀疏矩阵应用课程方案实验报告.doc...
weixin_36301639的博客
12-31 999
数据结构三元组表存储结构实现稀疏矩阵应用课程方案实验报告数 据 结 构 课 程 设 计设计题目：基于三元组表的存储结构实现稀疏矩阵的应用学生姓名：专业班级：指导教师：完成时间：课题名称基于三元组表的存储结构实现稀疏矩阵的基本操作院 系年级专业学 号姓 名成 绩课题设计目的与设计意义1、课题设计目的：(1)掌握稀疏矩阵三元组表的存储、创建、显示、转置。(2)利用三元组表实现矩阵的相加、减...
稀疏矩阵快速转置C语言算法
10-21
本文将详细介绍基于三元组表示法的稀疏矩阵快速转置算法，并提供具体的C语言实现。 #### 二、三元组表示与稀疏矩阵 ##### 2.1 三元组表示 三元组表示是一种高效的存储稀疏矩阵的方法，它只存储非零元素及其位置信息...
稀疏矩阵在区块链中的应用：提升区块链的效率与安全性
![稀疏矩阵在区块链中的应用：提升区块链的效率与安全性]...在实际应用中，稀疏矩阵经常出现，例如：图像处理、社交网络分析和金融建模等领域。稀疏矩
稀疏矩阵加法
03-04
设稀疏矩阵A和B均以三元组顺序表作为存储结构。试设计算法，计算A+B，并将运算结果存于三元组顺序表C中。
稀疏矩阵的相加
03-10
采用三元组表存储结构。已知稀疏矩阵M和矩阵N，求C=M+N。 输入有多行。分为两部分。 第一部为矩阵 M 的信息： 第一行为m1、n1、len1，表示矩阵 M 的行数、列数和非零元素的个数。 接着下来有len1行数据：每一行为矩阵元素 M 所在的行、列、值。 第二部分为矩阵 N 的信息： 第一行为m2、n2、len2，表示矩阵 N 的行数、列数和非零元素的个数。 接着下来有len2行数据：每一行为矩阵元素 N 所在的行、列、值。 说明： （1）行数、列数和非零元素的个数均大于零；非零元素的个数小于等于 行数*列数。 （2）行、列均从1开始； （3）先按行序，再按列序输入每个非零元素所在的行 列 值。 输出len行（为C的非零元素个数）。 每一行为矩阵元素C所在的行、列、值。（输出时行、列、值之间有一空格） 输入矩阵M时，在下述情况： （1）行数、列数小于等于零，或非零元素的个数小于等于0，或非零元素的个数超过矩阵的 行数*列数； （2）不按次序或行、列超出范围。 均显示 “error,please input!” 提醒重新输入。 如果矩阵 M 和 N 不满足矩阵相加的条件，则输出 “error!”。 如果相加以后矩阵C全部为“零元素”，则输出“Matrix Empty!”。
稀疏矩阵相加、相乘和转置（用三元组实现）
06-28
稀疏矩阵相加、相乘和转置（用三元组实现）
实现稀疏矩阵的相加运算
03-21
实现了稀疏矩阵A+B相加 数据结构中的采用结构体数组进行稀疏矩阵的存储
稀疏矩阵的相加（三元组）
qq_61163319的博客
10-26 1657
中，若数值为0的元素数目远远多于非0元素的数目，并且非0元素分布没有规律时，则称该矩阵为稀疏矩阵。若使用一般二维数组进行存储，则会造成空间的浪费，故使用三元组保证内存完全利用。
第九周--三元组存储稀疏矩阵
sunsunzice的博客
10-27 1003
/ 作 者：孙子策 完成日期：2016.10.27 问题描述：提示1：两个行数、列数相同的矩阵可以相加 提示2：充分利用已经建立好的算法库解决问题 / 头文件： #ifndef TUP_H_INCLUDED #define TUP_H_INCLUDED #define M 6 #define N 7 #define MaxSize 100
第九周 项目3 两个稀疏矩阵的相加运算
wly16885885的博客
10-27 486
问题描述及代码： #ifndef TUP_H_INCLUDED #define TUP_H_INCLUDED /* *烟台大学计控学院 *作 者：杨征 *完成日期：2015年10月27日 *问题描述：提示1：两个行数、列数相同的矩阵可以相加 提示2：充分利用已经建立好的算法库解决问题 */ #endif // TUP_H_INCLUDED
matlab稀疏矩阵三元法,数据结构——稀疏矩阵三元组表示法+算法详解
最新发布
05-26
稀疏矩阵三元组表示法是将稀疏矩阵中每个非零元素的行、列和值存储在一个三元组中。其数据结构如下所示： ``` struct Triple{ int row, col; double value; }; ``` 其中，row表示非零元素所在的行，col表示非零...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值