数据结构 C 从矩阵(二维数组)乘法到压缩矩阵的转置

最新推荐文章于 2024-06-11 19:56:37 发布
最新推荐文章于 2024-06-11 19:56:37 发布
阅读量190 收藏 1
点赞数
文章标签： c语言 数据结构 矩阵
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_66967137/article/details/124866496
版权

矩阵乘法

#include<stdio.h>
#include<malloc.h>

#define ROWS 5
#define COLUMNS 5
/*动态二维数组*/
typedef struct twoDArray{
	int rows;
	int columns;
	int** elements;
}twoDArray,*twoDArrayPtr;
/*静态二维数组*/ 
typedef struct twoDStaticArray{
	int rows;
	int columns;
	int element[ROWS][COLUMNS];
}twoDStaticArray,*twoDStaticArrayPtr;
/*初始化二维数组(需传2参，需返回值)*/
twoDArrayPtr initTwoDArray(int paraRows,int paraColumns){
	//内存分配+赋初值 
	twoDArrayPtr tempArray=(twoDArrayPtr)malloc(sizeof(struct twoDArray));
	tempArray->rows=paraRows;
	tempArray->columns=paraColumns;
	//给整个二维数分配行指针空间 
	tempArray->elements=(int**)malloc(paraRows*sizeof(int*));
	//给行指针分配元素空间 
	int i;
	for(i=0;i<paraRows;i++){
		tempArray->elements[i]=(int*)malloc(paraColumns*sizeof(int));
	}
	//返回初始化好了的数组
	return tempArray; 
} 
/*给数组赋随机值(需传三参)*/ 
void randomizeTwoDArray(twoDArrayPtr paraArray,int paraLowerBound,int paraUpperBound){
	int i,j;
	for(i=0;i<paraArray->rows;i++){
		for(j=0;j<paraArray->columns;j++){
			paraArray->elements[i][j]=rand()%(paraUpperBound-paraLowerBound)+paraUpperBound;
		}
	}
}
/*打印数组（需传参）*/
void printArray(twoDArrayPtr paraArray){
	int i,j;
	for(i=0;i<paraArray->rows;i++){
		for(j=0;j<paraArray->columns;j++){
			printf("%d, ",paraArray->elements[i][j]);
		}
		printf("\r\n");//使矩阵一行一行排列 
	}
}
/*矩阵乘（需传两参，需返回值）*/
twoDArrayPtr matrixMultiply(twoDArrayPtr matrix1,twoDArrayPtr matrix2){
	//判断给出矩阵能否相乘
	if(matrix1->columns!=matrix2->rows){
		printf("The given matrixs cannot multiply.\r\n");
		return NULL;
	} 
	//初始化结果数组 
	twoDArrayPtr resultPtr=initTwoDArray(matrix1->rows,matrix2->columns); 
	
	//计算 
	int i,j,k,sum;
	for(i=0;i<matrix1->rows;i++){
		for(j=0;j<matrix2->columns;j++){
			sum=0;
			for(k=0;k<matrix1->columns;k++){
				sum+=matrix1->elements[i][k]*matrix2->elements[k][j];
			}
			resultPtr->elements[i][j]=sum;
			printf("sum=%d, ",resultPtr->elements[i][j]);
		}
	}
	printf("\r\n");
	//返回结果数组的首地址
	return resultPtr;
}
/*测试*/
void twoDArrayTest(){
	twoDArrayPtr  matrix1,matrix2,matrix3;
	matrix1=initTwoDArray(3,2);
	randomizeTwoDArray(matrix1,1,5);
	printf("The first matrix is:\r\n");
	printArray(matrix1);
	
	matrix2=initTwoDArray(2,4);
	randomizeTwoDArray(matrix2,6,9);
	printf("The second matrix is:\r\n");
	printArray(matrix2);
	
	matrix3=matrixMultiply(matrix1,matrix2);
	printf("The result matrix is:\r\n");
	printArray(matrix3);
}
/*静态数组初始化*/
twoDStaticArrayPtr initTwoDStaticArray(){
	//内存分配和赋初值 
	twoDStaticArrayPtr resultPtr=(twoDStaticArrayPtr)malloc(sizeof(struct twoDStaticArray));
	resultPtr->rows=ROWS;
	resultPtr->columns=COLUMNS;
	//初始化 
	int i,j;
	for(i=0;i<resultPtr->rows;i++){
		for(j=0;j<resultPtr->columns;j++){
			resultPtr->element[i][j]=i*10+j;;
			//打印地址
			printf("(%d,%d):%d\r\n",i,j,&resultPtr->element[i][j]);
		}
	}
	//返回初始化静态数组
	return resultPtr;
}

int main(){
	twoDArrayTest();
	twoDStaticArrayPtr tempPtr=initTwoDStaticArray();
	return 0;
}

运行结果： 

The first matrix is:
6, 8,
7, 5,
6, 5,
The second matrix is:
9, 9, 10, 11,
11, 11, 10, 9,
sum=142, sum=142, sum=140, sum=138, sum=118, sum=118, sum=120, sum=122, sum=109, sum=109, sum=110, sum=111, The result matrix is:
142, 142, 140, 138,
118, 118, 120, 122,
109, 109, 110, 111,
(0,0):1775016
(0,1):1775020
(0,2):1775024
(0,3):1775028
(0,4):1775032
(1,0):1775036
(1,1):1775040
(1,2):1775044
(1,3):1775048
(1,4):1775052
(2,0):1775056
(2,1):1775060
(2,2):1775064
(2,3):1775068
(2,4):1775072
(3,0):1775076
(3,1):1775080
(3,2):1775084
(3,3):1775088
(3,4):1775092
(4,0):1775096
(4,1):1775100
(4,2):1775104
(4,3):1775108
(4,4):1775112

--------------------------------
Process exited after 0.06542 seconds with return value 0
请按任意键继续. . .

小实验：计算int，int*,int**的字节数

#include <stdio.h>
int main(){
    printf("int:%d \r\n",sizeof(int));
    printf("int*:%d \r\n",sizeof(int*));
    printf("int**:%d \r\n",sizeof(int**));
    return 0;
} 

 运行结果：

 结论：int占4个字节，int*和int**一样都占8个字节

压缩矩阵的转置

关于矩阵(二维数组)压缩：

  • 当矩阵中很多元素的值为零时，就不给零分配空间
  • 当矩阵中有很多值相同的元素时，只分配一个存储空间

关于稀疏矩阵压缩转置：

转置前M=                           

转置后T=

转置前：

顺序：2 3 5 6 4 7  （行优先），共7个非零值

存储：以2为例，它的行号i=0,列号 =0,值Value=2,可以存储为0 0 2如图所示

单个元素的存储结构
002
              单个元素的存储可以用三元组来表示：

 
压缩矩阵的存储表示

i

jk
002

0

23
205
216
304
327

                        整个压缩矩阵可以用以三元组为元素的一维数组来表示： 

转置后：

顺序：2 5 4 6 3 7 （行优先），共7个非零值

因此当我们想要通过压缩矩阵找到转置矩阵时我们需要考虑以下问题：

转置之后矩阵中元素的顺序不再是之前的顺序，怎么定位？

答：（1）根据转置前矩阵的列号j（即转置后矩阵的行号）来定位（下图中的3 1 2）

        （2）通过Offset记录转置后压缩矩阵的起始行号（下图中的0 3 5）

  •  左上方框(行有效值计数器)：记录原矩阵每一行有效值的个数（如j=0行有3个有效值(即非零值)）
  • 右上方框(偏移量)：记录转置矩阵对应的压缩矩阵行起始位置（以三元组为元素的数组的序号）
#include <stdio.h>
#include <malloc.h>
typedef int elem;
/*三元组*/
typedef struct Triple{
	int i;//非零值对应的行号 
	int j;//非零值对应的列号 
	elem e;//非零值的具体值 
}Triple,*TriplePtr;
/*压缩矩阵的三元组表示*/
typedef struct CompressedMatrix{
	int rows;//压缩前矩阵的行数 
	int columns;//压缩前矩阵的列数 
	int numElements;
	Triple* elements;//压缩后矩阵的三元组表示 
}CompressedMatrix,*CompressedMatrixPtr;

/*将paraData矩阵初始化为压缩矩阵*/
CompressedMatrixPtr initCompressedMatrix(int paraRows, int paraColumns, int paraElements, int** paraData){
	int i;
	CompressedMatrixPtr resultPtr = (CompressedMatrixPtr)malloc(sizeof(struct CompressedMatrix));
	resultPtr->rows = paraRows;
	resultPtr->columns = paraColumns;
	resultPtr->numElements = paraElements;//非零值的个数（也即等于压缩矩阵的三元组的个数） 
	resultPtr->elements = (TriplePtr)malloc(paraElements * sizeof(struct Triple));//给三元组分配空间 

	for(i = 0; i < paraElements; i ++){
		resultPtr->elements[i].i = paraData[i][0];//测试用：4*3 矩阵 
		resultPtr->elements[i].j = paraData[i][1];
		resultPtr->elements[i].e = paraData[i][2];
	}
	return resultPtr;
}

/*打印*/ 
void printCompressedMatrix(CompressedMatrixPtr paraPtr){
	int i;
	for(i = 0; i < paraPtr->numElements; i ++){
		printf("(%d, %d): %d\r\n", paraPtr->elements[i].i, paraPtr->elements[i].j, paraPtr->elements[i].e);
	}//Of for i
}// Of printCompressedMatrix

/*压缩矩阵的转置*/
CompressedMatrixPtr transposeCompressedMatrix(CompressedMatrixPtr paraPtr){
	
	int i, tempColumn, tempPosition;
	//为行有效值计数器分配空间 
	int *tempColumnCounts = (int*)malloc(paraPtr->columns * sizeof(int));//记录转置前的压缩矩阵每一列的非零值的个数 
	//为偏移量（压缩矩阵转置后行起始行号）分配空间 
	int *tempOffsets = (int*)malloc(paraPtr->columns * sizeof(int));//记录转置后压缩矩阵的行起始行号（保证压缩矩阵转置后通过该行号找到转置后的位置） 
	for(i = 0; i < paraPtr->columns; i ++){
		tempColumnCounts[i] = 0;//行有效值计数器初始化为0 
	}
	//为转置后的压缩矩阵分配空间、赋值 
	CompressedMatrixPtr resultPtr = (CompressedMatrixPtr)malloc(sizeof(struct CompressedMatrix));
	resultPtr->rows = paraPtr->columns;
	resultPtr->columns = paraPtr->rows;
	resultPtr->numElements = paraPtr->numElements;//有效值的个数 

	resultPtr->elements = (TriplePtr)malloc(paraPtr->numElements * sizeof(struct Triple));//分配存储转置后矩阵的有效值的三元组空间 
	
	//2.找offsets(偏移量).
	for(i = 0; i < paraPtr->numElements; i ++) {
		tempColumnCounts[paraPtr->elements[i].j] ++;
	}
	tempOffsets[0] = 0;
	for(i = 1; i < paraPtr->columns; i ++){
		tempOffsets[i] = tempOffsets[i - 1] + tempColumnCounts[i - 1];//转置后压缩矩阵的起始行号****（理解难点） 
		printf("tempOffsets[%d] = %d \r\n", i, tempOffsets[i]);
	}
	//3.根据转置后的压缩矩阵还原为正常矩阵 
	for(i = 0; i < paraPtr->numElements; i ++) {
		tempColumn = paraPtr->elements[i].j;
		tempPosition = tempOffsets[tempColumn];//通过偏移量(转置后压缩矩阵的起始行号)来寻(转置后有效值在转置矩阵的位置)址 
		resultPtr->elements[tempPosition].i = paraPtr->elements[i].j;
		resultPtr->elements[tempPosition].j = paraPtr->elements[i].i;
		resultPtr->elements[tempPosition].e = paraPtr->elements[i].e;

		tempOffsets[tempColumn]++;
	}
	return resultPtr;
}

/*T测试函数*/
void compressedMatrixTest(){
	CompressedMatrixPtr tempPtr1, tempPtr2;
	int i, j, tempElements;

	//创建一个4*3矩阵（分配好空间） 
	tempElements = 4;
	int** tempMatrix1 = (int**)malloc(tempElements * sizeof(int*));
	for(i = 0; i < tempElements; i ++){
		tempMatrix1[i] = (int*)malloc(3 * sizeof(int));
	}
	//为创建好的4*3矩阵赋初值
	int tempMatrix2[4][3] = {{0, 0, 2}, {0, 2, 3}, {2, 0, 5}, {2, 1, 6}};
	for(i = 0; i < tempElements; i ++){
		for(j = 0; j < 3; j ++) {
			tempMatrix1[i][j] = tempMatrix2[i][j];
		}
	}
	tempPtr1 = initCompressedMatrix(2, 3, 4, tempMatrix1);

	printf("After initialization.\r\n");
	printCompressedMatrix(tempPtr1);

	tempPtr2 = transposeCompressedMatrix(tempPtr1);
	printf("After transpose.\r\n");
	printCompressedMatrix(tempPtr2);
}

int main(){
	compressedMatrixTest();

	return 1;
}

 

西欢乐
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
[C语言] 0.5倍速讲解世纪大战 有趣的C语言玩法
m0_61998789的博客
07-17 742
新人新代码，不足之处还请多多关照
C语言 二维数组 malloc 矩阵加法 乘法 转置
12-11
C语言 实在 矩阵的乘法 加法 转置 各个子涵数都有通用性，内存的分配是使用二维数组动态 malloc 分配
【C语言】简单自定义棋盘大小实现三子棋
Ahaooooooo的博客
04-28 1686
文章目录一、浅谈思路和效果二、代码与解释1.测试页和头文件2.功能实现（1）菜单和游玩功能（2）初始化棋盘和打印棋盘功能（3）玩家回合和电脑回合功能（4）判断是否结束功能（5）最后展示一下 一、浅谈思路和效果 首先想通过一个简单的菜单，通过输入序号进入游戏。 在输入序号后，显示一个自定义大小的棋盘，用户通过输入序号位置，下好后电脑下，若谁先三点一线则获胜。 通过循环和switch实现菜单。 每个可下的位置通过数组定义为空，输入位置后通过数组改变值。 棋盘通过循环打印 电脑的输入通过随机值确认数组下标改变值
c语言实现简易版扫雷
qq_55783740的博客
05-06 351
这个小项目源自两个月前学数组的时候，由于觉得比较重要，想记录一下。 首先，大概的思路是要做出两个二维数组充当棋盘，一个用于后台储存雷的情况，一个用于打印给玩家玩游戏 那么第一步我们知道，需要声明两个二维数组，一个打印出来给用户看，一个自己深埋在心里。 第二步应该是要埋雷，这里我们可以定义几个数值去让玩家选择埋雷的数量。 第三步也就是最难的扫雷部分了，我的思路是，首先玩家先输入一个坐标，我们再对玩家输入的坐标找到对应藏雷的数组，若此坐标就是雷，则反馈玩家游戏结束，若不是雷，则计算周围九宫格的雷数，并以数字的形
数据结构 C 代码 二维数组、矩阵乘法与压缩矩阵的转置
weixin_62821452的博客
05-19 110
数据结构 C 代码 二维数组、矩阵乘法与压缩矩阵的转置 二维数组与矩阵乘法 定义 矩阵相乘最重要的方法是一般矩阵乘积。它只有在第一个矩阵的列数（column）和第二个矩阵的行数（row）相同时才有意义 [1] 。一般单指矩阵乘积时，指的便是一般矩阵乘积。一个m×n的矩阵就是m×n个数排成m行n列的一个数阵。由于它把许多数据紧凑地集中到了一起，所以有时候可以简便地表示一些复杂的模型，如电力系统网络模型。 示意图 注意事项 1、当矩阵A的列数（column）等于矩阵B的行数（row）时，A与B可以相乘。
二维数组 矩阵乘法 压缩矩阵的转置
m0_63288471的博客
05-19 340
一.二维数组 二维数组本质上是以数组作为数组元素的数组,即数组的数组。 二维数组就是一个有行和列的矩阵，每一行代表一个数组，即数组的数组； 每一行数组内元素所在的位置可以用行和列号来表示；动态数组 动态二维数组内存布局 1.定义 typedef struct TwoDArray{ int rows; int columns; int** elements; }TwoDArray,*TwoDArrayPtr; 2.初始化 //初始化 TwoDArrayPtr iniTwoDArr.
二维数组转置以及矩阵乘法运算问题
k_ys的博客
02-15 3115
问题一：二维数组转置问题； 代码如下： #include &amp;amp;lt;stdio.h&amp;amp;gt; #include &amp;amp;lt;stdlib.h&amp;amp;gt; /* run this program using the console pauser or add your own getch, system(&amp;quot;pause&amp;quot;) or input loop */ void
数据结构 C 代码 5: 二维数组与矩阵乘法&压缩矩阵的转置
qq_61649579的博客
05-19 173
学习目标：摆！ 学习指导：帆神的代码二维数组与矩阵乘法&压缩矩阵的转置 学习任务： 抄写代码 学习成果目录 1数据结构 C 代码 5.1: 二维数组与矩阵乘法 1.1全部代码 1.2测试结果 2数据结构 C 代码 5.2: 压缩矩阵的转置 2.1全部代码 2.2测试结果 代码说明： 1二维数组与矩阵乘法 1.1这里用二维数组表示矩阵. 1.2两种空间分配方案. 1.3矩阵的乘法复杂度为O(mnk...
数据结构与算法：9.二维数组（矩阵乘法）以及压缩矩阵的转置
tsswdqb的博客
05-20 168
文章目录二维数组（矩阵乘法）动态二维数组的定义静态二维数组的定义二维数组的初始化随机给二位数组一个数二维数组的打印矩阵相乘测试函数完整代码以及运行结果压缩矩阵的转置 二维数组（矩阵乘法） 动态二维数组的定义 // 动态二维数组的定义 typedef struct TwoDArray{ int rows; int columns; int** elements; } TwoDArray, *TwoDArrayPtr; 静态二维数组的定义 // 静态二维数组的定义 typedef struct Tw
二维数组与矩阵乘法与矩阵压缩
qq_62339421的博客
05-19 186
一、二维数组与矩阵乘法 矩阵乘法其实就是一个矩阵拿出一行，另一个矩阵拿出一列进行相乘，得出的值放进新的矩阵，新的矩阵大小为第一个矩阵的行数+第二个矩阵的列数 #include <stdio.h> #include <malloc.h> #include <stdlib.h> #define ROWS 4 #define COLUMNS 5 /** * 动态二维数组 定义1 */ typedef struct TwoDArray{ int rows; in
C#实现矩阵转置的方法
01-20
本文实例讲述了C#实现矩阵转置的方法。分享给大家供大家参考。具体如下： 1.转置函数 /// /// 求一个矩阵的转置矩阵 /// /// 矩阵 /// 转置矩阵 private static double[][] MatrixTranspose(double[][] matrix) {...
二维数组应用：转置、乘法（加减号法）
11-07
二维数 /* bo4-1.c 串采用定长顺序存储结构(由c4-1.h定义)的基本操作(14个) */ /* SString是数组，故不需引用类型。此基本操作包括算法4.2,4.3,4.5 */ Status StrAssign(SString T,char *chars) { /* 生成一个其...
Python使用min、max函数查找二维数据矩阵中最小、最大值的方法
12-24
本文实例讲述了Python使用min、max函数查找二维数据矩阵中最小、最大值的方法。分享给大家供大家参考，具体如下： 简单使用min、max函数来得到二维数据矩阵中的最大最小值，很简单，这是因为工作需要用到一个东西...
MATLAB矩阵与数组
04-11
矩阵是 MATLAB 中的一种特殊的数组，矩阵是二维的数值集合。矩阵的构造方式有： 1. 简单创建方法：使用 [ ]，逗号或空格隔开各元素，分号隔开各行，例如 [1,2;3,4]。 2. 构造特殊矩阵：例如 ones，zeros，eye，diag...
C语言从头学19——类型的显式转换
最新发布
m0_72128260的博客
06-11 330
介绍C语言中关于数据类型的显式转换。
C语言之argc、argv与main函数的传参
tmk1234567890的博客
06-11 657
C语言之argc、argv与main函数的传参
鸿蒙轻内核A核源码分析系列二 数据结构-位图操作
maniuT的博客
06-11 1040
位操作模块提供对32位无符号整数数值的bit位进行操作，bit位取值为0-31，以0开始计算，从左向右，第0位，第1位。。。第31位等。⑴处定义的宏如下，也就是十进制31。如果传入的比特位pos大于31，会通过逻辑与运算截断，只取低5位，确保不会大于31，避免溢出。⑵处定义的位图掩码全是1。在文件中定义了常用的位操作相关的宏。宏根据参数x计算出需要操作第几个状态字，由于计算状态字的使用的是UINTPTR，状态字可以是32位、也可以是64位。后文，我们默认以32位进行讲解。宏传入的参数是位操作的开始bit。
数据结构--第七章--树和二叉树
2302_80052051的博客
06-11 315
前序+中序可以确定一个二叉树；中序+后序可以确定一个二叉树。，将数据元素组织成层次结构，元素间属于。二叉树的定义是递归定义。
C语言二维数组矩阵运算
05-12
C语言中的二维数组可以被视为矩阵，因此可以对二维数组进行矩阵运算。常见的矩阵运算包括加法、减法、乘法、转置等。下面是一些基本的二维数组矩阵运算： 1. 矩阵加法：两个矩阵的加法需要满足矩阵的行数和列数相等...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值