数据结构 稀疏矩阵运算器

最新推荐文章于 2019-12-10 00:20:34 发布
最新推荐文章于 2019-12-10 00:20:34 发布
阅读量3.2k 收藏 14
点赞数 3
文章标签： 数据结构 struct c qt 图形 存储
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/skyqingchen/article/details/4845215
版权

问题描述：

有输入界面（图形或文字界面都可），能区分加法、减法、乘法和转置；能处理任意输入的典型数据和进行出错数据处理（例如乘法，当第一个矩阵的列数不等于第二个矩阵的行数时）；必须采用三元组作存储结构，不能采用数组等形式；输出要求用矩阵的形式输出（即习题集136页的形式），当第一个矩阵的行数不等于第二个矩阵的行数时，注意如第三个乘法的形式输出

 

******************************************************************************************

#include<stdio.h>
#define maxsize 100
typedef struct
{
 int i,j;                //该非零元的行和列
 int v;                  //该非零元的值
}triple;
typedef struct
{
 triple data[maxsize];         //非零元三元组表，data[0]未用
 int rpos[maxsize];
 int m,n,t;                    //矩阵的行数，列数和非零元个数
}tripletable;

void convert()                          //矩阵的转置

{
 int k;
 tripletable A,B;
 printf("输入稀疏矩阵A的行数，列数和非零元个数：");
 scanf("%d %d %d",&A.m,&A.n,&A.t);
 for(k=1;k<=A.t;k++)
 {
  printf("输入第%d个非0元素的行数，列数和值:",k);
  scanf("%d %d %d",&A.data[k].i,&A.data[k].j,&A.data[k].v);
 }
 B.m=A.m;B.n=A.n;B.t=A.t;
 if(B.t)
 {
  int q=1,col;
  for(col=1;col<=A.n;++col)
   for(int p=1;p<=A.t;++p)
    if(A.data[p].j==col)
    {
     B.data[q].i=A.data[p].j;
     B.data[q].j=A.data[p].i;
     B.data[q].v=A.data[p].v;
     ++q;
    }
 }
 int shuru[100][100]={0};
 for(k=1;k<=B.t;k++)
 {
  shuru[B.data[k].j][B.data[k].i]=B.data[k].v;
 }
 printf("输入为：/n");
 for(k=1;k<=B.m;k++)
 {
  for(int l=1;l<=B.n;l++)
   printf("%d ",shuru[k][l]);
  printf("/n");
 }
 int result[100][100]={0};

 for(k=1;k<=B.t;k++)
 {
  result[B.data[k].i][B.data[k].j]=B.data[k].v;
 }
 printf("结果为：/n");
 for(k=1;k<=B.n;k++)
 {
  for(int l=1;l<=B.m;l++)
   printf("%d ",result[k][l]);
  printf("/n");
 }
}

void add()                 //矩阵的加法
{
 int k;
 tripletable A,B;
 printf("输入稀疏矩阵A的行数，列数和非零元个数：");
 scanf("%d %d %d",&A.m,&A.n,&A.t);
 for(k=1;k<=A.t;k++)
 {
  printf("输入第%d个非0元素的行数，列数和值:",k);
  scanf("%d %d %d",&A.data[k].i,&A.data[k].j,&A.data[k].v);
 }
 printf("输入稀疏矩阵B的行数，列数和非零元个数：");
 scanf("%d %d %d",&B.m,&B.n,&B.t);
 for(k=1;k<=B.t;k++)
 {
  printf("输入第%d个非0元素的行数，列数和值:",k);
  scanf("%d %d %d",&B.data[k].i,&B.data[k].j,&B.data[k].v);
 }
 if(A.m!=B.m||A.n!=B.n)
 {
  printf("输入错误：A与B的行数或列数不相同，请重新输入/n");
  return;
 }
 int a[100][100]={0};
 for(k=1;k<=A.t;k++)
 {
  a[A.data[k].i][A.data[k].j]=A.data[k].v;
 }
 printf("A输入为：/n");
 for(k=1;k<=A.m;k++)
 {
  for(int l=1;l<=A.n;l++)
   printf("%d ",a[k][l]);
  printf("/n");
 }

 int b[100][100]={0};
 for(k=1;k<=B.t;k++)
 {
  b[B.data[k].i][B.data[k].j]=B.data[k].v;
 }
 printf("B输入为：/n");
 for(k=1;k<=B.m;k++)
 {
  for(int l=1;l<=B.n;l++)
   printf("%d ",b[k][l]);
  printf("/n");
 }
 int c[100][100]={0};
 for(k=1;k<=A.m;k++)
 {
  for(int l=1;l<=A.n;l++)
  {
   c[k][l]=a[k][l]+b[k][l];
  }
 }
 printf("加法结果C为：/n");
 for(k=1;k<=A.m;k++)
 {
  for(int l=1;l<=A.n;l++)
   printf("%d ",c[k][l]);
  printf("/n");
 }
}

void jian()                     //矩阵的减法
{
 int k;
 tripletable A,B;
 printf("输入稀疏矩阵A的行数，列数和非零元个数：");
 scanf("%d %d %d",&A.m,&A.n,&A.t);
 for(k=1;k<=A.t;k++)
 {
  printf("输入第%d个非0元素的行数，列数和值:",k);
  scanf("%d %d %d",&A.data[k].i,&A.data[k].j,&A.data[k].v);
 }
 printf("输入稀疏矩阵B的行数，列数和非零元个数：");
 scanf("%d %d %d",&B.m,&B.n,&B.t);
 for(k=1;k<=B.t;k++)
 {
  printf("输入第%d个非0元素的行数，列数和值:",k);
  scanf("%d %d %d",&B.data[k].i,&B.data[k].j,&B.data[k].v);
 }
 if(A.m!=B.m||A.n!=B.n)
 {
  printf("输入错误：A与B的行数或列数不相同，请重新输入/n");
  return;
 }
 int a[100][100]={0};
 for(k=1;k<=A.t;k++)
 {
  a[A.data[k].i][A.data[k].j]=A.data[k].v;
 }
 printf("A输入为：/n");
 for(k=1;k<=B.m;k++)
 {
  for(int l=1;l<=A.n;l++)
   printf("%d ",a[k][l]);
  printf("/n");
 }

 int b[100][100]={0};
 for(k=1;k<=B.t;k++)
 {
  b[B.data[k].i][B.data[k].j]=B.data[k].v;
 }
 printf("B输入为：/n");
 for(k=1;k<=B.m;k++)
 {
  for(int l=1;l<=B.n;l++)
   printf("%d ",b[k][l]);
  printf("/n");
 }
 int c[100][100]={0};
 for(k=1;k<=A.m;k++)
 {
  for(int l=1;l<=A.n;l++)
  {
   c[k][l]=a[k][l]-b[k][l];
  }
 }
 printf("减法结果C为：/n");
 for(k=1;k<=A.m;k++)
 {
  for(int l=1;l<=A.n;l++)
   printf("%d ",c[k][l]);
  printf("/n");
 }
}

void multi()                             //矩阵的乘法
{
 int k;
 tripletable A,B,C;
 printf("输入稀疏矩阵A的行数，列数和非零元个数：");
 scanf("%d %d %d",&A.m,&A.n,&A.t);
 for(k=1;k<=A.t;k++)
 {
  printf("输入第%d个非0元素的行数，列数和值:",k);
  scanf("%d %d %d",&A.data[k].i,&A.data[k].j,&A.data[k].v);
 }
 int row=1;
 for(k=1;k<=A.t;k++)
 {
  while(row<=A.data[k].i)
  {
   A.rpos[row++]=k;
  }
 }
 while(row<=A.m)A.rpos[row++]=A.t+1;
 printf("输入稀疏矩阵B的行数，列数和非零元个数：");
 scanf("%d %d %d",&B.m,&B.n,&B.t);
 for(k=1;k<=B.t;k++)
 {

  printf("输入第%d个非0元素的行数，列数和值:",k);
  scanf("%d %d %d",&B.data[k].i,&B.data[k].j,&B.data[k].v);
 }
 row=1;
 for(k=1;k<=B.t;k++)
 {
  while(row<=B.data[k].i)
  {
   B.rpos[row++]=k;
  }
 }
 while(row<=B.m)B.rpos[row++]=B.t+1;
 if(A.n!=B.m)
 {
  printf("输入错误：A的列数不等于B的行数，请重新输入/n");
  return;
 }

 C.m=A.m;C.n=B.n;C.t=0;
 int arow,p,q,ccol,t,tp;
 if(A.t*B.t!=0)
 {
  for(arow=1;arow<=A.m;++arow)
  {
   int ctemp[maxsize]={0};
   C.rpos[arow]=C.t+1;
   if(arow<A.m){tp=A.rpos[arow+1];}
   else{tp=A.t+1;}
   for(p=A.rpos[arow];p<tp;++p)
   {
    int brow=A.data[p].j;
    if(brow<B.m){t=B.rpos[brow+1];}
    else{t=B.t+1;}
    for(q=B.rpos[brow];q<t;++q)
    {
     ccol=B.data[q].j;
     ctemp[ccol]+=A.data[p].v*B.data[q].v;

    }

   }
   for(ccol=1;ccol<=C.n;++ccol)
   {
    if(ctemp[ccol])
    {
     if(++C.t>maxsize)return;
     C.data[C.t].i=arow;
     C.data[C.t].j=ccol;
     C.data[C.t].v=ctemp[ccol];
    }
   }

  }   

 }

 int a[100][100]={0};
 for(k=1;k<=A.t;k++)
 {
  a[A.data[k].i][A.data[k].j]=A.data[k].v;
 }
 printf("A输入为：/n");
 for(k=1;k<=A.m;k++)
 {
  for(int l=1;l<=A.n;l++)
   printf("%d ",a[k][l]);
  printf("/n");
 }

 int b[100][100]={0};
 for(k=1;k<=B.t;k++)
 {
  b[B.data[k].i][B.data[k].j]=B.data[k].v;
 }
 printf("B输入为：/n");
 for(k=1;k<=B.m;k++)
 {
  for(int l=1;l<=B.n;l++)
   printf("%d ",b[k][l]);
  printf("/n");
 }
 int c[100][100]={0};
 for(k=1;k<=C.t;k++)
 {
  c[C.data[k].i][C.data[k].j]=C.data[k].v;
 }
 printf("乘法结果C为：/n");
 for(k=1;k<=C.m;k++)
 {
  for(int l=1;l<=C.n;l++)
   printf("%d ",c[k][l]);
  printf("/n");
 }

}

void main()
{
 printf("=============   菜       单 ==============/n");
 printf("                            1 矩阵转置/n");
 printf("                            2 矩阵加法/n");
 printf("                            3 矩阵减法/n");
 printf("                            4 矩阵乘法/n");
 printf("======================================/n/n");
loop: printf("请选择相应操作的序号:");
 int y;
 scanf("%d",&y);
 switch(y)
 {
 case 1: convert();
  printf("/n");
  goto loop;
 case 2: add();
  printf("/n");
  goto loop;
 case 3: jian();
  printf("/n");
  goto loop;
 case 4: multi();
  printf("/n");
  goto loop;
 }
}

****************************************************************************************

skyqingchen
关注
c语言稀疏矩阵运算器,数据结构：稀疏矩阵运算器
weixin_35574537的博客
05-19 3175
题目：设计一个程序，实现一个能进行稀疏矩阵基本运算的计算器。按照教科书《数据结构(C语言版)》(严蔚敏等)5.3.2节中描述的方法，以十字链表表示稀疏矩阵。一、需求分析稀疏矩阵是指那些多数元素为零的矩阵。利用“稀疏”特点进修学校储存和计算可以大大节省储存空间，提高计算效率。实现一个能进行稀疏矩阵基本运算的计算器。以“带行逻辑链接信息”的三元组顺序表表示稀疏矩阵，实现两个矩阵相加、相减和相乘的运算。...
【数据结构】稀疏矩阵运算器（加、减、乘）
man_zuo的博客
11-21 7331
问题描述 稀疏矩阵是指那些多数元素为零的矩阵，利用“稀疏”特点进行存储和计算可以大大节省存储空间，提高计算效率。实现一个能进行稀疏矩阵基本运算的运算器 基本要求 以“带行逻辑连接信息”的三元组顺序表表示系数矩阵，实现两个矩阵相加、相减和想乘的运算。稀疏矩阵的输入形式采用三元组表示，而运算结果的矩阵以通常阵列形式列出 运行截图 数据输入 输出结果 代码实现 import java.util.Ar...
稀疏矩阵运算器（数据结构）
01-14
输入要求：稀疏矩阵的行、列和非零元素个数 以及每个非零元素在矩阵的位置 以三元组格式存储稀疏矩阵 输出要求：根据选项输出 稀疏矩阵的转置、加法、减法、乘法
数据结构-稀疏矩阵计算器
06-13
数据结构实验。实现了对稀疏矩阵的加减乘运算，并制作了MFC界面。采用十字链表作为数据结构。 这个忘记上传.net2005的解决方案文件了。。。已经下载过得同学抱歉了。还是麻烦新建一个.net2005的项目。
数据结构——稀疏矩阵运算器（C语言）
一个巨大的博客
10-30 6250
数据结构——稀疏矩阵运算器（C语言） /*****************稀疏矩阵运算器 ****************/ #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define OK 1 #define TRUE 1 #define ERROR 0 #define FALSE 0 #define MAX_SIZE 100 ...
数据结构稀疏矩阵运算器课程设计.doc
04-23
在设计稀疏矩阵运算器时，我们需要考虑到稀疏矩阵的特殊性质，使用合适的数据结构和算法来实现稀疏矩阵的运算。我们使用三元组顺序表来存储稀疏矩阵的元素，其中每个元素由行号、列号和元素值组成。这样可以快速地...
数据结构稀疏矩阵运算器
11-24
本项目“数据结构稀疏矩阵运算器”是基于十字链表实现的，它是一个用于操作稀疏矩阵的工具，同时也作为作者的课程设计成果。 稀疏矩阵是二维矩阵的高效表示，主要针对那些大部分元素为零的矩阵。在传统的一维数组...
稀疏矩阵运算器（C语言实现，代码完整，可读性很好）
06-27
问题描述： 稀疏矩阵是指那些多数元素为零的矩阵。利用“稀疏”特点进行存储和计算 可以大大节省...我写的这个稀疏矩阵运算器代码非常完整，功能也都能正确实现，绝对不会让你们失望的，有需要的朋友们赶紧下载吧！
稀疏矩阵运算器 数据结构
04-18
数据结构（C语言版）实习4.1，稀疏矩阵运算器
稀疏矩阵计算器
04-29
采用三元组形式实现稀疏矩阵的存储，加法、乘法求逆的运算
C语言实现的稀疏矩阵运算器
04-30
C语言实现的稀疏矩阵运算器，通过用数据结构来实现（一部分），主要是矩阵的实现
稀疏矩阵计算器及其报告
12-18
以“带行逻辑链接信息”的三元组顺序表示稀疏矩阵，实现两个矩阵的相加相减和相乘的运算。
（数据结构课程设计）稀疏矩阵运算器
青春
05-24 7450
1．设计内容  稀疏矩阵是指那些多数元素为零的矩阵。利用“稀疏”特点进行存储和计算可以大大节省存储空间，提高计算准备效率。实现一个能进行稀疏矩阵基本运算的运算器。    具体功能有：（1）以“带行逻辑链接信息”的三元组顺序表示稀疏矩阵，实现两个稀疏矩阵相加、相减、相乘和求逆的运算。（2）稀疏矩阵的输入形式采用三元组表示，而运算结果的矩阵则以通常的阵列形式列出。2. 本设计所采用的数据结构稀疏矩阵采
稀疏矩阵运算器
fengzhongzhui_feng的博客
07-19 882
// 稀疏矩阵计算器.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #define MAXSIZE 12500 #define OK 1 typedef int ElemType; typedef int Status; typedef struct{ int i,j; ElemType e; }Triple; typedef
数据结构｜稀疏矩阵运算器
匿名用户小易
12-10 3548
稀疏矩阵运算器 一、需求分析 1、稀疏矩阵是指那些多数元素为零的矩阵。利用“稀疏”特点进行存储和计算可以大大节省存储空间，提高计算效率。实现一个能进行稀疏矩阵基本运算的运算器。 2、以“带行逻辑链接信息’的三元组顺序表示稀疏矩阵，实现两个矩阵相加，相减和相乘的运算，稀疏矩阵的输入形式采用三元组表示，而运算结果的矩阵则以通常的阵列形式列出。 3、首先应输入矩阵的行数和列数，并判别给出的两个矩阵的行，...
数据结构稀疏矩阵运算器思路
最新发布
06-10
在处理大规模的数据结构，特别是稀疏矩阵（在其中大部分元素为零）时，稀疏矩阵运算器的设计主要关注效率和内存管理。稀疏矩阵通常采用压缩存储格式，如CSR（Compressed Sparse Row）、CSC（Compressed Sparse ...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值