精华内容
下载资源
问答
  • 稀疏矩阵求和

    2007-12-08 23:13:30
    稀疏矩阵的加减乘除等
  • 矩阵求和 [问题描述] 实现两个稀疏矩阵求和操作。 [基本要求] (1)矩阵可键盘输入,也可事先给定; (2)输出求和结果; (3)利用三元组数据结构。
  • } 2、 题目:稀疏矩阵的快速转置B=A’ 算法思想: 按照A. data中三元组的次序进行转置,并将转置后的三元组置人B中恰当的位置。如果能预先确定矩阵B中每-列(即A中每一行)的第一 个非零元在B. data中应有的位置,...

    一、调试成功程序及说明
    1、碰撞的小球
    题目:
    1、 数轴上有一条长度为L(L为偶数)的线段,左端点在原点,右端点在坐标L处。有n个不计体积的小球在线段上,开始时所有的小球都处在偶数坐标上,速度方向向右,速度大小为1单位长度每秒;
    2、 当小球到达线段的端点(左端点或右端点)的时候,会立即向相反的方向移动,速度大小仍然为原来大小;
    3、 当两个小球撞到一起的时候,两个小球会分别向与自己原来移动的方向相反的方向,以原来的速度大小继续移动。
    4、 现在,告诉你线段的长度L,小球数量n,以及n个小球的初始位置,请你计算t秒之后,各个小球的位置。

    算法思想:
    对于本体,由于涉及到多次的比较,判断,所有我使用的数据结构为顺序表,顺序表在访问第i个元素上面比链表的时间复杂度要低。我用一个顺序表来存储他们的位置,用另一个顺序表来存储他们的速度,再用一个顺序表来进行排序。这样我们就在判断速度方向是否改变的时候,只需要判断自己和左边(或者右边,只用选一边进行判断)的位置进行判断,当然端点要额外判断。这样时间复杂度为O(n2+nt),其中n2来自于对数据的排序(对于选择排序和冒泡排序时间复杂度一样),nt来自与判断位置是否重合(相遇)由于我们开了三个大小为的顺序表,所以我们的空间复杂度为:O(n)。
    运行结果:
    在这里插入图片描述
    在这里插入图片描述

    结果分析:
    从结果上来看,答案是正确的,而且有输入的提示信息,方便使用者输入相应的数值。
    附源代码:

    #include "stdlib.h"
    #include "math.h"
    #include "stdio.h"
    #define N 100
    
    main()
    {
    	int x[N],v[N],pos[N];      //存储小球的位置信息和速度信息 
    	int i,j,temp;              //辅助变量,i:用来进行对小球的位置信息和速度信息的初始化,,,,j,k:后面运动过程中进行改变球的位置信息和速度信息
    	int n,L,t;                 //小球的个数n,线段的长度L,以及你需要计算t秒之后小球的位置
    	printf("请输入小球的个数n,线段的长度L,以及你需要计算t秒之后小球的位置: ");  //提示输入信息 
    	scanf("%d %d %d",&n,&L,&t);
    	while(L%2)          //判断线段的长度L是否是偶数
    	{
    		printf("线段的长度L输入错误,L必须是偶数!\n");
    		printf("请输入线段的长度L: ");
    		scanf("%d",&L);
    	}
    	for(i = 1;i<=n;i++)      //初始化小球的位置信息和速度信息 
    	{
    		printf("请输入第%d个小球的初始坐标: ",i);
    		scanf("%d",&x[i]); 
    		v[i] = 1;   //初始速度全为1 
    		while(x[i]%2)          //判断第i+1个小球的初始坐标是否是偶数
    		{
    			printf("第%d个小球的初始坐标输入错误,L必须是偶数!\n",i);
    			printf("请输入第%d个小球的初始坐标: ",i);
    			scanf("%d",&x[i]);
    		}
    		pos[i] = i;
    	}
    	x[0] = 0;x[n+1] = L;v[0] = 0;v[n+1] = 0;pos[0] = 0;pos[n+1] = n+1;
    	for(i = 1;i<=n;i++)
    	{
    		for(j = i+1;j<=n;j++)
    		{
    			if(x[pos[i]] > x[pos[j]])
    			{
    				temp = pos[i];
    				pos[i] = pos[j];
    				pos[j]= temp;
    			}
    		}
    	}
    	for(j=1;j<=t;j++)//遍历运功过程每秒时间
    	{
    		for(i = 1;i<=n;i++)
    			x[i] = x[i]+v[i]; 
    		for(i = 1;i<=n;i++)//遍历每个小球,判断小球是否运动反向 
    		{
    			if(x[pos[i]] == x[pos[i-1]])
    			{
    				v[pos[i]] = -v[pos[i]];
    				v[pos[i-1]] = -v[pos[i-1]];
    			}
    			if(i == n)
    				if(x[pos[i]] == x[pos[i+1]])
    					v[pos[i]] = -v[pos[i]];
    		}
    	}
    	printf("%d秒后:\n",t);
    	for(i = 1;i<=n;i++)
    		printf("第%d个小球的位置为:%d\n",i,x[i]);
    }
    
    

    2、
    题目:稀疏矩阵的快速转置B=A’
    算法思想:
    按照A. data中三元组的次序进行转置,并将转置后的三元组置人B中恰当的位置。如果能预先确定矩阵B中每-列(即A中每一行)的第一 个非零元在B. data中应有的位置,那么在对A. data中的三元组依次作转置时,便可直接放到B. data中怡当的位置上去。为了确定这些位置.在转置前,应先求得A的每一列中非零元的个数,进而求得每一列的第一个非零元在B. data中应有的位置。在此,需要附设num和cpot两个向量。num[col]表示矩阵 A中第col列中非零元的个数,pot[co]指示A中第col列的第一个非零元在b. data中的恰当位置。显然有:
    cpot[1]=1;cpot[col]=cpot[col-1]+num[col-1]
    这里我们相当于空间换时间了,我们多用了俩个辅助向量,空间复杂度为:O(n),但是时间复杂度降为:O(nu+tu)
    运行结果:
    在这里插入图片描述

    结果分析:
    运行结果正确,可以快速算出矩阵的转置;
    附源程序:

    MA reversema(MA *A)//快速转置
    {
    	MA B;   //矩阵B为矩阵A转置以后的矩阵;
    	int i,col,p;      //辅助变量;
    	int num[A->nu+1],cpot[A->nu+1];   //num记录每一列中非0元素的个数,cpot记录该列第一个元素的存储位置
    	B.mu = A->nu; //初始化矩阵B
    	B.nu = A->mu; //初始化矩阵B
    	B.tu = A->tu; //初始化矩阵B
    	if(A->tu)    //如果矩阵A为零矩阵,那么就直接返回B就行了 
    	{
    		for(i = 1;i<=A->nu;i++)  //初始化num 
    			num[i] = 0;
    		for(i = 1;i<=A->tu;i++)  //得到num 
    			num[A->T[i].j]++;
    		cpot[1] = 1;  //初始化cpot
    		for(i = 2;i<=A->nu;i++)   //得到cpot 
    			cpot[i] = cpot[i-1] + num[i-1];
    		for(i = 1;i<=A->tu;i++)   //将A中的三元组赋值到对应的B中的三元组中 
    		{
    			col = A->T[i].j;
    			p = cpot[col];
    			B.T[p].i = A->T[i].j;
    			B.T[p].j = A->T[i].i;
    			B.T[p].data = A->T[i].data;
    			cpot[col]++;
    		}
    	}
    	return B;
    }
    

    3.题目:稀疏矩阵加法
    算法思想:
    开一个新的矩阵C,用来存放矩阵A+矩阵B的值,当A中某非0元素和矩阵B中某非0元素的行相等时,我们就返回他们的和给C,否则判断行或者列的大小关系,判断应该把谁先给矩阵C,当然要注意,跳出while循环时,可能有一个还有剩余,要将剩下的赋值过去。
    运行结果:
    在这里插入图片描述

    结果分析:
    结果运行正确,可以正确算出矩阵A和矩阵B的和
    附源程序:

    MA addition(MA *A,MA *B)
    {
    	MA C;    //将两个稀疏矩阵相加,并返回结果
    	int i,j,k;  //辅助变量
    	i = j = k = 1;   //赋初值 
    	if(A->mu != B->mu || A->nu != B->nu)   //判断矩阵A和矩阵B的维数,以此来看是否可以相加 
    	{
    		printf("矩阵A和矩阵B的维数不完全相同,不可以做加法!");
    		exit(0);
    	}
    	C.mu = A->mu;  //矩阵C初始化 
    	C.nu = A->nu;  //矩阵C初始化 
    	while(i<=A->tu&&j<=B->tu)    //循环条件,当i和j都没有把矩阵A和矩阵B中非零元素遍历完 
    	{
    		if(A->T[i].i == B->T[j].i)     //判断行关系 
    		{
    			if(A->T[i].j == B->T[j].j)   //判断列关系 
    			{
    				C.T[k].i = A->T[i].i;
    				C.T[k].j = A->T[i].j;
    				C.T[k].data = A->T[i].data + B->T[j].data;
    				k++;
    				i++;
    				j++;
    			}
    			else if(A->T[i].j < B->T[j].j)
    			{
    				C.T[k].i = A->T[i].i;
    				C.T[k].j = A->T[i].j;
    				C.T[k].data = A->T[i].data;
    				k++;
    				i++;
    			}
    			else
    			{
    				C.T[k].i = B->T[j].i;
    				C.T[k].j = B->T[j].j;
    				C.T[k].data = B->T[j].data;
    				k++;
    				j++;
    			}
    		}
    		else if(A->T[i].i < B->T[j].i)
    		{
    			C.T[k].i = A->T[i].i;
    			C.T[k].j = A->T[i].j;
    			C.T[k].data = A->T[i].data;
    			k++;
    			i++;
    		}
    		else
    		{
    			C.T[k].i = B->T[j].i;
    			C.T[k].j = B->T[j].j;
    			C.T[k].data = B->T[j].data;
    			k++;
    			j++;
    		}
    	}
    	while(i<=A->tu)    //如果是j先遍历完了,但是i没有遍历完,那么就将矩阵A中剩余元素赋值给矩阵C 
    	{
    		C.T[k].i = A->T[i].i;
    		C.T[k].j = A->T[i].j;
    		C.T[k].data = A->T[i].data;
    		k++;
    		i++;
    	}
    	while(j<=B->tu)   //如果是i先遍历完了,但是j没有遍历完,那么就将矩阵B中剩余元素赋值给矩阵C  
    	{
    		C.T[k].i = B->T[j].i;
    		C.T[k].j = B->T[j].j;
    		C.T[k].data = B->T[j].data;
    		k++;
    		j++;
    	}
    	C.tu = k-1;      //注意,我这里是先赋值,再k++,所以最后k的值比C中非零元素个数多1,所以要减去。 
    	return C;
    }
    

    二、小结
    写完这次作业以后,我收获很多,这道题我以前写过类似的,但是没有想到过每个小球只会和周围的两个球发生碰撞,我以前会采用遍历的方式来做,那么时间复杂度就为:,空间复杂度为:相比于学过数据结构以后的我设计出来的算法,以前的算法时间复杂度太大了,所以感觉学了数据结构以后收获颇丰。
    矩阵这里,我以前不会用三元组来表示,都是单纯的用二维数组来做的,那样的话,时间复杂度很高,所以学完了三元组感觉可以提升自己的矩阵处理能力了。
    (附上以前写的第一题的代码和结果,当然按照这道题的意思改了改原来的代码)

    main()
    {
    	int x[N],v[N];      //存储小球的位置信息和速度信息 
    	int i,j,k;          //辅助变量,i:用来进行对小球的位置信息和速度信息的初始化,,,,j,k:后面运动过程中进行改变球的位置信息和速度信息
    	int n,L,t;          //小球的个数n,线段的长度L,以及你需要计算t秒之后小球的位置
    	printf("请输入小球的个数n,线段的长度L,以及你需要计算t秒之后小球的位置: ");  //提示输入信息 
    	scanf("%d %d %d",&n,&L,&t);
    	while(L%2)          //判断线段的长度L是否是偶数
    	{
    		printf("线段的长度L输入错误,L必须是偶数!\n");
    		printf("请输入线段的长度L: ");
    		scanf("%d",&L);
    	}
    	for(i = 0;i<n;i++)      //初始化小球的位置信息和速度信息 
    	{
    		printf("请输入第%d个小球的初始坐标: ",i+1);
    		scanf("%d",&x[i]); 
    		v[i] = 1;   //初始速度全为1 
    		while(x[i]%2)          //判断第i+1个小球的初始坐标是否是偶数
    		{
    			printf("第%d个小球的初始坐标输入错误,L必须是偶数!\n",i+1);
    			printf("请输入第%d个小球的初始坐标: ",i+1);
    			scanf("%d",&x[i]);
    		}
    	}
    	for(j = 0;j<t;j++)         //不考虑初始位置相同的情况 
    	{
    		for(i = 0;i<n;i++)     //找到下一秒小球的位置,对小球位置进行更新 
    			x[i] = x[i]+v[i];
    		for(i = 0;i<n;i++)
    		{
    			for(k = i+1;k<n;k++)
    			{
    				if(x[i] == x[k])
    				{
    					v[i] = -v[i];
    					v[k] = -v[k];
    					continue;           //因为所有小球的初始位置都为偶数,而且线段的长度为偶数,可以证明,不会有三个小球同时相撞
    				}
    			}
    			if(x[i] == 0||x[i] == L)
    			{
    				v[i] = -v[i];
    			}
    		}
    	}
    	printf("%d秒后小球的位置坐标为:\n",t);
    	for(i = 0;i < n;i++)
    		printf("第%d个小球的位置为:%d\n",i+1,x[i]);
    }
    

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 顺序执行下来,没有设置循环运行,有很多确认判断,很好用哦~
  • 实现两个稀疏矩阵求和相减,相乘操作。 [基本要求] (1)矩阵可键盘输入。(2)输出求和,相减,相乘结果; (3)利用三元组数据结构。
  • 题目内容: 稀疏矩阵是一系列数字,其中大部分...一个表示稀疏矩阵求和结果的数字序列,数字之间空格分隔,结尾无空格 输入样例: 1 0 3 0 0 4 0 0 2 6 6 0 0 0 1 2 0 0 0 3 输出样例: 7 0 3 0 1 6 0 0 2 9
  • 稀疏矩阵

    2020-07-08 08:16:20
    稀疏矩阵 本词条由“科普中国”科学百科词条编写与应用工作项目审核 。 在矩阵中,若数值为0的元素数目远远多于非0元素的数目,并且非0元素分布没有规律时,则称该矩阵为稀疏矩阵;与之相反,若非0元素数目占...

    稀疏矩阵

    本词条由“科普中国”科学百科词条编写与应用工作项目 审核 。

    矩阵中,若数值为0的元素数目远远多于非0元素的数目,并且非0元素分布没有规律时,则称该矩阵为稀疏矩阵;与之相反,若非0元素数目占大多数时,则称该矩阵为稠密矩阵。定义非零元素的总数比上矩阵所有元素的总数为矩阵的稠密度。

    中文名

    稀疏矩阵

    外文名

    sparse matrix

    优    点

    计算速度更快

    对应名词

    稠密矩阵

    适用范围

    大型科学工程计算领域

    存储格式

    列压缩存储或行压缩存储

    目录

    1. 定义
    2. 简介
    3. 存储格式
    4. 优点
    5. 运算

    定义

    编辑

    矩阵中非零元素的个数远远小于矩阵元素的总数,并且非零元素的分布没有规律,通常认为矩阵中非零元素的总数比上矩阵所有元素总数的值小于等于0.05时,则称该矩阵为稀疏矩阵(sparse matrix),该比值称为这个矩阵的稠密度;与之相区别的是,如果非零元素的分布存在规律(如上三角矩阵、下三角矩阵、对角矩阵),则称该矩阵为特殊矩阵

    比较基本的定义是矩阵中的大多数元素为零,并且可以利用零元素节约大量存储、运算和程序运行时间。

    简介

    编辑

    稀疏矩阵几乎产生于所有的大型科学工程计算领域,包括计算流体力学、统计物理、电路模拟、图像处理、纳米材料计算等。

    存储格式

    编辑

    最常用的稀疏矩阵存储格式为列压缩存储(compressedcolumn storage,CCS) 或行压缩存储( ompressedrow storage,CRS)。

    以CCS 格式为例,一个

     阶包含 nnz 个非零元的稀疏矩阵需要用列指针、行指标和非零值三个一维数组表示,其中 nnz 维非零值数组按列记录所有非零元素,同样维数的行指标记录每列非零元所在的行,n+1 维的列打针向量记录每一列(包括 n+1 列) 的开始位置。还有三元组表和链接存储等其他格式等。

    一个对称或埃尔米特稀疏矩阵可以节约将近一半的存储量。

    符号稀疏矩阵(symbolic sparse matrix) 只需列指针和行指标两个数组。此外,稀疏向量是稀疏矩阵的特例,只需用指标和非零值两个数组表示,最近在电路、电子结构等领域得到越来越多的重视。

    图1.稀疏矩阵的压缩存储图1.稀疏矩阵的压缩存储

    优点

    编辑

    稀疏矩阵的计算速度更快,因为 MATLAB 只对非零元素进行操作,这是稀疏矩阵的一个突出的优点。

    假设矩阵 A,B 中的矩阵一样,计算 2*A 需要一百万次的浮点运算,而计算 2*B 只需要 2000 次浮点运算。

    因为 MATLAB 不能自动创建稀疏矩阵,所以要用特殊的命令来得到稀疏矩阵。算术和逻辑运算都适用于稀疏矩阵。

    对于一个用二维数组存储的稀疏矩阵 Amn ,如果假设存储每个数组元素需要 L 个字节,那么存储整个矩阵需要 m*n*L 个字节。但是,这些存储空间的大部分存放的是 0 元素,从而造成大量的空间浪费。为了节省存储空间,可以只存储其中的非 0 元素。

    图2.图2.

    对于矩阵 Amn 的每个元素 aij ,知道其行号 i 和列号 j 就可以确定其位置。因此对于稀疏矩阵可以用一个结点来存储一个非 0 元素。该结点可以定义:[i,j,aij]。该结点由3个域组成,i:行号,j:列号,aij:元素值。

    这样的结点被称为三元组结点。矩阵的每一个元素 Qij,由一个三元组结点 (i,j,aij) 唯一确定。

    运算

    编辑

    稀疏矩阵和稠密向量的乘积运算等相对容易实现。稀疏矩阵和稠密向量的高性能运算类似,它可以通过对行列的适当排序实现,其中块操作起着至关重要的作用。

    对稀疏矩阵结构的操作则比较复杂,和排序、消去数等图论技巧关系密切,比如稀疏矩阵的求和与三角分解会产生填充(fill-in),两个稀疏矩阵的乘积的高效实现至今仍是一个具有挑战性的问题。另一方面,稀疏矩阵运算,比如三角分解,还要考虑数值稳定性问题,稀疏性和数值稳定性往往是一对矛盾。

    有些应用问题,尤其是有限元离散化得到的稀疏矩阵,往往具有非常特殊的结构,在区域和网格均匀等条件下可以实现快速算法。 [1]

    展开全文
  • Java实现 稀疏矩阵乘积

    万次阅读 多人点赞 2020-02-25 14:22:03
    稀疏矩阵乘积 描述 给定两个N × N的稀疏矩阵A和B,其中矩阵A有P个元素非0,矩阵B有Q个元素非0。请计算两个矩阵的乘积C = A × B并且输出C中所有非0的元素。 输入 第一行包含三个整数N, P, Q 以下P行每行三个整数i, ...

    稀疏矩阵乘积

    描述
    给定两个N × N的稀疏矩阵A和B,其中矩阵A有P个元素非0,矩阵B有Q个元素非0。请计算两个矩阵的乘积C = A × B并且输出C中所有非0的元素。
    输入
    第一行包含三个整数N, P, Q
    以下P行每行三个整数i, j, k表示A矩阵的一个非0元素:Aij = k
    以下Q行每行三个整数i, j, k表示B矩阵的一个非0元素:Bij = k
    对于80%的数据,1 ≤ N, P, Q ≤ 200
    对于100%的数据, 1 ≤ N, P, Q ≤ 2000, 1 ≤ i, j ≤ N, 0 ≤ k ≤ 100
    输出
    输出若干行,按先行后列的顺序输出矩阵C的每一个非0元素
    每行三个整数i, j, k表示C矩阵的一个非0元素:Cij = k
    样例输入
    2 2 4
    1 1 1
    2 2 1
    1 1 1
    1 2 2
    2 1 3
    2 2 4
    样例输出
    1 1 1
    1 2 2
    2 1 3
    2 2 4

    package 第二次模拟;
    
    import java.util.Scanner;
    
    public class Demo4矩阵相乘 {
    	public static void main(String[] args) {
    		Scanner sc = new Scanner(System.in);
    		int n = sc.nextInt();
    		int p = sc.nextInt();
    		int q=sc.nextInt();
    		int [] [] a = new int [p][3];
    		int [] [] b = new int [q][3];
    		for (int i = 0; i < p; i++) {
    			for (int j = 0; j < 3; j++) {
    				a[i][j]=sc.nextInt();
    			}
    		}
    		for (int i = 0; i < q; i++) {
    			for (int j = 0; j < 3; j++) {
    				b[i][j]=sc.nextInt();
    			}
    		}
    		sc.close();
    		int [] [] c = new int [n][n];
    		  for (int i = 0; i < p; i++) {
    	            for (int j = 0; j < q; j++) {
    	                if (a[i][1] == b[j][0]) {//由图可以看出当A矩阵的列号等于B矩阵的行号时求和
    	                    c[a[i][0]-1][b[j][1]-1] += a[i][2] * b[j][2];
    	                }
    	            }
    	        }
    		for (int i = 0; i <n; i++) {
    			for (int j = 0; j <n; j++) {
    				System.out.println(i+1+" "+(j+1)+" "+c[i][j]);
    			}
    			 
    		}
    	}
    
    }
    
    
    展开全文
  • #include #include using namespace std; typedef struct Node { int i, j, v; Node *right, *down; }Node; typedef struct Crosslist { int s; Node **rHead, **cHead;...int Tran (Crosslist &N)

    第二次大作业,作为自己第一次完整打下来的代码,虽然出现了很多bug,但是都一一找出来的,写得不好,但是我会继续努力的,传上blog,mark一下。

    #include <iostream>
    #include <cstdio>
    using namespace std;
    
    typedef struct Node
    {
    	int i, j, v;
    	Node *right, *down;
    }Node;
    typedef struct Crosslist
    {
    	int s;
    	Node **rHead, **cHead;
    }Crosslist;
    int Tran (Crosslist &N)
    {
    	int k, flag = 0;
    	Node *R;
    	for (k=0; k<N.s; k++)
    	{
    		for (R=N.cHead[k]; R!=NULL; R=R->down)
    		{
    			if (flag == 0)
    			{
    				printf ("%d %d %d", R->j, R->i, R->v);
    			}
    			else
    				printf ("\n%d %d %d", R->j, R->i, R->v);
    			flag = 1;	
    		}
    	}
    	return 0;
    }
    int Add (Crosslist &N)
    {
    	int k, flag;
    	Node *R, *S;
    	for (k=0; k<N.s; k++)
    	{
    		R = N.rHead[k];
    		S = N.cHead[k];
    		flag = 1;
    		while (flag == 1)
    		{
    			if (R!=NULL && S!=NULL)
    			{
    				if (R->j == S->i)
    				{
    					if(R->v+S->v != 0)
    					printf ("\n%d %d %d", S->j, S->i, (R->v+S->v));
    					R = R->right;
    					S = S->down;
    				}
    				else if (R->j < S->i)
    				{
    					printf ("\n%d %d %d", R->i, R->j, R->v);
    					R = R->right;
    				}
    				else if (R->j > S->i)
    				{
    					printf ("\n%d %d %d", S->j,S->i, S->v);
    					S = S->down;
    				}
    			}
    			else if (R!=NULL && S==NULL)
    			{
    				while (R!=NULL)
    				{
    					printf ("\n%d %d %d", R->i, R->j, R->v);
    					R = R->right;
    				}
    			}
    			else if (R==NULL && S!=NULL)
    			{
    				while (S!=NULL)
    				{
    					printf ("\n%d %d %d", S->j, S->i, S->v);
    					S = S->down;
    				}
    			}
    			else if (R==NULL && S==NULL)
    			{
    				flag = 0;
    			}
    		}
    	}
    	return 0;
    }
    int Muti (Crosslist &N)
    {
    	int k, t, flag, sum = 0;
    	Node *R, *S;
    	for (k=0; k<N.s; k++)
    	{
    		for (t=0; t<N.s; t++)
    		{
    			R = N.rHead[k];
    			S = N.rHead[t];
    			flag = 1;
    			while (flag == 1)
    			{
    				if (R!=NULL && S!=NULL)
    				{
    					if (R->j == S->j)
    					{
    						sum += R->v*S->v;
    						R = R->right;
    						S = S->right;
    					}
    					else if (R->j < S->j)
    					{
    						R = R->right;
    					}
    					else if (R->j > S->j)
    					{
    						S = S->right;
    					}
    				}
    				else
    				{
    					flag = 0;
    				}
    
    			}
    			while (sum != 0)
    			{
    				printf("\n%d %d %d",k,t,sum);
    				sum = 0;
    			}
    		}	
    	}
    	return 0;
    }
    int main ()
    {
    	int m = 0, n = 0, l = 0, t, flag = 0;
    	Node *P, *Q;
    	Crosslist M;
    	scanf ("%d%d%d",&m, &n, &l);
    	if (m<=0 || n<=0 || l<=0 || m!=n || l>m*n)
    		return 0;
    	M.s = m;
    	M.rHead = new Node *[m];
    	M.cHead = new Node *[n];
    	for(t=0; t<m; t++)
    	{
    		M.rHead[t] = NULL;
    		M.cHead[t] = NULL;
    	}
    	for (t=0; t<l; t++)
    	{
    		P = new Node;
    		scanf ("%d%d%d",&P->i, &P->j, &P->v);
    		if (P->i>=0 && P->i<m && P->j>=0 && P->j<n && P->v>=-10 && P->v<=10 && P->v!=0)
    		{
    			flag = 1;
    			if (M.rHead[P->i]==NULL || P->j<M.rHead[P->i]->j)
    			{
    				P->right = M.rHead[P->i];
    				M.rHead[P->i] = P;
    			}
    			else
    			{
    				for (Q=M.rHead[P->i]; Q->right && P->j>Q->right->j; Q=Q->right);
    				P->right = Q->right;
    				Q->right = P;
    			}
    			if (M.cHead[P->j]==NULL || P->i<M.cHead[P->j]->i)
    			{
    				P->down = M.cHead[P->j];
    				M.cHead[P->j] = P;
    			}
    			else
    			{
    				for (Q=M.cHead[P->j]; Q->down && P->i>Q->down->i; Q=Q->down);
    				P->down = Q->down;
    				Q->down = P;
    			}		
    		}
    	}
    	if (flag == 0)
    		return 0;
    	Tran (M);
    	Add (M);
    	Muti (M);
    	return 0;
    }


    展开全文
  • 稀疏矩阵操作

    千次阅读 2018-10-13 20:09:27
    稀疏矩阵格式 在许多应用中(例如,有限元方法),通常处理非常大的矩阵,其中只有少数系数与零不同。 在这种情况下,通过使用仅存储非零系数的专用表示,可以减少存储器消耗并提高性能。 这种矩阵称为稀疏矩阵。 ...
  • python 稀疏矩阵的计算

    2020-11-04 13:46:19
    python 稀疏矩阵的计算1 稀疏矩阵的学习2 稀疏矩阵的实现 1 稀疏矩阵的学习 SciPy教程 - 稀疏矩阵库scipy.sparse 稀疏矩阵运算库 官方文档 2 稀疏矩阵的实现 code # coding = utf-8 from scipy.sparse import rand...
  • 数据结构实践——稀疏矩阵相加

    万次阅读 多人点赞 2015-10-07 21:06:53
     采用三元组存储稀疏矩阵,设计两个稀疏矩阵相加的运算算法 提示1:两个行数、列数相同的矩阵可以相加 提示2:充分利用已经建立好的算法库解决问题[参考解答1](程序中使用的头文件”tup.h”见稀疏矩阵的三元组...
  • 设计一个稀疏矩阵运算器。实现两个矩阵相加、相减和相乘等的运算。矩阵的输入输出均按通常的阵列形式
  • 稀疏矩阵动态增加行

    2019-06-04 15:41:37
    """ 稀疏矩阵动态增加行 原理:创建一个1行n列的新矩阵与原矩阵合并-->tocsr() 成为新的稀疏矩阵.动态增加的目的达成 """ import sys import scipy.sparse as ss import numpy as np a = ss.dok_matrix((0, 100...
  • 实现了稀疏矩阵A+B相加 数据结构中的采用结构体数组进行稀疏矩阵的存储
  • 根据用户输入的矩阵,实现稀疏矩阵求和运算,并输出结果。 2、输入要求:的数据在程序运行的时候由用户提供,先由用户输入稀疏矩阵的行数、列数和非零元个数。再根据非零元个数,输入这些非零元,还需要用户为这些...
  • // c5-2.h 稀疏矩阵的三元组顺序表存储表示(见图5.4) #define MAX_SIZE 100 // 非零元个数的最大值 struct Triple { int i,j; // 行下标,列下标 ElemType e; // 非零元素值 }; struct TSMatrix { Triple data[MAX...
  • 稀疏矩阵和广义表 C语言实现

    千次阅读 2013-11-29 16:06:34
    1、稀疏矩阵概念 稀疏矩阵是矩阵中的一种特殊情况,其非零元素个数远小于零元素个数。 如下图为一个稀疏矩阵 2、稀疏矩阵的存储结构 稀疏矩阵的存储结构分为顺序存储和链接存储,链接存储又分为带行指针向量的...
  • 但是很多情况下,并不是每一个元素都是非零的,当一个矩阵中的非零元素的较少的时候,其实是存在着空间的浪费的,于是,应该采用稀疏矩阵的方式来进行数据的保存和运算。 11月1号将稀疏矩阵的内容写成了办完工状态...
  • 稀疏矩阵的乘法

    千次阅读 2019-06-26 11:01:34
    1492.稀疏矩阵的乘法 时限:1000ms 内存限制:10000K 总时限:3000ms 描述 计算两个稀疏矩阵的乘法 输入 首先输入第一个矩阵的行数和列数,再输入该矩阵的三元组形式,以0 0 0结束  然后输入第二个矩阵的行数和列数...
  • 稀疏矩阵的压缩存储

    2018-05-02 19:27:00
    实现稀疏矩阵压缩存储,并实现矩阵转置和求和。 输入矩阵时,首先需要输入非零元素的个数,然后分别输入矩阵的 行号,列号和值。 输完2个矩阵后,自动进行计算第一个矩阵的转置以及两个矩阵的和。 例如:输入如下: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,768
精华内容 3,107
关键字:

稀疏矩阵求和