数据结构矩阵的转置

合集下载

数据结构 严蔚敏 快速转置算法

数据结构 严蔚敏 快速转置算法

数据结构严蔚敏快速转置算法快速转置算法是一种常用的数据结构算法,它可以高效地将矩阵进行转置操作。

本文将介绍快速转置算法的原理及其实现过程,并通过实例进行说明。

1. 算法原理快速转置算法是基于矩阵的行优先存储方式的特点而设计的。

在行优先存储方式中,矩阵的元素按行存储在内存中,即连续存储。

而转置操作则是将矩阵的行变为列,列变为行。

快速转置算法通过改变矩阵的存储方式,从而实现高效的转置操作。

2. 算法实现快速转置算法的实现主要分为两个步骤:扫描矩阵和转置矩阵。

2.1 扫描矩阵对于行优先存储的矩阵,我们可以使用两个指针来扫描矩阵。

一个指针用于遍历矩阵的行,另一个指针用于遍历矩阵的列。

具体步骤如下:(1)初始化两个指针,分别指向矩阵的第一个元素。

(2)遍历矩阵的行和列,同时将对应的元素交换位置。

(3)如果指针到达矩阵的最后一行或最后一列,则停止扫描。

2.2 转置矩阵在扫描矩阵完成后,我们可以得到一个转置后的矩阵。

具体步骤如下:(1)创建一个新的矩阵,大小与原矩阵相反。

(2)将扫描得到的矩阵的行变为新矩阵的列,列变为新矩阵的行。

3. 算法示例为了更好地理解快速转置算法,下面给出一个示例。

假设有一个3x3的矩阵:1 2 34 5 67 8 9按照步骤2.1进行扫描,得到以下结果:1 4 72 5 83 6 9然后按照步骤2.2进行转置,得到最终的转置矩阵:1 2 34 5 67 8 9可以看出,经过快速转置算法的处理,原矩阵成功地被转置了。

4. 总结快速转置算法是一种高效的数据结构算法,它通过改变矩阵的存储方式,实现了矩阵的快速转置操作。

本文介绍了快速转置算法的原理及其实现过程,并通过一个示例进行了说明。

快速转置算法在实际应用中具有广泛的用途,能够提升数据处理的效率。

希望通过本文的介绍,读者能够更好地理解和应用快速转置算法。

矩阵转置

矩阵转置

下面就是(算式1)式中矩阵M的(5行6列共有)8个非零元素的三元组表示:
{ (1,1, 8), (1,3, 9) , (2,2,2) , (3,4,3) , (3,6,7) , (4,1,6) , (4,3,4) , (5,4,5)}
若以某种方式(以行为主或以列为主的顺序)将8个三元组排列起来,再加上一个表示矩阵M的行数,列数及非零元素的个数的特殊的三元组(5,6,8),则所形成的表就能唯一地确定稀疏矩阵。
5.快速转置算法程序:
void fastran(Spmatrix a,Spmatrix *b)
{ int k,p,q,col;
int num[10],pot[10];
b->m=a.n; b->n=a.m; b->t=a.t;
if (a.t!=0)
普通算法分析:按b.data中三元组的次序进行转置。也就是说,按照矩阵M的列序进行转置。显然,为了找到M中的每一列的所有的非零元素,需要对a.data从第1行起整个扫描一遍。由于a.data是以M的行序来存放每一个非零元素的,因此,这样得到的顺序恰好是b.data应有的顺序。其具体算法描述如下:
矩阵的转置运算是变换元素的位置,把位于(i, j)的元素换到(j, i)位置上。也就是说,把元素的行和列对换。所以一个m×n的矩阵M,它的转置矩阵是一个n×m的矩阵,且N[i,j]=M[j,i],其中,1≤i≤n,1≤j≤m。例如, (算式1)中的矩阵N就是矩阵M的转置矩阵,矩阵N也是一个稀疏矩阵,其非零元素的排列情况如表-1(b)所示。求矩阵M的转置矩阵N,实际上就是由表-1(a)求表-1(b)。
这比直接用二维数组表示矩阵的转置算法的时间量级O(m*n)要差。不难看出,此算法之所以耗费时间,问题在于其每形成转置矩阵的一行,都必须对a.data从头到尾扫描一遍。能否对a.data只扫描一次,又不引起元素的移动就能得到要求的b->data呢?为此,我们可使用另一种快速方法。

数据结构矩阵转置

数据结构矩阵转置

数据结构矩阵转置
数据结构中的矩阵转置指的是矩阵中元素位置的改变。

当矩阵中原来
横纵坐标对应的数据发生变化,而元素位置不变时就是矩阵的转置。

在矩
阵转置的过程中,列变行,行变列,维度保持不变。

矩阵转置的概念:
矩阵的转置是指将一个m*n矩阵A的元素按照Aij=Aji的规律进行重
新排列而成为另一个n*m矩阵B,它就是矩阵A的转置矩阵,表示为BT。

由矩阵转置的定义可以得出,矩阵转置的过程会使矩阵的行列发生变化,而维度保持不变,即原来m*n矩阵转置之后仍为n*m矩阵,这其实就
是将二维l矩阵的行列颠倒,看起来像是把矩阵(腾空间)旋转了90度。

矩阵转置的特性:
1.交换性:(A^T)^T=A
2.矩阵乘法中,AB和BA相等时:(AB)^T=B^TA^T
矩阵转置的实现方式:
1.暴力法:
采用暴力法实现矩阵转置,其步骤如下:
(1)申请n*m的空间,用来存储转置后的矩阵
(2)以行为单位,读取第i行的元素,不断存入转置后的第i列中
(3)依次完成全部元素的赋值
2.零判断法:
此种方式可减小重复赋值的次数,其步骤如下:(1)申请n*m的空间,用来存储转置后的矩阵(2)以行为单位。

矩阵原地转置 c语言

矩阵原地转置 c语言

矩阵原地转置 c语言矩阵是数学中的一种重要的概念,也是计算机科学中常见的数据结构。

矩阵由一组有限个数的数字或符号排列成的矩形阵列组成,它是一种能够在数学和计算机科学中广泛应用的工具。

矩阵的转置是指将矩阵的行变为列,列变为行的操作。

在实际应用中,经常会遇到需要对矩阵进行转置的情况,比如在图像处理、机器学习和统计学等领域。

为了高效地处理矩阵转置的需求,我们可以使用原地转置的方法。

原地转置的思想是在不使用额外的空间的情况下,直接修改原始矩阵的元素来实现转置操作。

这种方法在处理大规模矩阵时非常有用,因为它可以节省内存空间并提高算法的效率。

下面我将介绍一种基于C 语言的原地转置算法。

假设我们有一个n×m的矩阵,我们可以通过以下步骤来实现原地转置:1. 使用两个循环来遍历矩阵的每个元素。

外层循环控制行号,内层循环控制列号。

2. 在每一次循环中,交换当前元素和对应的转置元素的位置。

也就是说,将当前元素与矩阵中以当前元素的列号为行号、以当前元素的行号为列号的元素进行交换。

这样就能实现原地转置的效果。

通过这种方法,我们可以在不使用额外空间的情况下,将原始矩阵转置为转置矩阵。

这个原地转置的算法的时间复杂度为O(n×m),其中n和m分别为矩阵的行数和列数。

另外,这个算法的空间复杂度为O(1),也就是说,它不需要额外的空间来储存中间结果。

需要注意的是,在实际应用中,我们可能会遇到矩阵的大小超过计算机内存限制的情况。

这时候,我们可以使用分块转置的方法来处理大规模矩阵。

分块转置将矩阵分成若干个较小的块,对每个块进行原地转置,然后再对块内的元素进行交换,最终得到整个矩阵的转置结果。

通过这种方法,我们可以有效地处理大规模矩阵的转置需求。

总之,矩阵的原地转置是一种重要且常用的操作,它在数学和计算机科学中具有广泛的应用。

使用C语言可以非常方便地实现原地转置算法,并在处理大规模矩阵时提高算法的效率。

通过合理地应用原地转置算法,并结合分块转置等技术,我们能够高效地处理各种实际应用中的矩阵转置问题。

转置矩阵的符号

转置矩阵的符号

转置矩阵的符号【实用版】目录1.引言2.转置矩阵的定义和表示方法3.转置矩阵的性质4.转置矩阵的应用5.结论正文1.引言在数学和物理学中,矩阵是一种重要的数据结构,用于表示线性方程组、线性变换以及向量空间等概念。

矩阵的转置是矩阵操作中常见的一种,它涉及到矩阵的行和列的交换。

本文将介绍转置矩阵的符号、性质以及应用。

2.转置矩阵的定义和表示方法设矩阵 A 是一个 m×n 矩阵,其中 m 表示矩阵的行数,n 表示矩阵的列数。

矩阵 A 的转置记作 A^T,是一个 n×m 矩阵。

在 A^T 中,原矩阵 A 的行变为列,原矩阵 A 的列变为行。

具体表示如下:A = | a11 a12 a13 || a21 a22 a23 || a31 a32 a33 |A^T = | a11 a21 a31 || a12 a22 a32 || a13 a23 a33 |3.转置矩阵的性质转置矩阵具有以下几个性质:(1) 对于任意矩阵 A,其转置矩阵 A^T 的行数等于原矩阵 A 的列数,列数等于原矩阵 A 的行数。

(2) 矩阵 A 与其转置矩阵 A^T 的乘积等于单位矩阵:AA^T = A^T A = I,其中 I 表示单位矩阵。

(3) 矩阵 A 的逆矩阵与其转置矩阵互为逆矩阵:A^(-1) =(A^T)^(-1)。

(4) 转置矩阵的行列式等于原矩阵的行列式的相反数:|A^T| = -|A|。

4.转置矩阵的应用转置矩阵在实际应用中具有广泛的应用,例如:(1) 在线性代数中,求解线性方程组时,通过高斯消元法可以将增广矩阵转化为行最简矩阵,再通过转置操作可以得到列最简矩阵,从而简化计算过程。

(2) 在机器学习和数据挖掘领域,特征值分解是常用的方法。

在计算特征值分解时,矩阵的转置操作可以简化计算过程。

(3) 在计算机图形学中,矩阵的转置操作常用于将三维坐标系下的点投影到二维坐标系。

5.结论矩阵的转置操作是矩阵操作中常见的一种,它具有重要的性质和应用。

c语言转置矩阵 一维数组 不定义数组

c语言转置矩阵 一维数组 不定义数组

C语言中的转置矩阵、一维数组和不定义数组的操作是编程中常见的问题,通过合理的编程技巧和算法思路,可以实现对这些问题的高效解决。

在本篇文章中,将围绕这三个主题展开讨论,为读者提供相关知识和实用技巧。

一、C语言中的转置矩阵1. 转置矩阵的定义及作用在数学中,矩阵的转置是指将矩阵的行和列互换得到的新矩阵。

在实际编程中,对矩阵进行转置操作可以在一定程度上简化矩阵运算和数据处理,并满足特定的需求。

2. 转置矩阵的实现方法在C语言中,可以通过嵌套循环的方式遍历原始矩阵,并将元素按照新的行列顺序放置到新的矩阵中,从而实现矩阵的转置操作。

3. 转置矩阵的代码示例以下是一个简单的C语言代码示例,演示了如何实现一个转置矩阵的函数:```c#include <stdio.h>#define ROWS 3#define COLS 3void transposeMatrix(int original[ROWS][COLS], int transposed[COLS][ROWS]) {for (int i = 0; i < ROWS; i++) {for (int j = 0; j < COLS; j++) {transposed[j][i] = original[i][j];}}}int m本人n() {int originalMatrix[ROWS][COLS] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; int transposedMatrix[COLS][ROWS];transposeMatrix(originalMatrix, transposedMatrix);for (int i = 0; i < COLS; i++) {for (int j = 0; j < ROWS; j++) {printf("d ", transposedMatrix[i][j]);}printf("\n");}return 0;}```以上代码实现了一个简单的矩阵转置函数和主函数,能够将原始矩阵转置后输出新矩阵。

数据结构25:矩阵转置算法(三元组顺序表)

数据结构25:矩阵转置算法(三元组顺序表)

数据结构25:矩阵转置算法(三元组顺序表)矩阵的转置实际上就是将数据元素的⾏标和列标互换,即 T(i,j) = M(j,i) 。

例如:图1 矩阵的转置相应地,三元组表转变为:图2 三元组表矩阵的转置,经历了三个步骤:矩阵的⾏数 n 和列数 m 的值交换;将三元组中的i和j调换;转换之后的表同样按照⾏序(置换前的列序)为主序,进⾏排序;实现三元组的转换,重点在第三步,实现算法有两种。

普通算法普通算法的实现过程为:1. 将矩阵的⾏数和列数进⾏调换;2. 遍历表 a 的 j 列(查找 j 的值,从 1 ⼀直到未转置之前的矩阵的列数 m ),遍历的过程,就可以⾃动存储为表 b 的形式。

因为在表 a 中 i 列的数值是从⼩到⼤的,在根据 j 列由上到下的遍历时, i 列同样也是有序的。

实现代码:TSMatrix transposeMatrix(TSMatrix M, TSMatrix T){ //⾏和列置换 T.m = M.n; T.n = M.m; T.num = M.num; if (T.num) { int q = 0; //依次遍历M矩阵的列(从1开始),的遍历的过程中将⾏标和列标置换,得到置换后的三元表T for (int col=1; col<=M.m; col++) { for (int p=0; p<M.num; 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].data = M.data[p].data; q++; } } } } return T;}此算法的时间复杂度关键在于嵌套的两个 for 循环,时间复杂度为O(m*num),和矩阵的列数以及⾮ 0 元素的个数的乘积成正⽐,如果稀疏矩阵的⾮ 0 元素很多的情况,使⽤这个算法,虽然⼀定程度上节省了空间,但是时间复杂度会很⾼。

矩阵转置的概念

矩阵转置的概念

矩阵转置的概念矩阵转置的概念矩阵是数学中一个重要的概念,它是由若干行和若干列组成的二维数组。

在实际应用中,经常需要对矩阵进行一些操作,如矩阵加法、矩阵乘法等。

其中一个常见的操作就是矩阵转置。

一、什么是矩阵转置?矩阵转置是指将一个m×n的矩阵A的行和列互换,得到一个n×m的新矩阵B,即B[i][j] = A[j][i]。

例如,对于以下3×2的矩阵A:1 23 45 6其转置后得到2×3的新矩阵B:1 3 52 4 6二、为什么需要进行矩阵转置?1. 简化运算:在某些情况下,对于某个问题来说,使用转置后的矩阵可以更加方便地进行运算。

2. 程序实现:在程序实现中,有些算法需要使用到转置后的矩阵。

三、如何计算矩阵转置?对于一个m×n的矩阵A,其转置后得到一个n×m的新矩阵B。

可以通过以下方式计算矩阵转置:1. 遍历原矩阵:对于原矩阵A中的每一个元素A[i][j],将其赋值给新矩阵B中的B[j][i]。

2. 使用公式计算:对于原矩阵A中的每一个元素A[i][j],可以使用公式B[j][i] = A[i][j]计算转置后的新矩阵B。

四、矩阵转置的性质1. 转置后的转置等于原矩阵:即(A^T)^T = A。

2. 转置后的逆矩阵等于原矩阵的逆矩阵的转置:即(A^-1)^T =(A^T)^-1。

3. 线性变换下的转置:对于线性变换T(x),其在标准正交基下对应着一个m×n的矩阵A。

则其转置在标准正交基下对应着一个n×m的矩阵A^T,且有(T(x))^T = T(x^T)。

五、应用实例1. 线性代数中常用到的向量内积可以通过向量转为列向量和行向量,再进行点乘得到。

2. 在图像处理中,常使用卷积运算。

而卷积运算可以看做是将一个滤波器(卷积核)在图像上滑动,将每个位置上的像素值与滤波器对应位置上的系数相乘并求和得到新的像素值。

而这个滤波器可以看做是一个矩阵,因此需要对其进行转置后再进行卷积运算。

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

/* c1.h (程序名) */#include<string.h>#include<ctype.h>#include<malloc.h> /* malloc()等*/#include<limits.h> /* INT_MAX等*/#include<stdio.h> /* EOF(=^Z或F6),NULL */#include<stdlib.h> /* atoi() */#include<io.h> /* eof() */#include<math.h> /* floor(),ceil(),abs() */#include<process.h> /* exit() *//* 函数结果状态代码*/#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1/* #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行*/ typedef int Status; /* Status是函数的类型,其值是函数结果状态代码,如OK等*/ typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE *//* c5-2.h 稀疏矩阵的三元组顺序表存储表示*/#define MAXSIZE 100 /* 非零元个数的最大值*/typedef struct{int i,j; /* 行下标,列下标*/ElemType e; /* 非零元素值*/}Triple;typedef struct{Triple data[MAXSIZE+1]; /* 非零元三元组表,data[0]未用*/int mu,nu,tu; /* 矩阵的行数、列数和非零元个数*/}TSMatrix;/* bo5-2.c 三元组稀疏矩阵的基本操作,包括算法5.1(9个) */Status CreateSMatrix(TSMatrix *M){ /* 创建稀疏矩阵M */int i,m,n;ElemType e;Status k;printf("请输入矩阵的行数,列数,非零元素数:");scanf("%d,%d,%d",&(*M).mu,&(*M).nu,&(*M).tu);(*M).data[0].i=0; /* 为以下比较顺序做准备*/for(i=1;i<=(*M).tu;i++)do{printf("请按行序顺序输入第%d个非零元素所在的行(1~%d),列(1~%d),元素值:",i,(*M).mu,(*M).nu);scanf("%d,%d,%d",&m,&n,&e);k=0;if(m<1||m>(*M).mu||n<1||n>(*M).nu) /* 行或列超出范围*/k=1;if(m<(*M).data[i-1].i||m==(*M).data[i-1].i&&n<=(*M).data[i-1].j) /* 行或列的顺序有错*/k=1;}while(k);(*M).data[i].i=m;(*M).data[i].j=n;(*M).data[i].e=e;}return OK;}void DestroySMatrix(TSMatrix *M){ /* 销毁稀疏矩阵M */(*M).mu=0;(*M).nu=0;(*M).tu=0;}void PrintSMatrix(TSMatrix M){ /* 输出稀疏矩阵M */int i;printf("%d行%d列%d个非零元素。

\n",M.mu,M.nu,M.tu);printf("行列元素值\n");for(i=1;i<=M.tu;i++)printf("%2d%4d%8d\n",M.data[i].i,M.data[i].j,M.data[i].e);}Status CopySMatrix(TSMatrix M,TSMatrix *T){ /* 由稀疏矩阵M复制得到T */(*T)=M;return OK;}int comp(int c1,int c2) /* 另加*/{ /* AddSMatrix函数要用到*/if(c1<c2)i=1;else if(c1==c2)i=0;elsei=-1;return i;}Status AddSMatrix(TSMatrix M,TSMatrix N,TSMatrix *Q){ /* 求稀疏矩阵的和Q=M+N */Triple *Mp,*Me,*Np,*Ne,*Qh,*Qe;if(M.mu!=N.mu)return ERROR;if(M.nu!=N.nu)return ERROR;(*Q).mu=M.mu;(*Q).nu=M.nu;Mp=&M.data[1]; /* Mp的初值指向矩阵M的非零元素首地址*/Np=&N.data[1]; /* Np的初值指向矩阵N的非零元素首地址*/Me=&M.data[M.tu]; /* Me指向矩阵M的非零元素尾地址*/Ne=&N.data[N.tu]; /* Ne指向矩阵N的非零元素尾地址*/Qh=Qe=(*Q).data; /* Qh、Qe的初值指向矩阵Q的非零元素首地址的前一地址*/while(Mp<=Me&&Np<=Ne){Qe++;switch(comp(Mp->i,Np->i)){case 1: *Qe=*Mp;Mp++;break;case 0: switch(comp(Mp->j,Np->j)) /* M、N矩阵当前非零元素的行相等,继续比较列*/{case 1: *Qe=*Mp;Mp++;break;case 0: *Qe=*Mp;Qe->e+=Np->e;if(!Qe->e) /* 元素值为0,不存入压缩矩阵*/Qe--;Mp++;Np++;break;case -1: *Qe=*Np;Np++;}break;case -1: *Qe=*Np;Np++;}}if(Mp>Me) /* 矩阵M的元素全部处理完毕*/while(Np<=Ne){Qe++;*Qe=*Np;Np++;}if(Np>Ne) /* 矩阵N的元素全部处理完毕*/while(Mp<=Me){Qe++;*Qe=*Mp;Mp++;}(*Q).tu=Qe-Qh; /* 矩阵Q的非零元素个数*/return OK;}Status SubtSMatrix(TSMatrix M,TSMatrix N,TSMatrix *Q){ /* 求稀疏矩阵的差Q=M-N */int i;for(i=1;i<=N.tu;i++)N.data[i].e*=-1;AddSMatrix(M,N,Q);return OK;}Status MultSMatrix(TSMatrix M,TSMatrix N,TSMatrix *Q){ /* 求稀疏矩阵的乘积Q=M*N */int i,j,h=M.mu,l=N.nu,Qn=0;/* h,l分别为矩阵Q的行、列值,Qn为矩阵Q的非零元素个数,初值为0 */ ElemType *Qe;if(M.nu!=N.mu)return ERROR;(*Q).mu=M.mu;(*Q).nu=N.nu;Qe=(ElemType *)malloc(h*l*sizeof(ElemType)); /* Qe为矩阵Q的临时数组*/ /* 矩阵Q的第i行j列的元素值存于*(Qe+(i-1)*l+j-1)中,初值为0 */for(i=0;i<h*l;i++)*(Qe+i)=0; /* 赋初值0 */for(i=1;i<=M.tu;i++) /* 矩阵元素相乘,结果累加到Qe */for(j=1;j<=N.tu;j++)if(M.data[i].j==N.data[j].i)*(Qe+(M.data[i].i-1)*l+N.data[j].j-1)+=M.data[i].e*N.data[j].e;for(i=1;i<=M.mu;i++)for(j=1;j<=N.nu;j++)if(*(Qe+(i-1)*l+j-1)!=0){Qn++;(*Q).data[Qn].e=*(Qe+(i-1)*l+j-1);(*Q).data[Qn].i=i;(*Q).data[Qn].j=j;}free(Qe);(*Q).tu=Qn;return OK;}Status TransposeSMatrix(TSMatrix M,TSMatrix *T){ /* 求稀疏矩阵M的转置矩阵T。

算法5.1 */int p,q,col;(*T).mu=M.nu;(*T).nu=M.mu;(*T).tu=M.tu;if((*T).tu){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;}}return OK;}/* main5-2.c 检验bo5-2.c的主程序*/#include"c1.h"typedef int ElemType;#include"c5-2.h"#include"bo5-2.c"void main(){TSMatrix A,B,C;printf("创建矩阵A: ");CreateSMatrix(&A);PrintSMatrix(A);printf("由矩阵A复制矩阵B: ");CopySMatrix(A,&B);PrintSMatrix(B);DestroySMatrix(&B);printf("销毁矩阵B后:\n");PrintSMatrix(B);printf("创建矩阵B2:(与矩阵A的行、列数相同,行、列分别为%d,%d)\n",A.mu,A.nu);CreateSMatrix(&B);PrintSMatrix(B);printf("矩阵C1(A+B): ");AddSMatrix(A,B,&C);PrintSMatrix(C);DestroySMatrix(&C);printf("矩阵C2(A-B): ");SubtSMatrix(A,B,&C);PrintSMatrix(C);DestroySMatrix(&C);printf("矩阵C3(A的转置): ");TransposeSMatrix(A,&C);PrintSMatrix(C);DestroySMatrix(&A);DestroySMatrix(&B);DestroySMatrix(&C);printf("创建矩阵A2: ");CreateSMatrix(&A);PrintSMatrix(A);printf("创建矩阵B3:(行数应与矩阵A2的列数相同=%d)\n",A.nu);CreateSMatrix(&B);PrintSMatrix(B);printf("矩阵C5(A*B): ");MultSMatrix(A,B,&C);PrintSMatrix(C);DestroySMatrix(&A); DestroySMatrix(&B); DestroySMatrix(&C); }。

相关文档
最新文档