精华内容
下载资源
问答
  • 十五、稀疏矩阵乘法运算

    千次阅读 2020-10-30 18:51:40
    十五、稀疏矩阵乘法运算 文章目录十五、稀疏矩阵乘法运算题目描述解题思路上机代码 题目描述 数据压缩是提高传输、存储效率一种技术。教材第5章介绍了两种简单的压缩存储方法。 本实验要求实现两个稀疏矩阵相...

    十五、稀疏矩阵的乘法运算

    题目描述

    数据压缩是提高传输、存储效率一种技术。教材第5章介绍了两种简单的压缩存储方法。

    本实验要求实现两个稀疏矩阵相乘积的算法**。其中稀疏矩阵非零元素数量小于100.**

    输入:

    第1个稀疏矩阵的行数

    • 列数
    • 非零元个数(三个数都大于0)
    • 三元组

    第2个稀疏矩阵的行数

    • 列数
    • 非零元个数(三个数都大于0)
    • 三元组

    以行为主序输入稀疏矩阵三元组表

    输出

    乘积矩阵的行数
    列数
    非零元个数(三个数都大于0)
    三元组

    测试输入期待的输出时间限制内存限制额外进程
    测试用例 13
    4
    4
    1 1 3
    1 4 5
    2 2 -1
    3 1 2
    4
    2
    4
    1 2 2
    2 1 1
    3 1 -2
    3 2 4
    3
    2
    3
    1,2,6
    2,1,-1
    3,2,4
    1秒256KB0

    解题思路

    教材第 100 页指出,为了便于随机存取任意一行的非零元,需要知道每一行的第一个非零元在三元组表中的位置。因此,把指示 “行” 信息的辅助数组 cpot 固定在稀疏矩阵的存储结构中,称这种 “带行链接信息” 的三元组表为行逻辑链接的顺序表。

    /* 行逻辑链接顺序表 */
    typedef struct {
    	Triple data[1000];	//非零元三元组表
    	int rpos[1000];		//各行第一个非零元的位置表
    	int mu, nu, tu;		//矩阵的行数、列数和非零元个数
    }RLSMatrix;
    

    教材第 102 页给出了稀疏矩阵乘法的基本操作描述和算法流程实现。

    矩阵乘法

    上机代码

    #include<cstdio>  
    #include<stack>  
    #include<cstring>   
    #include<cstdlib>   
    #include<iostream>  
    using namespace std;
    
    //定义三元组和顺序表
    typedef struct {
    	int i, j;
    	int e;
    }Triple;
    typedef struct {
    	Triple data[1000];
    	int rpos[1000];
    	int mu, nu, tu;
    }RLSMatrix;
    int rpos[1000];
    int num[1000];
    
    int main()
    {
    	int arow = 0, brow = 0, tp = 0;
    	int col = 0, ccol = 0;
    	int p = 0, t = 0, q = 0;
    	RLSMatrix M, N, Q;
    
    	//输入M、N矩阵数据
    	scanf("%d%d%d", &M.mu, &M.nu, &M.tu);
    	for (int i = 1; i <= M.tu; i++)
    		scanf("%d%d%d", &M.data[i].i, &M.data[i].j, &M.data[i].e);
    	scanf("%d%d%d", &N.mu, &N.nu, &N.tu);
    	for (int i = 1; i <= N.tu; i++)
    		scanf("%d%d%d", &N.data[i].i, &N.data[i].j, &N.data[i].e);
    	
    	for (col = 1; col <= M.mu; col++)
    		num[col] = 0;
    	for (int i = 1; i <= M.tu; i++)
    		num[M.data[i].i]++;
    	M.rpos[1] = 1;
    	for (col = 2; col <= M.mu; col++)
    		M.rpos[col] = M.rpos[col - 1] + num[col - 1];
    	for (col = 1; col <= N.mu; col++)
    		num[col] = 0;
    	for (int i = 1; i <= N.tu; i++)
    		num[N.data[i].i]++;
    	N.rpos[1] = 1;
    	for (col = 2; col <= N.mu; col++)
    		N.rpos[col] = N.rpos[col - 1] + num[col - 1];
    	
    	/* 计算矩阵乘积 */
    	Q.mu = M.mu;
    	Q.nu = N.nu;
    	Q.tu = 0;
    	if (M.tu*N.tu != 0) 
    	{
    		for (arow = 1; arow <= M.mu; arow++) 
    		{
    			memset(rpos, 0, sizeof(rpos));
    			Q.rpos[arow] = Q.tu + 1;
    			if (arow < M.mu)
    				tp = M.rpos[arow + 1];
    			else
    				tp = M.tu + 1;
    			for (p = M.rpos[arow]; p < tp; p++) 
    			{
    				brow = M.data[p].j;
    				if (brow < N.mu)
    					t = N.rpos[brow + 1];
    				else
    					t = N.tu + 1;
    				for (q = N.rpos[brow]; q < t; q++) 
    				{
    					ccol = N.data[q].j;
    					rpos[ccol] += M.data[p].e*N.data[q].e;
    				}
    			}
    			for (ccol = 1; ccol <= Q.nu; ccol++)
    			{
    				if (rpos[ccol]) {
    					Q.tu++;
    					Q.data[Q.tu].i = arow;
    					Q.data[Q.tu].j = ccol;
    					Q.data[Q.tu].e = rpos[ccol];
    				}
    			}
    		}
    	}
    
    	//输出乘积矩阵Q
    	printf("%d\n", Q.mu);
    	printf("%d\n", Q.nu);
    	printf("%d\n", Q.tu);
    	for (int i = 1; i <= Q.tu; i++)
    		printf("%d,%d,%d\n", Q.data[i].i, Q.data[i].j, Q.data[i].e);
    
    	return 0;
    }
    
    展开全文
  • 稀疏矩阵乘法运算

    千次阅读 2020-10-28 15:42:14
    稀疏矩阵乘法运算题目信息输入输出测试样例解答想法 题目信息 数据压缩是提高传输、存储效率一种技术。 本实验要求实现两个稀疏矩阵相乘积的算法。其中稀疏矩阵非零元素数量小于100. 输入 第1个稀疏矩阵的行数,列...

    题目信息

    数据压缩是提高传输、存储效率一种技术。
    本实验要求实现两个稀疏矩阵相乘积的算法。其中稀疏矩阵非零元素数量小于100.

    输入

    第1个稀疏矩阵的行数,列数,非零元个数(三个数都大于0),三元组
    第2个稀疏矩阵的行数,列数,非零元个数(三个数都大于0),三元组
    以行为主序输入稀疏矩阵三元组表

    输出

    乘积矩阵的行数
    列数
    非零元个数(三个数都大于0)
    三元组

    测试样例

    3
    4
    4
    1 1 3
    1 4 5
    2 2 -1
    3 1 2
    4
    2
    4
    1 2 2
    2 1 1
    3 1 -2
    3 2 4
    
    3
    2
    3
    1,2,6
    2,1,-1
    3,2,4
    

    解答

    #include<stdio.h>
    
    typedef struct
    {
        int i, j;
        int e;
    } Node;
    typedef struct
    {
        Node nodes[105];
        int rpos[105];//各行第一个非零元的位置表
        int m, n, t;
    } Matrix;
    
    int main()
    {
        //freopen("/Users/zhj/Downloads/test.txt", "r", stdin);
        Matrix A, B;
    
        scanf("%d%d%d", &A.m, &A.n, &A.t);
        for (int i = 1; i <= A.t; i++)
        {
            scanf("%d%d%d", &A.nodes[i].i, &A.nodes[i].j, &A.nodes[i].e);
        }
        int num[1000];
        for (int col = 1; col <= A.m; col++)
        {
            num[col] = 0;
        }
        for (int i = 1; i <= A.t; i++)
        {
            num[A.nodes[i].i]++;
        }
        A.rpos[1] = 1;
        for (int col = 2; col <= A.m; col++)
        {
            A.rpos[col] = A.rpos[col - 1] + num[col - 1];
        }
    
        scanf("%d%d%d", &B.m, &B.n, &B.t);
        for (int i = 1; i <= B.t; i++)
        {
            scanf("%d%d%d", &B.nodes[i].i, &B.nodes[i].j, &B.nodes[i].e);
        }
        for (int col = 1; col <= B.m; col++)
        {
            num[col] = 0;
        }
        for (int i = 1; i <= B.t; i++)
        {
            num[B.nodes[i].i]++;
        }
        B.rpos[1] = 1;
        for (int col = 2; col <= B.m; col++)
        {
            B.rpos[col] = B.rpos[col - 1] + num[col - 1];
        }
    
        Matrix Q;
        Q.m = A.m;
        Q.n = B.n;
        Q.t = 0;//创建答案矩阵
    
        if (A.t * B.t != 0)
        {//Q是非零矩阵
            for (int arow = 1; arow <= A.m; arow++)
            {//处理A的每一行
                int ctemp[105] = {0};
                Q.rpos[arow] = Q.t + 1;
    
                int tp;//tp是下一行元素在nodes表中位置
                if (arow < A.m)
                {
                    tp = A.rpos[arow + 1];
                }
                else
                {
                    tp = A.t + 1;
                }
                for (int p = A.rpos[arow]; p < tp; p++)
                {//对当前行中每一个非零元,既从当前在nodes表中位置找到下一行元素在nodes表的位置
                    int brow = A.nodes[p].j;//此为A表中的纵向位置值,在B表中找相应的行号即可
    
                    int t;//t仍然为下一行的位置
                    if (brow < B.m)
                    {
                        t = B.rpos[brow + 1];
                    }
                    else
                    {
                        t = B.t + 1;
                    }
                    for (int q = B.rpos[brow]; q < t; q++)
                    {
                        int ccol = B.nodes[q].j;//Q中的纵坐标是以B元素中的j来说话的
                        ctemp[ccol] += A.nodes[p].e * B.nodes[q].e;
                    }
                }
    
                for (int ccol = 1; ccol <= Q.n; ccol++)
                {//压缩存储该行的非零元
                    if (ctemp[ccol])
                    {//如果此处有值的话
                        Q.t++;//Q的非零元素多了一个
                        Q.nodes[Q.t].i = arow;//行号为此时遍历的A的行号
                        Q.nodes[Q.t].j = ccol;//列号为此时正在进行压缩所遍历到有值的地方
                        Q.nodes[Q.t].e = ctemp[ccol];//累计的和拷贝过来
                    }
                }
            }
        }
    
        printf("%d\n", Q.m);
        printf("%d\n", Q.n);
        printf("%d\n", Q.t);
        for (int i = 1; i <= Q.t; i++)
        {
            printf("%d,%d,%d\n", Q.nodes[i].i, Q.nodes[i].j, Q.nodes[i].e);
        }
        return 0;
    }
    

    想法

    在这里插入图片描述
    对于A中每个元素A.nodes[p](p=1,2,...,A.t),找到N中所有满足条件A.nodes[p].j = B.nodes.i的元素B.nodes[q],求得A.nodes[p].vB.nodes[q].v的乘积.
    乘积矩阵Q中每个元素的值是个累积和,这个乘积A.nodes[p].v * B.nodes[q],v只是Q[i][j]中的一部分.为便于操作,应对每个元素设一累计和的变量,其初值为零,然后扫面数组A,求得相应元素的乘积并累加到适当的求累计和的变量上

    展开全文
  • C ++中的稀疏矩阵乘法

    2021-05-19 12:32:38
    假设我们有两个矩阵A和B,我们必须找到AB的结果。我们可以假设A的列号等于B的行号。因此,如果输入像[[1,0,0],[-1,0,3]] [[7,0,0],[0,0,0],[0,0,1]] ,100-103700000001那么输出将是[[7,0,0],[-7,0,3]]700-703...

    假设我们有两个矩阵A和B,我们必须找到AB的结果。我们可以假设A的列号等于B的行号。

    因此,如果输入像[[1,0,0],[-1,0,3]] [[7,0,0],[0,0,0],[0,0,1]] ,100

    -103

    700

    000

    001

    那么输出将是[[7,0,0],[-7,0,3]]700

    -703

    为了解决这个问题,我们将遵循以下步骤-r1:= A的大小,r2:= B的大小

    c1:= A [0]的大小,c2:= B [0]的大小

    定义顺序为r1 x c2的一个2D数组ret

    定义成对的数组sparseA [r1]

    对于初始化i:= 0,当i

    在sparseA [i]的末尾插入{j,A [i,j]}

    对于初始化j:= 0,当j

    对于初始化i:= 0,当i

    ret [i,k]:= ret [i,k] + sparseA [i,j] * B [x,k]的第二个元素

    x:= sparseA [i,j]的第一个元素

    如果B [x,k]不等于0,则-

    对于初始化j:= 0,当j

    返回ret

    让我们看下面的实现以更好地理解-class Solution {

    public:

    vector multiply(vector& A, vector& B) {

    int r1 = A.size();

    int r2 = B.size();

    int c1 = A[0].size();

    int c2 = B[0].size();

    vector  ret(r1, vector 

    vector  > sparseA[r1];

    for(int i = 0; i 

    for(int j = 0; j 

    if(A[i][j] != 0)sparseA[i].push_back({j, A[i][j]});

    }

    }

    for(int i = 0; i 

    for(int j = 0; j 

    for(int k = 0; k 

    int x = sparseA[i][j].first;

    if(B[x][k] != 0){

    ret[i][k] += sparseA[i][j].second * B[x][k];

    }

    }

    }

    }

    return ret;

    }

    };

    输入值{{1,0,0},{-1,0,3}},{{7,0,0},{0,0,0},{0,0,1}}

    输出结果[[7, 0, 0, ],[-7, 0, 3, ],]

    展开全文
  • 今天小编就为大家分享一篇关于C++稀疏矩阵的各种基本运算并实现加法乘法,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • 数据结构课程设计《稀疏矩阵乘法运算的十字链表实现》
  • 稀疏矩阵的加法和乘法运算 上节学了类的友元,这节开始矩阵加法和乘法运算: (一)加法: 在这里插入代码片 在这里插入代码片

    稀疏矩阵的加法和乘法运算

    在这里插入图片描述
    上节学了类的友元,这节开始矩阵加法和乘法运算:
    (一)加法:
    三元组.h文件

    #pragma once
    #include<iostream>
    using namespace std;
    #include <string>
    #define Max 100
    #define ERROR 0
    #define OK 1
    
    typedef struct  //三元组
    {
    	int line;   //行
    	int row;    //列
    	int item;   //值
    }Trip;
    
    
    class TripMN
    {
    private:
    	Trip  dat[Max];
    	int L, R, num;   //行 ,列, 非零元个数
    public:
    	TripMN()       //自我构造
    	{
    		L = 0;
    		R = 0;
    		num = 0;
    	}
    
    	TripMN(int m, int n)   //创建对象时完成对属性的初始化
    	{
    		L = m;
    		R = n;
    		num = 0;
    	}
    
    	~TripMN()
    	{
    		//空
    	}
    
    	int set_Item(int line, int row, int item)   //根据行号列号添加一个三元组
    	{
    		//******检查******//
    		if (line > L || row > R)  //越界
    		{
    			return ERROR;
    		}
    		if (num == Max)    //已存元素个数num达到过三元组可以存储的最大位
    		{
    			return ERROR;
    		}
    		if (item == 0)     //输入的数组元素值为0,则不做插入,直接返回
    		{
    			return OK;
    		}
    		//******插入*******//
    		int index = 0;   //存储元素应该插入的位置
    		while (index < num)    
    		{
    			    //作比较时看你时先插第一行之后下一行,然后在下一行,三元组如果是按这个方式,就先查行进行插入
    			if (line>dat[index].line)    
    			{
    				index++;        //先比行,行小于三元组行时,向后继续比较
    			}
    			else if (line == dat[index].line && (row > dat[index].row))
    			{
    				index++;        //当行相等,列号大的时候,向后继续比较
    			}
    			else
    			{
    				break;          //找到了位置
    			}
    		}
    		if (line == dat[index].line && row == dat[index].row)
    		{
    			dat[index].item = item;  //如果所插正好相等,就覆盖
    		}
    		for (int i = num ; i > index ; i--)
    		{
    			dat[i].line = dat[i - 1].line;
    			dat[i].row = dat[i - 1].row;
    			dat[i].item = dat[i - 1].item;     //**从尾部开始移位
    		}
    		dat[index].item = item;     //插入
    		dat[index].line = line;
    		dat[index].row = row;
    		num++;    //个数加一
    		return OK;
    	}
    
    	int get_Ttem(int line, int row)   //根据行号和列号获得一个三元组
    	{
    		if (line > L || row > R)   //越界检查
    		{
    			return 0;
    		}
    		
    		for (int i = 0; i < num; i++)   //遍历三元组
    		{    //如果发现行号列号匹配三元组,返回非零元素值
    			if (dat[i].line == line && dat[i].row == row)
    			{
    				return dat[i].item;
    			}
    		}
    		return 0;	
    	}
    
    	void  printMatrix()    //按矩阵方式打印稀疏矩阵
    	{
    		int index = 0;   //三元组下标
    		cout << "《打印稀疏矩阵》: " << endl;
    		for (int i = 1; i <= L; i++)
    		{
    			for (int j = 1; j <= R; j++)
    			{
    				if (i == dat[index].line && j == dat[index].row)
    				{
    					cout << dat[index].item << "\t";
    					index++;
    				}
    				else
    				{
    					cout << "0\t";
    				}
    			}
    			cout << "\n";
    		}
    		cout << "矩阵行数: " << L << "\n" << "矩阵列数:" << R << "\n" << "矩阵非零元个数: " << num << endl;
    	}
    
    	void printTrip()     //打印三元组
    	{
    		cout << "\n";
    		int index = 0;
    		cout << "打印三元组数组(行,列,值): " << endl;
    		for(int i = 0; i < num; i++)
    		{
    			cout << "(" << dat[i].line << ", " << dat[i].row << ", " << dat[i].item << ")" << endl;
    		}
    	}
    
    	friend bool TripADD(TripMN& A, TripMN& B, TripMN& C);    //加法 ,矩阵:A+B=C 友元
    };                                                            //需要被传出去的才加&
    
    bool TripADD(TripMN& A, TripMN& B, TripMN& C)
    {
    	if (A.L != B.L || B.L != C.L || A.R != B.R || B.R != C.R )
    	{
    		return false;   //检查行列是否相等,矩阵加法前提
    	}
    	else
    	{
    		for (int i = 0; i < A.L; i++)
    		{
    			for (int j = 0; j < A.R; j++)
    			{
    				int item = A.get_Ttem(i,j) + B.get_Ttem(i,j);  //将A,B矩阵值相加
    				//如果计算出来不为零,则插入矩阵之中
    				if (item != 0)
    				{
    					C.set_Item(i, j, item);
    				}
    			}
    		}
    		return true;
    	}
    }
    

    三元组.cpp文件

    #include"三元组.h"
    
    void input(int m,int n, int num, TripMN& trip)     //初始化三元组
    {
    	int line, row, item;
    	for (int i = 1; i <= num; i++)
    	{
    		cout << "请依次输入,行,列,和非零元:";
    		cin >> line >> row >> item;
    		if (item != 0)
    		{
    			if(trip.set_Item(line, row, item)==ERROR)
    			{
    				cout << "行号列号不正确,或者三元组已满 !!!";
    				break;
    			}
    		}
    	}
    }
    
    
    int main()
    { 
    	int m, n, num;
    	cout << "请输入第(一)个矩阵A行数列数,非零元个数: ";
    	cin >> m;
    	cin >> n;
    	cin >> num;
    	TripMN A(m,n);     //类的人工初始化
    	input(m, n, num, A);    //创建一个矩阵
    	//trip.printTrip();
    	A.printMatrix();
    
    	cout << "请输入第(二)个矩阵B行数列数,非零元个数: ";
    	cin >> m;
    	cin >> n;
    	cin >> num;
    	TripMN B(m, n);     //类的人工初始化
    	input(m, n, num, B);    //创建一个矩阵
    	//trip.printTrip();
    	B.printMatrix();
    
    	TripMN C(m, n);
    	bool resurt = TripADD(A, B, C);
    	if (resurt)
    	{
    		cout << "矩阵相加后C:" << endl;
    		C.printMatrix();
    	}
    	else
    	{
    		cout << "矩阵不能相加!!!" << endl;
    	}
    	return 0;
    }
    

    在这里插入图片描述

    (二).乘法:
    有i,j, k三个变量,i表示A矩阵的行,j表示A矩阵的列==B矩阵的行,k表示B矩阵的列。
    在这里插入图片描述
    .h文件

    #pragma once
    #include<iostream>
    using namespace std;
    #include <string>
    #define Max 100
    #define ERROR 0
    #define OK 1
    
    typedef struct  //三元组
    {
    	int line;   //行
    	int row;    //列
    	int item;   //值
    }Trip;
    
    
    class TripMN
    {
    private:
    	Trip  dat[Max];
    	int L, R, num;   //行 ,列, 非零元个数
    public:
    	TripMN()       //自我构造
    	{
    		L = 0;
    		R = 0;
    		num = 0;
    	}
    
    	TripMN(int m, int n)   //创建对象时完成对属性的初始化
    	{
    		L = m;
    		R = n;
    		num = 0;
    	}
    
    	~TripMN()
    	{
    		//空
    	}
    
    	int set_Item(int line, int row, int item)   //根据行号列号添加一个三元组
    	{
    		//******检查******//
    		if (line > L || row > R)  //越界
    		{
    			return ERROR;
    		}
    		if (num == Max)    //已存元素个数num达到过三元组可以存储的最大位
    		{
    			return ERROR;
    		}
    		if (item == 0)     //输入的数组元素值为0,则不做插入,直接返回
    		{
    			return OK;
    		}
    		//******插入*******//
    		int index = 0;   //存储元素应该插入的位置
    		while (index < num)    
    		{
    			    //作比较时看你时先插第一行之后下一行,然后在下一行,三元组如果是按这个方式,就先查行进行插入
    			if (line>dat[index].line)    
    			{
    				index++;        //先比行,行小于三元组行时,向后继续比较
    			}
    			else if (line == dat[index].line && (row > dat[index].row))
    			{
    				index++;        //当行相等,列号大的时候,向后继续比较
    			}
    			else
    			{
    				break;          //找到了位置
    			}
    		}
    		if (line == dat[index].line && row == dat[index].row)
    		{
    			dat[index].item = item;  //如果所插正好相等,就覆盖
    		}
    		for (int i = num ; i > index ; i--)
    		{
    			dat[i].line = dat[i - 1].line;
    			dat[i].row = dat[i - 1].row;
    			dat[i].item = dat[i - 1].item;     //**从尾部开始移位
    		}
    		dat[index].item = item;     //插入
    		dat[index].line = line;
    		dat[index].row = row;
    		num++;    //个数加一
    		return OK;
    	}
    
    	int get_Ttem(int line, int row)   //根据行号和列号获得一个三元组
    	{
    		if (line > L || row > R)   //越界检查
    		{
    			return 0;
    		}
    		
    		for (int i = 0; i < num; i++)   //遍历三元组
    		{    //如果发现行号列号匹配三元组,返回非零元素值
    			if (dat[i].line == line && dat[i].row == row)
    			{
    				return dat[i].item;
    			}
    		}
    		return 0;	
    	}
    
    	void  printMatrix()    //按矩阵方式打印稀疏矩阵
    	{
    		int index = 0;   //三元组下标
    		cout << "《打印稀疏矩阵》: " << endl;
    		for (int i = 1; i <= L; i++)
    		{
    			for (int j = 1; j <= R; j++)
    			{
    				if (i == dat[index].line && j == dat[index].row)
    				{
    					cout << dat[index].item << "\t";
    					index++;
    				}
    				else
    				{
    					cout << "0\t";
    				}
    			}
    			cout << "\n";
    		}
    		cout << "矩阵行数: " << L << "\n" << "矩阵列数:" << R << "\n" << "矩阵非零元个数: " << num << endl;
    	}
    
    	void printTrip()     //打印三元组
    	{
    		cout << "\n";
    		int index = 0;
    		cout << "打印三元组数组(行,列,值): " << endl;
    		for(int i = 0; i < num; i++)
    		{
    			cout << "(" << dat[i].line << ", " << dat[i].row << ", " << dat[i].item << ")" << endl;
    		}
    	}
    
    	friend bool TripADD(TripMN& A, TripMN& B, TripMN& C);    //加法 ,矩阵:A+B=C 友元
    															  //需要被传出去的才加&
    	friend bool TripXXX(TripMN& A, TripMN& B, TripMN& C);    //乘法法则
    
    };                                                            
    
    bool TripXXX(TripMN& A, TripMN& B, TripMN& C)
    {
    	int sum;
    	if (A.R != B.L)
    	{
    		return false;
    	}
    	else
    	{
    		for (int i = 1; i <= A.L; i++)
    		{
    			for (int j = 1; j <= B.R; j++)
    			{
    				sum = 0;
    				for (int k = 1; k <= A.R; k++)   //A.R==B.L
    				{
    					sum = A.get_Ttem(i, k) * B.get_Ttem(k, j) + sum;  //行列分别相加
    				}
    				if(sum!=0)
    				C.set_Item(i, j, sum);
    			}
    		}
    		return true;
    	}
    }
    
    bool TripADD(TripMN& A, TripMN& B, TripMN& C)
    {
    	if (A.L != B.L || B.L != C.L || A.R != B.R || B.R != C.R )
    	{
    		return false;   //检查行列是否相等,矩阵加法前提
    	}
    	else
    	{
    		for (int i = 0; i < A.L; i++)
    		{
    			for (int j = 0; j < A.R; j++)
    			{
    				int item = A.get_Ttem(i,j) + B.get_Ttem(i,j);  //将A,B矩阵值相加
    				//如果计算出来不为零,则插入矩阵之中
    				if (item != 0)
    				{
    					C.set_Item(i, j, item);
    				}
    			}
    		}
    		return true;
    	}
    }
    

    .cpp文件

    #include"三元组.h"
    
    void input(int m,int n, int num, TripMN& trip)     //初始化三元组
    {
    	int line, row, item;
    	for (int i = 1; i <= num; i++)
    	{
    		cout << "请依次输入,行,列,和非零元:";
    		cin >> line >> row >> item;
    		if (item != 0)
    		{
    			if(trip.set_Item(line, row, item)==ERROR)
    			{
    				cout << "行号列号不正确,或者三元组已满 !!!";
    				break;
    			}
    		}
    	}
    }
    
    
    int main()
    { 
    	int m, n, num;
    	cout << "请输入第(一)个矩阵A行数列数,非零元个数: ";
    	cin >> m;
    	cin >> n;
    	cin >> num;
    	int CL = m;     //乘法中C矩阵的行
    	TripMN A(m,n);     //类的人工初始化
    	input(m, n, num, A);    //创建一个矩阵
    	//trip.printTrip();
    	A.printMatrix();
    	cout << endl;
    
    	cout << "请输入第(二)个矩阵B行数列数,非零元个数: ";
    	cin >> m;
    	cin >> n;
    	cin >> num;
    	int CR = n;    //乘法中C矩阵的列
    	TripMN B(m, n);     //类的人工初始化
    	input(m, n, num, B);    //创建一个矩阵
    	//trip.printTrip();
    	B.printMatrix();
    	cout << endl;
    
    	TripMN C(CL,CR);
    	bool resurt = TripXXX(A, B, C);
    	if (resurt)
    	{
    		cout << "矩阵相乘后C:" << endl;
    		C.printMatrix();
    	}
    	else
    	{
    		cout << "矩阵不能相乘!!!" << endl;
    	}
    	return 0;
    }
    

    在这里插入图片描述

    展开全文
  • 稀疏矩阵乘法(C语言)

    万次阅读 2021-03-30 20:06:34
    代码: #include<stdio.h> #include<stdlib.h> #define MAXSIZE 1000 typedef struct{ int row;//第几行 ...//稀疏矩阵的行,列,非零元素的个数 }TSMatrix; void createTSMatrix(TSM.
  • 【问题描述】 ...编写程序实现用上述压缩存储方式输入的稀疏矩阵乘法稀疏矩阵最大为9*9。以压缩方式输出结果矩阵。行标和列标都从0开始计数。 0 0 0 10 0 3 10 2 0 0 0 1 0 2 0 0 3 1 2 2 3 1 0
  • 稀疏矩阵乘法

    千次阅读 2019-06-26 11:01:34
    1492.稀疏矩阵乘法 时限:1000ms 内存限制:10000K 总时限:3000ms 描述 计算两个稀疏矩阵乘法 输入 首先输入第一个矩阵的行数和列数,再输入该矩阵的三元组形式,以0 0 0结束  然后输入第二个矩阵的行数和列数...
  • 说明如果在矩阵中,多数的元素并没有资料,称此矩阵为稀疏矩阵(sparse matrix), 由于矩阵在程式中常使用二维阵列表示,二维阵列的大小与使用的记忆体空间成正比,如果多数的元素没有资料,则会造成记忆体空间的浪费...
  • 稀疏矩阵乘法

    2021-04-20 19:00:52
    title: 稀疏矩阵乘法 date: 2020-11-09 19:31:44 tags: 稀疏矩阵运算 categories: 数据结构 在本算法中,两个稀疏矩阵的特性都有用到 规定 规定以下变量名称,本文讲述 矩阵A × 矩阵B = 矩阵C 的运算过程 需要...
  • {//稀疏矩阵的转置,一个M*N的稀疏矩阵,转置为N*M的矩阵 int cnum[SIZE];//列非零元素的个数 int cpot[SIZE];//列的起始位置 int i,p; for(i=0;i;i++) { cnum[i]=0; cpot[i]=1; } tran_...
  • (五)1.1_稀疏矩阵乘法的快速运算

    万次阅读 多人点赞 2018-11-30 01:01:41
      有矩阵M和N,都是用三元组压缩存储,设计高效率算法求矩阵M*N得到的矩阵Q(也用三元组压缩存储). 二.思路分析 假设矩阵M*N=Q 如下 那么得到的矩阵Q有三行三列,第一列中的元素有这样的关系 所以我们可以...
  • 已结贴√问题点数:20回复次数:2 用三元组实现稀疏矩阵乘法!#include#include#define MAXSIZE 12500typedef struct{int i,j;int e;} Triple;typedef struct{Triple data[MAXSIZE+1];int mu,nu,tu;} TSMatrix;int...
  • 引入在计算机中图形的存储和表示...用上面的算法中,不论M(i,k)和N(k,j)的值是否为零,都要进行一次乘法运算,而实际上,这两者有一个值为零时,其乘积也为零。因此,在对稀疏矩阵进行运算时,若免去这种无效操作,将可大大的
  • 该软件包包括一个小型扩展库,该库具有自动分级支持,可优化稀疏矩阵运算。 该软件包当前包含以下方法: 所有包含的操作都适用于不同的数据类型,并且都针对CPU和GPU实施。 为了避免创建 ,此程序包仅通过将index和...
  • 稀疏矩阵,即含有少量非 0 元素的矩阵,如图 1 稀疏矩阵该矩阵中非 0 元素的数量比较少,与其使用普通方式将矩阵中的所有数据元素一一存储,不如只存储非 0 元素更节省内存空间,拿图 1 中矩阵来说,只需存储元素 3...
  • 稀疏矩阵相乘运算 一、目的 1.了解稀疏矩阵相乘运算特点 2.知道稀疏矩阵存储,创建,显示,转置方法 二、设计要求 1.问题描述 利用稀疏的特点进行存储和计算可大大节省存储空间,并实现稀疏矩阵相乘运算 2.需求分析 ...
  • 输入要求:稀疏矩阵的行、列和非零元素个数 以及每个非零元素在矩阵的位置 以三元组格式存储稀疏矩阵 输出要求:根据选项输出 稀疏矩阵的转置、加法、减法、乘法
  • 三元组形式的二维稀疏矩阵乘法运算
  • 用十字链表实现稀疏矩阵加法运算、稀疏矩阵减法运算、稀疏矩阵乘法运算
  • 用C++编写的稀疏矩阵乘法运算,稀疏矩阵采用十字链表存储及计算
  • 稀疏矩阵运算

    2017-03-14 22:48:22
    printf("输入稀疏矩阵A的行数,列数和非零元个数:"); scanf("%d %d %d",&A.m,&A.n,&A.t); for(k=1;k;k++) { printf("输入第%d个非0元素的行数,列数和值:",k); scanf("%d %d %d",&A.data[k].i,&A.data[k].j,&...
  • Matlab 矩阵运算

    2021-04-22 03:29:59
    Copyright 2008说明:这一段时间用Matlab做了LDPC码的性能仿真,过程中涉及了大量的矩阵运算,本文记录了Matlab中矩阵的相关知识,特别的说明了稀疏矩阵和有限域中的矩阵。Matlab的运算是在矩阵意义下进行的,这里所...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,514
精华内容 2,605
关键字:

稀疏矩阵的乘法运算