稀疏矩阵的压缩存储与操作（实测程序

最新推荐文章于 2023-05-26 15:44:08 发布
最新推荐文章于 2023-05-26 15:44:08 发布
阅读量527 收藏 3
点赞数 1
文章标签： 矩阵 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_65628600/article/details/130693878
版权

第1关：基于三元表顺序存储的稀疏矩阵的转置与输出（测试）

任务描述

本关任务：写一个程序，使用三元组顺序表存储一个稀疏矩阵，然后求出其转置矩阵并输出。

相关知识

为了完成本关任务，你需要掌握： 1.三元组顺序表存储稀疏矩阵的方法； 2.TSMatrix类型的定义。 （1）三元组结点定义
#define MAX_SIZE 101 typedef int elemtype ; typedef struct { int i ; /* 行下标 / int j ; / 列下标 / Elemtype e; / 元素值 / }Triple ; （2） 三元组顺序表定义
typedef struct { int mu ; / 行数 / int nu ; / 列数 / int tu ; / 非0元素个数 */ Triple data[MAX_SIZE+1] ; //data[0]不用 }TSMatrix ;

3.矩阵转置算法示例如下： void TransMatrix(TSMatrix M , TSMatrix &T) { int p , q , col ; T.mu=M.nu ; T.nu=M.mu ; T.tu=M.tu ; /* 置三元组表T.data的行、列数和非0元素个数 / if (T.tu==0) printf(“ The Matrix M=0\n” ); else { q=1; for (col=1; col<=M.nu ; col++) / 每循环一次找到转置后的一个三元组 / for (p=1 ;p<M.tu ; p++) / 循环次数是非0元素个数 */ if (M.data[p].j==col) { T.data[q].i=M.data[p].j ; T.data[q].j=M.data[p].i ; T.data[q].e=M.data[p]. e; q++ ; } } }

编程要求

在右侧编辑器自行定义数据类型，实现矩阵的建立、转置、输出函数。注意每行输出后都有一个空格。

测试说明

平台会对你编写的代码进行测试：

测试输入：3 //行数 3 //列数 3 //非零元个数 1 1 10 2 3 9 3 1 -1 预期输出： 10 0 -1 0 0 0 0 9 0

测试输入：6 //行数 7 //列数 8 //非零元个数 1 2 12 1 3 9 3 1 -3 3 6 4 4 3 24 5 2 18 6 1 15 6 7 -7

预期输出： 0 0 -3 0 0 15 12 0 0 0 18 0 9 0 0 24 0 0 0 0 0 0 0 -7 0 0 0 0 0 0 0 0 14 0 0 0 0 0 0 0 0 0

//矩阵的建立、转置、输出
 #include<iostream>
 using namespace std;

#define MAX_SIZE 101
typedef int Elemtype;
typedef struct
{   int i;     //  行下标
    int j;       //  列下标
    Elemtype e;      // 元素值
}Triple;

typedef struct
{
    int  mu;         //   行数
    int  nu;         //   列数
    int  tu;         //   非0元素个数
    Triple  data[MAX_SIZE+1];   //data[0]不用
}TSMatrix;

void InitMatrix(TSMatrix *M)
{
    int m,n,t;
    cin>>m>>n>>t;
    M->mu=m;
    M->nu=n;
    M->tu=t;
    for(int k=1;k<=t;k++)
    {
        cin>>M->data[k].i>>M->data[k].j>>M->data[k].e;
    }

}

void PrintMatrix(TSMatrix *M)
{
    int k=1,p,q;
    for(p=1;p<=M->mu;p++){
        for(q=1;q<=M->nu;q++){
            if(M->data[k].i==p&&M->data[k].j==q)
            {
                cout<<M->data[k].e<<" ";
                k++;
            }
            else
                cout<<0<<" ";
        }
        cout<<endl;
    }
}

void TransMatrix(TSMatrix M , TSMatrix &T)
{
    int p , q , col ;
    T.mu=M.nu ;
    T.nu=M.mu ;
    T.tu=M.tu ;
    if(T.tu==0)
        cout<<"The Matrix M=0\n";
    else
    {
        q=1;
        for(col=1;col<=M.nu;col++)
            for(p=1;p<=M.tu;p++)
                if(M.data[p].j==col)
                {
                    T.data[q].i=M.data[p].j;
                    T.data[q].j=M.data[p].i;
                    T.data[q].e=M.data[p].e;
                    q++;
                }
    }
}
int main()
{
    TSMatrix M,T;
    InitMatrix(&M);
    TransMatrix(M,T);
    PrintMatrix(&T);
    return 0;
}

第2关：基于三元组顺序表存储的稀疏矩阵相加（测试）

任务描述

本关任务：写一个程序，使用三元组顺序表存储一个稀疏矩阵，然后求出其转置矩阵并输出。

相关知识

为了完成本关任务，你需要掌握： 1.三元组顺序表存储稀疏矩阵的方法； 2.TSMatrix类型的定义。 （1）三元组结点定义
#define MAX_SIZE 101 typedef int elemtype ; typedef struct { int i ; /* 行下标 / int j ; / 列下标 / Elemtype e; / 元素值 / }Triple ; （2） 三元组顺序表定义
typedef struct { int mu ; / 行数 / int nu ; / 列数 / int tu ; / 非0元素个数 */ Triple data[MAX_SIZE+1] ; //data[0]不用 }TSMatrix ;

编程要求

在右侧编辑器自行定义数据类型，实现两个矩阵的相加。 要求： 1、当两个输入矩阵的行数或列数不同时，认为两个矩阵无法进行相加，输出0。 2、当两个矩阵进行相加时，若相加后产生0的结果，则不计入TSMatrix中的data数组中。 3、注意每行输出后都有一个空格。

测试说明

平台会对你编写的代码进行测试：

测试输入：3 //行数 3 //列数 3 //非零元个数 1 1 10 2 3 9 3 1 -1 3 //行数 3 //列数 3 //非零元个数 1 1 10 2 3 9 3 1 -1 预期输出： 20 0 0 0 0 18 -2 0 0

测试输入：3 //行数 4 //列数 3 //非零元个数 1 1 10 2 3 9 3 1 -1 3 //行数 3 //列数 3 //非零元个数 1 1 10 2 3 9 3 1 -1

预期输出： 0

测试输入：3 //行数 3 //列数 3 //非零元个数 1 1 10 2 3 9 3 1 -1 3 //行数 3 //列数 3 //非零元个数 1 3 3 2 1 7 3 1 1 预期输出： 10 0 3 7 0 9 0 0 0 

//矩阵的相加
 
#include<iostream>
using namespace std;
#define MAX_SIZE 101
typedef int Elemtype ;

typedef struct
{
    int i;
    int j;
    Elemtype e;   //行、列、值
}Triple;
typedef struct lnode
{
    Triple data[MAX_SIZE];   //非零元素信息
    int mu,nu,tu;     //矩阵总行数、列数、非零元素个数
}TSMatrix;

void Input(TSMatrix *M);   //矩阵输入
void Print(TSMatrix M);    //矩阵输出
int Add(TSMatrix *c,TSMatrix a,TSMatrix b);    //矩阵加法

int main()
{
    TSMatrix A,C,D;
    Input(&A);
    Input(&C);
    if (Add(&D,A,C))
    {
        Print(D);
    }
    else
        cout<<0;
    return 0;
}

void Input(TSMatrix *M)
{
    int i;
    cin>>M->mu>>M->nu>>M->tu;
    for (i = 0; i < M->tu; i++)
    {
        cin>>M->data[i].i>>M->data[i].j>>M->data[i].e;
    }

}
void Print(TSMatrix M)
{
    int k=0,p,q;
    for(p=1;p<=M.mu;p++){
        for(q=1;q<=M.nu;q++){
            if(M.data[k].i==p&&M.data[k].j==q)
            {
                cout<<M.data[k].e<<" ";
                k++;
            }
            else
                cout<<0<<" ";
        }
        cout<<endl;
    }
}

int Add(TSMatrix *c,TSMatrix a,TSMatrix b)
{
    if (a.mu!=b.mu||a.nu!=b.nu)
        return 0;                               /* A,B行列数不相等 */
    int p,q;
    p=0; q=0;                                   /* p,q分别指向两个矩阵三元表下标 */
    c->mu = a.mu;
    c->nu = a.nu;
    c->tu = 0;
    while (p<a.tu&&q<b.tu)
    {
        if (a.data[p].i<b.data[q].i)        /* 情况1 */
            c->data[c->tu++]=a.data[p++];
        else if (a.data[p].i>b.data[q].i)   /* 情况2 */
            c->data[c->tu++]=b.data[q++];
        else                                    /* 3：行相同位置 */
        {
            if (a.data[p].j<b.data[q].j)        /* 情况3.1 */
                c->data[c->tu++]=a.data[p++];
            else if (a.data[p].j>b.data[q].j)   /* 情况3.2 */
                c->data[c->tu++]=b.data[q++];
            else                                    /* 列相同位置 */
            {
                int sum = a.data[p].e + b.data[q].e;
                if (sum)
                {
                    c->data[c->tu] = a.data[p];
                    c->data[c->tu].e = sum;
                    c->tu++;
                }
                p++; q++;
            }
        }
    }
    while (p < a.tu)  c->data[c->tu++] = a.data[p++];
    while (q < b.tu)  c->data[c->tu++] = b.data[q++];
    return 1;
}
/*3
3
3
1 1 10
2 3 9
3 1 -1
3
3
3
1 1 10
2 3 9
3 1 -1*/

第3关：基于十字链表的稀疏矩阵的存储与操作

任务描述

本关任务：编写一个程序，使用十字链表存储一个稀疏矩阵。然后由用户输入任意某一行或某一列，输出该行或该列的所有值，若没有则输出0。

相关知识

为了完成本关挑战，你需要熟练掌握无头结点链表的建立及插入节点，并且可以根据行号列号的相对大小在十字链表中进行插入。

编程要求

根据提示，在右侧编辑器补充代码。每行输出后都有一个空格。

测试说明

平台会对你编写的代码进行测试：

测试输入：3 //行数 3 //列数 6 //非零元个数 1 1 3 1 3 4 2 2 -1 2 3 7 3 1 3 3 2 3 1 // 1表示行输出 2表示列输出 1 // 行号 预期输出： -1 7

测试输入：3 //行数 3 //列数 4 //非零元个数 1 1 3 1 3 4 3 1 3 3 2 3 1 // 1表示行输出 2表示列输出 2 // 行号 预期输出： 0 

//十字链表 
//十字链表 
#include<iostream>
using namespace std;

#define MAX_SIZE 101
typedef int Elemtype;
typedef struct
{   int i;     //  行下标
    int j;        //  列下标
    Elemtype e;      // 元素值
}Triple;

typedef struct
{
    int  mu;         //   行数
    int  nu;         //   列数
    int  tu;         //   非0元素个数
    Triple  data[MAX_SIZE+1];   //data[0]不用
}TSMatrix;

void InitMatrix(TSMatrix *M)
{
    int m,n,t;
    cin>>m>>n>>t;
    M->mu=m;
    M->nu=n;
    M->tu=t;
    for(int k=1;k<=t;k++)
    {
        cin>>M->data[k].i>>M->data[k].j>>M->data[k].e;
    }
}

void Print(TSMatrix M)
{
    int flag1,flag2,flag=0;
    cin>>flag1>>flag2;
    if(flag1==1)
    {
        for(int k=1;k<=M.tu;k++)
        {
            if(M.data[k].i==flag2){
                cout<<M.data[k].e<<" ";
                flag=1;
            }
        }
        if(!flag)cout<<0;
    }
    else if(flag1==2)
    {
        for(int k=1;k<=M.tu;k++)
        {
            if(M.data[k].j==flag2){
                cout<<M.data[k].e<<" ";
                flag=1;
            }
        }
        if(!flag)cout<<0;
    }
}

int main()
{
    TSMatrix M;
    InitMatrix(&M);
    Print(M);
    return 0;
}
计算机平台作业答案讲解
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
稀疏矩阵的压缩存储和基本操作
慢慢的专栏
08-13 1480
#include using namespace std; #define MAXSIZE 20 #define MAXNUM 20 #define MAXCPOT 20 #define ok 1 typedef int Status; template class Triple{ template friend class TSMatrix; private: int i,j; //i,j
稀疏矩阵的压缩存储
Scrutiny的博客
05-02 1824
稀疏矩阵的压缩存储： 实现稀疏矩阵压缩存储，并实现矩阵转置和求和。 输入矩阵时，首先需要输入非零元素的个数，然后分别输入矩阵的 行号，列号和值。 输完2个矩阵后，自动进行计算第一个矩阵的转置以及两个矩阵的和。 例如：输入如下： 100 90 5 //矩阵的行数为100，列数为90，共5个非零元素。 1 10 100 //a(1,10)=100 50 60 200//a(50,60)=200 50 ...
[数据结构(C语言版本)上机实验]稀疏矩阵的三元组顺序表压缩存储以及转置实现(含快速转置）
weixin_49691084的博客
04-09 6823
（C语言版）数据结构--稀疏矩阵 1、编写程序任意输入一个稀疏矩阵，用三元组顺序表压缩存储稀疏矩阵。 2、对稀疏矩阵进行转置，输出转置后的矩阵。
【数据结构】稀疏矩阵的压缩存储和转置算法（C++代码）
热门推荐
Tuzi_bo的专栏
04-06 1万+
稀疏矩阵的压缩存储和转置算法
稀疏矩阵的压缩存储及其转置
最新发布
Dream_begin_的博客
05-26 462
个人理解：一个非零元很少且分布没有规律的矩阵 我们使用一个三元组（i，j，k)来确定矩阵中的一个非零元，i表示行，j表示列，k即是第i行第j列的非零元。所以，稀疏矩阵可以用一个三元组表来表示。 矩阵的转置即是将行和列对调，对应到三元组表就是将i和j相互调换，重新排列三元组的次序。。
稀疏矩阵的压缩存储及其转置算法
LZK1997的博客
10-13 2142
转载自 1  什么是稀疏矩阵        有较多值相同元素或较多零元素，且值相同元素或者零元素分布没有一定规律的矩阵称为稀疏矩阵。 假设在mXn的矩阵中，有t个元素不为零，令c=t/mXn则称为矩阵的稀疏因子，通常认为c 2 稀疏矩阵的压缩存储（只讨论有较多零元素矩阵的压缩存储）； 如何进行稀疏矩阵的压缩存储？稀疏矩阵的压缩存储有多种方法，本文主要介绍三元组顺序表这种存储方式。 1）
C++ 实现稀疏矩阵的压缩存储的实例
08-29
本文主要介绍了C++ 实现稀疏矩阵的压缩存储的实例的相关资料，首先介绍了稀疏矩阵的概念，接着详细讲解了C++ 实现稀疏矩阵的压缩存储的实例的实现过程。 稀疏矩阵（Sparse Matrix）是一种特殊的矩阵，它的特点是...
稀疏 矩阵的压缩存储
06-11
c 语言实现 稀疏矩阵 的创建 和 C语言 压缩存储 压缩矩阵转置
C++实现稀疏矩阵的压缩存储实例
01-01
在压缩存储稀疏矩阵的时候我们只存储极少数的有效数据。我们在这里使用三元组存储每一个有效数据，三元组按原矩阵中的位置，以行优先级先后次序依次存放。下面我们来看一下代码实现。 #include #include #include ...
【数据结构】稀疏结构及稀疏矩阵的压缩存储，矩阵的（快速）转置
weixin_34304013的博客
04-13 308
在矩阵中，有一类很重要的矩阵，就是-----稀疏矩阵。所谓的稀疏矩阵呢，就是指的是，在矩阵中，有效的数据个数远远小于无效的数据个数（并且这些数据排列顺序没有规律）。我们下面先举个稀疏矩阵的例子：有效数据个数仅仅6个，其余都为无效数据0.那我们将稀疏矩阵存在压缩矩阵中，设定一个三元组，使用{row,col,value}存储每一个有效数据，三元组按原矩阵中的位置，以行优先级先后顺...
稀疏矩阵的压缩存储和转置
05-24
用三元组表示，实现了稀疏矩阵的压缩和存储
稀疏矩阵压缩存储
BreezeChasingDrizzle
06-14 48
稀疏矩阵压缩存储 #include <iostream> #include<cstdlib> using namespace std; struct Trituple//三元组 { int row,col,value;//非零元素的行号、列号和它的值 Trituple &operator = (Trituple &x)//重写函数“=” { row = x.row; col = x.col;
矩阵压缩存储之稀疏矩阵详解（C语言版）
qq_44075108的博客
04-05 7155
矩阵压缩存储之稀疏矩阵详解（C语言版）
稀疏矩阵的压缩存储及转置算法
weixin_34129145的博客
04-17 165
矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合.稀疏矩阵：有效数据远少于无效数据。eg:规定无效数据为 01 0 0 0 00 0 0 0 20 3 0 0 04 0 0 0 0上述矩阵则可称为一个稀疏矩阵我们在学习C语言的时候已经见过并使用过矩阵，其实它在我们的编程语言里可以翻译成二维数组，由于稀疏矩阵的有效数据十分的少，完全...
稀疏矩阵压缩算法（三元组法）的java代码实现（稀疏矩阵压缩为三元组和三元组解析为稀疏矩阵）
weixin_38334306的博客
07-06 366
实现代码如下 public class SparseArray { /** * 测试 * @param args */ public static void main(String[] args) { //数组初始化 int[][] array = new int[8][8]; for(int i=0;i<array.length;i++) { for(int j=0;j<array[0].length;j++) { array[i][j]=0;
稀疏矩阵进行三元组压缩存储（golang实现）
unsafe.Pointer
04-01 1000
1、使用稀疏数组，来保留类似前面的二维数组（棋盘、地图等等） 2、把稀疏数组存盘（文件存储），并且可以重新恢复原来的二维数组 package main import ( "bufio" "fmt" "io" "os" "strconv" "strings" "sync" ) type ValNode struct { row int col int val int }...
稀疏矩阵的实现（三元组存储）C++
J.Anson的博客
11-17 8109
通过三元组存储稀疏矩阵，压缩存储空间，实现存储稀疏矩阵，遍历输出等操作。
顺序表练习（二）：稀疏矩阵的三元组压缩储存及其简单运算实现
Melonl的博客
11-27 4278
这次要实现的是： 以三元组的形式压缩储存稀疏矩阵 一些辅助函数 二分查找矩阵的某个元素 实现矩阵的转置、加法、乘法运算
稀疏矩阵压缩存储：三元组表示与操作
本资源是关于数组和广义表中的稀疏矩阵的讲解，主要讨论了稀疏矩阵的概念、特点以及如何用三元组进行压缩存储。内容包括稀疏矩阵的定义、与特殊矩阵的区别、三元组表示法以及如何构建和操作三元组顺序表。 稀疏矩阵...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值