数据结构实验(矩阵的运算)

合集下载

数据结构实验五矩阵的压缩存储与运算学习资料

数据结构实验五矩阵的压缩存储与运算第五章矩阵的压缩存储与运算【实验目的】1. 熟练掌握稀疏矩阵的两种存储结构(三元组表和十字链表)的实现；2. 掌握稀疏矩阵的加法、转置、乘法等基本运算；3. 加深对线性表的顺序存储和链式结构的理解。

第一节知识准备矩阵是由两个关系（行关系和列关系）组成的二维数组，因此对每一个关系上都可以用线性表进行处理；考虑到两个关系的先后，在存储上就有按行优先和按列优先两种存储方式，所谓按行优先，是指将矩阵的每一行看成一个元素进行存储；所谓按列优先，是指将矩阵的每一列看成一个元素进行存储；这是矩阵在计算机中用一个连续存储区域存放的一般情形，对特殊矩阵还有特殊的存储方式。

一、特殊矩阵的压缩存储1. 对称矩阵和上、下三角阵若n阶矩阵A中的元素满足= （0≤i，j≤n-1 ）则称为n阶对称矩阵。

对n阶对称矩阵，我们只需要存储下三角元素就可以了。

事实上对上三角矩阵（下三角部分为零）和下三角矩阵（上三角部分为零），都可以用一维数组ma[0.. ]来存储A的下三角元素（对上三角矩阵做转置存储），称ma为矩阵A的压缩存储结构，现在我们来分析以下，A和ma之间的元素对应放置关系。

问题已经转化为：已知二维矩阵A[i，j]，如图5-1，我们将A用一个一维数组ma[k]来存储，它们之间存在着如图5-2所示的一一对应关系。

任意一组下标(i,j)都可在ma中的位置k中找到元素m[k]= ；这里：k=i(i+1)/2+j (i≥j)图5-1 下三角矩阵a00 a10 a11 a20 … an-1,0 … an-1,n-1k= 0 1 2 3 …n(n-1)/2 …n(n+1)/2-1图5-2下三角矩阵的压缩存储反之，对所有的k=0,1，2,…,n(n+1)/2-1，都能确定ma[k]中的元素在矩阵A中的位置（i,j）。

这里，i=d-1，（d是使sum= > k的最小整数），j= 。

2. 三对角矩阵在三对角矩阵中，所有的非零元素集中在以主对角线为中心的带内状区域中，除了主对角线上和直接在对角线上、下方对角线上的元素之外，所有其它的元素皆为零，见图5-3。

数据结构矩阵实验报告

一、实验目的和要求（1）掌握各种特殊矩阵如对称矩阵、上下三角矩阵和对角矩阵的压缩存储方法。

（2）掌握稀疏矩阵的各种存储结构以及基本运算实现算法。

（3）掌握广义表的递归特性、存储结构以及基本运算实现算法。

二、实验环境、内容和方法实验内容：①打开Visual C++6.0并输入实验指导书上的程序，并进行调试和运行。

②自行尝试编写第六个实验。

实验方法：（一）综合运用课本所学的知识，用不同的算法实现在不同的程序功能。

（二）结合指导老师的指导，解决程序中的问题，正确解决实际中存在的异常情况，逐步改善功能。

（三）根据实验内容，编译程序。

实验环境：Windows xp Visual C++6.0三、实验过程描述实验①以下是一个5*5阶的螺旋方阵。

设计一个程序输出该形式的n*n阶方阵。

1 2 3 4 516 17 18 19 615 24 25 20 714 23 22 21 813 12 11 10 9一、打开Visual C++6.0并输入如下程序#include <stdio.h>#define MaxLen 10void fun(int a[MaxLen][MaxLen],int n){int i,j,k=0,m;if (n%2==0)m=n/2;elsem=n/2+1;for (i=0;i<m;i++){for (j=i;j<n-i;j++){k++;a[i][j]=k;}for (j=i+1;j<n-i;j++){k++;a[j][n-i-1]=k;}for (j=n-i-2;j>=i;j--){k++;a[n-i-1][j]=k;}for (j=n-i-2;j>=i+1;j--){k++;a[j][i]=k;}}}void main(){int n,i,j;int a[MaxLen][MaxLen];printf("\n");printf("输入n(n<10):");scanf("%d",&n);fun(a,n);printf("%d阶数字方阵如下:\n",n);for (i=0;i<n;i++){for (j=0;j<n;j++)printf("%4d",a[i][j]);printf("\n");}printf("\n");}二、,编译并连接此程序，如图三、运行此程序，如图实验②假设n*n的稀疏矩阵A采用三元组表示，设计一个程序实现如下功能：（1）生成如下两个稀疏矩阵的三元组a和b：a:1 0 3 0 b: 3 0 0 00 1 0 0 0 4 0 00 0 1 0 0 0 1 00 0 1 1 0 0 0 2(2)输出a转置矩阵的三元组(3)输出a+b的三元组(4) 输出a*b的三元组一、输入如图所示程序#include <stdio.h>#define N 4typedef int ElemType;#define MaxSize 100typedef struct{ int r;int c;ElemType d;} TupNode;typedef struct{ int rows;int cols;int nums;TupNode data[MaxSize];} TSMatrix;void CreatMat(TSMatrix &t,ElemType A[N][N]){int i,j;t.rows=N;t.cols=N;t.nums=0;for (i=0;i<N;i++){for (j=0;j<N;j++)if (A[i][j]!=0){t.data[t.nums].r=i;t.data[t.nums].c=j;t.data[t.nums].d=A[i][j];t.nums++;}}}void DispMat(TSMatrix t){int i;if (t.nums<=0)return;printf("\t%d\t%d\t%d\n",t.rows,t.cols,t.nums);printf("\t------------------\n");for (i=0;i<t.nums;i++)printf("\t%d\t%d\t%d\n",t.data[i].r,t.data[i].c,t.data[i].d); }void TranMat(TSMatrix t,TSMatrix &tb){int p,q=0,v;tb.rows=t.cols;tb.cols=t.rows;tb.nums=t.nums;if (t.nums!=0){for (v=0;v<t.cols;v++)for (p=0;p<t.nums;p++)if (t.data[p].c==v){tb.data[q].r=t.data[p].c;tb.data[q].c=t.data[p].r;tb.data[q].d=t.data[p].d;q++;}}}int 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;while (i<a.nums && j<b.nums){if (a.data[i].r==b.data[j].r){if(a.data[i].c<b.data[j].c){c.data[k].r=a.data[i].r;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){c.data[k].r=b.data[j].r;c.data[k].c=b.data[j].c;c.data[k].d=b.data[j].d;k++;j++;}else{v=a.data[i].d+b.data[j].d;if (v!=0){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){c.data[k].r=a.data[i].r;c.data[k].c=a.data[i].c;c.data[k].d=a.data[i].d;k++;i++;}else{c.data[k].r=b.data[j].r;c.data[k].c=b.data[j].c;c.data[k].d=b.data[j].d;k++;j++;}c.nums=k;}return 1;}int value(TSMatrix c,int i,int j){int k=0;while (k<c.nums && (c.data[k].r!=i || c.data[k].c!=j)) k++;if (k<c.nums)return(c.data[k].d);elsereturn(0);}int MatMul(TSMatrix a,TSMatrix b,TSMatrix &c){int i,j,k,p=0;ElemType s;if (a.cols!=b.rows)return 0;for (i=0;i<a.rows;i++)for (j=0;j<b.cols;j++){s=0;for (k=0;k<a.cols;k++)s=s+value(a,i,k)*value(b,k,j);if (s!=0){c.data[p].r=i;c.data[p].c=j;c.data[p].d=s;p++;}}c.rows=a.rows;c.cols=b.cols;c.nums=p;return 1;}void main(){ElemType a1[N][N]={{1,0,3,0},{0,1,0,0},{0,0,1,0},{0,0,1,1}};ElemType b1[N][N]={{3,0,0,0},{0,4,0,0},{0,0,1,0},{0,0,0,2}};TSMatrix a,b,c;CreatMat(a,a1);CreatMat(b,b1);printf("a的三元组:\n");DispMat(a);printf("b的三元组:\n");DispMat(b);printf("a转置为c\n");TranMat(a,c);printf("c的三元组:\n");DispMat(c);printf("c=a+b\n");MatAdd(a,b,c);printf("c的三元组:\n");DispMat(c);printf("c=a*b\n");MatMul(a,b,c);printf("c的三元组:\n");DispMat(c);}二、程序运行结果如图实验③编写一个程序实现广义表的各种运算，并在此基本上设计一个程序完成如下功能：（1）建立广义表g=“(b,(b,a,(#),d),((a,b),c,((#))))”的链式存储结构；（2）输出广义表g的长度；（3）输出广义表g的深度；（4）输出广义表g的最大原子；一、输入如图所示程序#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct lnode{ int tag;union{ElemType data;struct lnode *sublist;}val;struct lnode *link;} GLNode;GLNode *CreatGL(char *&s){GLNode *h;char ch;ch=*s++;if (ch!='\0'){h=(GLNode *)malloc(sizeof(GLNode));if (ch=='('){h->tag=1;h->val.sublist=CreatGL(s);}else if (ch==')')h=NULL;else{h->tag=0;h->val.data=ch;}}else h=NULL;ch=*s++;if (h!=NULL)if (ch==',')h->link=CreatGL(s);elseh->link=NULL;return h;}int GLLength(GLNode *g){int n=0;g=g->val.sublist;while (g!=NULL){n++;g=g->link;}return n;}int GLDepth(GLNode *g){int max=0,dep;if (g->tag==0)return 0;g=g->val.sublist;if (g==NULL)return 1;while (g!=NULL){if (g->tag==1){dep=GLDepth(g);if (dep>max) max=dep;}g=g->link;}return(max+1);}void DispGL(GLNode *g){if (g!=NULL){if (g->tag==1){printf("(");if (g->val.sublist==NULL) printf("");else DispGL(g->val.sublist);}else printf("%c", g->val.data);if (g->tag==1) printf(")");if (g->link!=NULL){printf(",");DispGL(g->link);}}}void main(){GLNode *g;char *str="(b,(b,a,a),((a,b),c))";g=CreatGL(str);printf(" 广义表g:");DispGL(g);printf("\n");printf(" 广义表g的长度:%d\n",GLLength(g));printf(" 广义表g的深度:%d\n",GLDepth(g));printf("\n");}二、程序运行结果如图。

数据结构矩阵加法

数据结构矩阵加法
一、数据结构矩阵加法是什么呢？
嘿呀，宝子们！今天咱们来唠唠数据结构里的矩阵加法。

矩阵就像是一个方格阵，里面装着好多数字呢。

矩阵加法呢，可不是简单地把两个矩阵放在一块儿就完事儿啦。

它是要把对应的方格里面的数字相加哦。

比如说有矩阵A和矩阵B，A的第一行第一列的数字就要和B的第一行第一列的数字相加，得到新矩阵相应位置的数字。

二、怎么去做矩阵加法呢？
这就像是玩数字对对碰的游戏。

首先得保证两个矩阵的行数和列数是一样的。

要是不一样的话，就像两个人玩游戏，规则都不一样，那可没法玩加法这个游戏啦。

假设矩阵A是一个2行3列的矩阵，矩阵B也得是2行3列的。

然后就一个一个方格对着加呗。

就像给每个小方格里面的数字找个小伙伴，然后把它们凑一块儿。

三、矩阵加法在实际中有啥用呢？
这用处可大了去了。

在计算机图形学里，矩阵加法就像魔法一样。

比如说我们要把一个图形移动到另一个位置，就可以用矩阵来表示这个图形，然后通过矩阵加法来计算它移动后的新位置。

还有在物理学里，矩阵加法也能用来计算一些物理量的叠加呢。

就好比两个力作用在一个物体上，我们可以用矩阵来表示这两个力，然后用矩阵加法算出它们叠加后的效果。

概括来说呀，矩阵加法虽然看起来就是数字的相加，但是在很多领域都是超级重要的小能手呢。

它就像一把万能钥匙，能打开好
多不同领域的大门。

矩阵的乘法实验报告

一、实验目的1. 理解矩阵乘法的概念和运算规则。

2. 掌握矩阵乘法的编程实现方法。

3. 通过实验验证矩阵乘法的正确性。

二、实验环境1. 操作系统：Windows 102. 编程语言：Python3. 库：NumPy三、实验原理矩阵乘法是指两个矩阵相乘的运算。

设矩阵A为m×n的矩阵，矩阵B为n×p的矩阵，则它们的乘积C为一个m×p的矩阵。

矩阵乘法的运算规则如下：C[i][j] = Σ(A[i][k] B[k][j])，其中k为1到n的整数。

四、实验步骤1. 导入NumPy库。

```pythonimport numpy as np```2. 定义矩阵A和B。

```pythonA = np.array([[1, 2], [3, 4]])B = np.array([[5, 6], [7, 8]])```3. 计算矩阵A和B的乘积C。

```pythonC = np.dot(A, B)```4. 打印结果。

```pythonprint("矩阵A：")print(A)print("矩阵B：")print(B)print("矩阵C（A乘B）：")print(C)```五、实验结果与分析1. 运行实验程序，得到以下结果：```矩阵A：[[1 2][3 4]]矩阵B：[[5 6][7 8]]矩阵C（A乘B）：[[19 22][43 50]]```2. 分析结果：- 矩阵A为2×2的矩阵，矩阵B为2×2的矩阵，它们的乘积C为2×2的矩阵。

- 根据矩阵乘法的运算规则，我们可以计算出矩阵C的每个元素。

- 实验结果与理论计算相符，说明矩阵乘法的编程实现是正确的。

六、实验总结1. 本实验成功实现了矩阵乘法的编程，验证了矩阵乘法的正确性。

2. 通过实验，加深了对矩阵乘法概念和运算规则的理解。

3. NumPy库在矩阵运算方面具有强大的功能，为编程提供了便利。

数据结构课程设计报告---矩阵的运算

数据结构课程设计报告题目：专业：班级：学号：姓名：指导老师：时间：一、课程设计题目及所涉及知识点设计题目是“矩阵的运算”；所涉及的知识点主要是：1、利用数组的形式来储存数据，在main函数里面，实现对于数据的输入操作，利用switch语句进行选择来执行操作，利用for语句与do……while语句来实现功能的循环操作。

2、矩阵的加法、减法、乘法、数乘、转置的基本算法方式。

3、通过switch语句进行选择来执行操作，来实现每个算法的功能。

二、课程设计思路及算法描述设计思路：用程序实现矩阵能够完成矩阵的转置运算；矩阵的数乘运算；矩阵的加法运算；矩阵的减法运算；矩阵的乘法运算；这几种矩阵的简单的运算。

用数组把将要运算的矩阵储存起来，然后实现矩阵的这几种运算。

在main函数里面，来实现对于数据的输入操作，利用switch语句进行选择来执行操作，利用for语句来实现功能的循环操作。

算法：算法1：矩阵的转置运算；首先是把将要运算的矩阵存放在数组中，矩阵的转置运算，就是把你将要进行运算的A矩阵的行ar和列ac，把A矩阵的行ar作为B矩阵的bc，A矩阵的列ac作为B矩阵的br，这样得到的新矩阵B的行br和列bc就是矩阵A的转置。

算法如下：for(i=0;i<ar;i++)for(j=0;j<ac;j++)B[j][i]=A[i][j];算法2：矩阵的数乘运算；首先是把将要运算的矩阵存放在数组中，矩阵的数乘运算，就是实现用一个实数k 去A矩阵。

实数k去乘矩阵的每一行和每一列，得到的一个新的矩阵B，这样就解决了矩阵的数乘运算。

算法如下：for(i=0;i<ar;i++)for(j=0;j<ac;j++)B[i][j]=k*A[i][j];算法3：矩阵的加法运算；首先是把将要运算的矩阵存放在数组中，矩阵的加法运算，就是要实现A矩阵与B 矩阵进行加法运算。

事实上就是A矩阵的每一行ar与B矩阵的每一行br进行加法运算，而得到的一个新的矩阵C的每一行cr就是A矩阵的ar行与B矩阵的br行的和；A矩阵的每一列ac与B矩阵的每一列bc进行加法运算，而得到的一个新的矩阵C的每一列cc 就是A矩阵的ac列与B矩阵的bc列的和。

数据结构实验报告稀疏矩阵运算

数据结构实验报告稀疏矩阵运算实验目的：1.学习并理解稀疏矩阵的概念、特点以及存储方式。

2.掌握稀疏矩阵加法、乘法运算的基本思想和算法。

3.实现稀疏矩阵加法、乘法的算法，并进行性能测试和分析。

实验原理：稀疏矩阵是指矩阵中绝大多数元素为0的矩阵。

在实际问题中，有许多矩阵具有稀疏性，例如文本矩阵、图像矩阵等。

由于存储稀疏矩阵时，对于大量的零元素进行存储是一种浪费空间的行为，因此需要采用一种特殊的存储方式。

常见的稀疏矩阵的存储方式有三元组顺序表、十字链表、行逻辑链接表等。

其中，三元组顺序表是最简单直观的一种方式，它是将非零元素按行优先的顺序存储起来，每个元素由三个参数组成：行号、列号和元素值。

此外，还需要记录稀疏矩阵的行数、列数和非零元素个数。

稀疏矩阵加法的原理是将两个稀疏矩阵按照相同的行、列顺序进行遍历，对于相同位置的元素进行相加，得到结果矩阵。

稀疏矩阵乘法的原理是将两个稀疏矩阵按照乘法的定义进行计算，即行乘以列的和。

实验步骤：1.实现稀疏矩阵的三元组顺序表存储方式，并完成稀疏矩阵的初始化、转置、打印等基本操作。

2.实现稀疏矩阵的加法运算，并进行性能测试和分析。

3.实现稀疏矩阵的乘法运算，并进行性能测试和分析。

4.编写实验报告。

实验结果：经过实验测试，稀疏矩阵的加法和乘法算法都能正确运行，并且在处理稀疏矩阵时能够有效节省存储空间。

性能测试结果表明，稀疏矩阵加法、乘法的运行时间与非零元素个数有关，当非零元素个数较少时，运算速度较快；当非零元素个数较多时，运算速度较慢。

实验分析：稀疏矩阵的运算相对于普通矩阵的运算有明显的优势，可以节省存储空间和运算时间。

在实际应用中，稀疏矩阵的存储方式和运算算法都可以进行优化。

例如，可以采用行逻辑链接表的方式存储稀疏矩阵，进一步减少存储空间的占用；可以采用并行计算的策略加快稀疏矩阵的运算速度。

总结：通过本次实验，我深入学习了稀疏矩阵的概念、特点和存储方式，掌握了稀疏矩阵加法、乘法的基本思想和算法，并通过实验实现了稀疏矩阵的加法、乘法运算。

数据结构实验报告-魔方阵

数据结构与程序设计实验实验报告
哈尔滨工程大学
实验报告三
c. 如果按上述方法找到的位置已填入数据，则在同一列下一行填入下一个数字。

(3). 以3×3魔方阵为例，说明其填数过程，如下图所示。

三阶魔方阵的生成过程
由三阶魔方阵的生成过程可知，某一位置(x,y)的左上角的位置是(x-1,y-1),如果x-1≥0，不用调整，否则将其调整为x-1+m；同理，如果y-1≥0，不用调整，否则将其调整为y-1+m。

所以，位置(x,y)的左上角的位置可以用求模的方法获得，即：
x=(x-1+m)%m
y=(y-1+m)%m
如果所求的位置已经有数据了，将该数据填入同一列下一行的位置。

这里需要注意的是。

此时的x和y已经变成之前的上一行上一列了，如果想变回之前位置的下一行同一列，x需要跨越两行，y需要跨越一列，即：
x=(x+2)%m
printf("%d\t",a[i][j]);
printf("\n");
}
四、界面设计
程序需要获取魔方阵的阶数(包括错误判断)，输出结果，均在执行过程中给出提示。

五、运行测试与分析
1. 获取阶数并给出错误提示
2. 获取正确阶数，并输出结果
六、实验收获与思考
本次实验采用的数据结构为二维数组，在使用过程中巩固了学习的知识，在用C语言实现魔方阵算法时对C语言的使用更加熟悉。

七、附录（原程序）。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

cin>>x2[i][j];
cout<<"相乘后："<<endl;
//相乘运算
double **r=new double *[a1];
for(int i=0;i<a1;i++)
r[i]=new double[b2];
for(int q=0;q<a1;q++)
for(int w=0;w<b2;w++)
{
delete []x1[i];
delete []r[i];
}
for(int i=0;i<a2;i++)
delete []x2[i];
delete x1;x1=0;
delete x2;x2=0;
delete r;r=0;
}
算法的选择：switch(c)
{
case 1:Addition();break;
x2[i]=new double[b2];
cout<<"输入第二个矩阵：\n";
for(int i=0;i<a2;i++)
for(int j=0;j<b2;j++)
cin>>x2[i][j];
cout<<"相加后："<<endl;
矩阵的加法：for(int i=0;i<a1;i++)
{
for(int j=0;j<b1;j++)
3.倘若选择加（减）法，若两个矩阵的行、列数不相等的话，软件会报错
4.注意输入矩阵的每一个成员是要以空格（space）键隔开。
5.依次输入完两个矩阵成员后，按下回车键，结果将出现显示屏。
附录：
#include <iostream.h>
//矩阵加法
void Addition()
{
int a1,b1,a2,b2;
Multiplication()实现两个任意矩阵的乘法运算
Main()主函数
主要
矩阵的构建：int a1,b1,a2,b2;
double **x1,**x2;
cout<<"输入第一个行数，列数:";
cin>>a1>>b1;
cout<<"输入第二个行数，列数:";
cin>>a2>>b2;
if(a1!=a2 ||b1 !=b2)
cout<<"\t(1)矩阵加法\n\t(2)矩阵减法\n\t(3)矩阵乘法\n\t(0)退出"<<endl;
cout<<"***************************\n";
for(int i=0;i<a1;i++)
x1[i]=new double [b1]; //为x1的每个元素动态分配数组空间
cout<<"输入第一个矩阵：\n";
forห้องสมุดไป่ตู้int i=0;i<a1;i++)
for(int j=0;j<b1;j++)
cin>>x1[i][j];
//分配地址空间
x2=new double *[a2]; //x2[][]
{
r[q][w]=0;
for(int j=0;j<b1;j++)
r[q][w]+=x1[q][j]*x2[j][w];
}
//输出相乘后结果
for(int q=0;q<a1;q++)
{
for(int w=0;w<b2;w++)
{
cout<<r[q][w]<<"\t";
}
cout<<endl;
}
for(int i=0;i<a1;i++)
for(int i=0;i<a2;i++)
x2[i]=new double[b2];
cout<<"输入第二个矩阵：\n";
for(int i=0;i<a2;i++)
for(int j=0;j<b2;j++)
cin>>x2[i][j];
cout<<"相加后："<<endl;
//相加运算
for(int i=0;i<a1;i++)
for(int j=0;j<b1;j++)
cin>>x1[i][j];
x2=new double *[a2]; //x2[][]
for(int i=0;i<a2;i++)
x2[i]=new double[b2];
cout<<"输入第二个矩阵：\n";
for(int i=0;i<a2;i++)
for(int j=0;j<b2;j++)
{
cout<<"无法相加！"<<endl;return;
}
/**************分配地址空间********************/
x1=new double *[a1]; //x1[][]，动态分配指针数组
for(int i=0;i<a1;i++)
x1[i]=new double [b1]; //为x1的每个元素动态分配数组空间
if(b1!=a2)
{
cout<<"无法相乘！"<<endl;return;
}
x1=new double *[a1]; //x1[][]
for(int i=0;i<a1;i++)
x1[i]=new double[b1];
cout<<"输入第一个矩阵：\n";
for(int i=0;i<a1;i++)
cin>>x1[i][j];
x2=new double *[a2]; //x2[][]
for(int i=0;i<a2;i++)
x2[i]=new double[b2];
cout<<"输入第二个矩阵：\n";
for(int i=0;i<a2;i++)
for(int j=0;j<b2;j++)
cin>>x2[i][j];
{
r[q][w]=0;
for(int j=0;j<b1;j++)
r[q][w]+=x1[q][j]*x2[j][w];
}
//输出相乘后结果
for(int q=0;q<a1;q++)
{
for(int w=0;w<b2;w++)
{
cout<<r[q][w]<<"\t";
}
cout<<endl;
}
for(int i=0;i<a1;i++)
{
delete []x1[i];
delete []r[i];
}
for(int i=0;i<a2;i++)
delete []x2[i];
delete x1;x1=0;
delete x2;x2=0;
delete r;r=0;
}
int main()
{
int c=1;
while(c)
{
cout<<"***************************\n";
for(int j=0;j<b1;j++)
cin>>x1[i][j];
x2=new double *[a2]; //x2[][]
for(int i=0;i<a2;i++)
x2[i]=new double[b2];
cout<<"输入第二个矩阵：\n";
for(int i=0;i<a2;i++)
for(int j=0;j<b2;j++)
cin>>a2>>b2;
if(b1!=a2)
{
cout<<"无法相乘！"<<endl;return;
}
x1=new double *[a1]; //x1[][]
for(int i=0;i<a1;i++)
x1[i]=new double[b1];
cout<<"输入第一个矩阵：\n";
for(int i=0;i<a1;i++)
delete []x2[i];
}
delete x1;x1=0;
delete x2;x2=0;
}
//矩阵乘法
void Multiplication()
{