问题描述

将稀疏矩阵A的非零元以行序为主序的顺序存于一维数组V中，并用二维数组B表示A中的相应元素是否为零元素，例如：

 



 

可用          和     表示。

编程实现上述表示法的矩阵加法运算。

输入格式

首先输入两个整数n和m，为矩阵维数，然后输入两个矩阵的值B1、V1和B2、V2。

输出格式

输出矩阵运算结果B、V。

样例输入

3 4

1 0 0 1

0 1 0 0

1 0 0 0

15 22 -6 9

0 1 1 0

0 1 1 0

1 0 0 1

3 2 6 2 -5 8

样例输出

1 1 1 1

0 0 1 0

1 0 0 1

15 3 2 22 2 4 8

#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 100
#define MAXLENGTH 10000
int main(){
	int i,j;
	int n,m;
	int p=0, q=0, r=0;	//做加法的下标 
	int count1 = 0;		//记录非零元个数 
	int count2 = 0;
	int tmp;
	int B1[MAXSIZE][MAXSIZE];
	int B2[MAXSIZE][MAXSIZE];
	int B[MAXSIZE][MAXSIZE] = {0};
	int V1[MAXLENGTH];
	int V2[MAXLENGTH];
	int V[MAXLENGTH] = {0};
	scanf("%d %d", &n, &m);
	//输入矩阵 
	for(i=0; i<n; i++){
		for(j=0; j<m; j++){
			scanf("%d", &tmp);
			if(tmp == 1)
				count1 ++;
			B1[i][j] = tmp;
		}
	}
	for(i=0; i<count1; i++){
		scanf("%d", &V1[i]); 
	}
	for(i=0; i<n; i++){
		for(j=0; j<m; j++){
			scanf("%d", &tmp);
			if(tmp == 1)
				count2 ++;
			B2[i][j] = tmp;
		}
	}
	for(i=0; i<count2; i++){
		scanf("%d", &V2[i]); 
	}
	//做加法
	for(i=0; i<n; i++){
		for(j=0; j<m; j++){
			if(B1[i][j] == 1 && B2[i][j] == 0){
				B[i][j] = 1;
				V[p] = V1[q];
				p++;
				q++; 
			}else if(B1[i][j] == 0 && B2[i][j] == 1){
				B[i][j] = 1;
				V[p] = V2[r];
				p++;
				r++; 
			}else if(B1[i][j] == 1 && B2[i][j] == 1){
				tmp = V1[q] + V2[r];
				q++; r++;
				if(tmp != 0){
					B[i][j] = 1;
					V[p] = tmp;
					p++; 
					
				}
			}
		}
	}
	//输出
	for(i=0; i<n; i++){
		for(j=0; j<m; j++){
			printf("%d ", B[i][j]);
		}
		printf("\n");
	} 
	i=0;
	while(1){
		if(V[i] == 0)
			break;
		printf("%d ", V[i]);
		i++;
	} 
	return 0;
} 

 

最近在学习机器人运动控制学,用到了矩阵运算,并用C语言实现之

首先声明该代码在Ubuntu18.04下运行通过, 如若在windows下运行失败请考虑编译器版本问题
一个矩阵最基本的有行数line,列数row和 行数乘以列数个数据(row*line), 所以用一个最基本的结构体变量来表示一个矩阵;

矩阵的结构体:
typedef struct 
{
	int row,line;			//line为行,row为列
	double *data;
}Matrix;

这样在创建一个矩阵的时候只需要分配row,line和data的内存就好.

然后…好像也没啥好说的… 直接根据所学矩阵的基本运算只是写代码就好…
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

double value[] = {1,2,3,4,5,6,7,8,9};
double value2[] = {9,8,7,6,5,4,3,2,1};

typedef struct 
{
	int row,line;		//line为行,row为列
	double *data;
}Matrix;

Matrix* InitMatrix(Matrix *matrix,int row,int line);		//初始化矩阵
void ValueMatrix(Matrix *matrix,double *array);				//给一个矩阵赋值
int SizeMatrix(Matrix *matrix);								//获得一个矩阵的大小
void FreeMatrix(Matrix *matrix);							//释放一个矩阵
void CopyMatrix(Matrix *matrix_A, Matrix *matrix_B);		//复制一个矩阵的值
void PrintMatrix(Matrix *matrix);							//打印一个矩阵

//矩阵的基本运算
Matrix* AddMatrix(Matrix *matrix_A,Matrix *matrix_B);		//矩阵的加法
Matrix* MulMatrix(Matrix *matrix_A,Matrix *matrix_B);		//矩阵的乘法
void TransMatrix(Matrix *matrix);			//条件为方阵

int main(int argc,char* argv[])
{
	Matrix *matrix1 = InitMatrix(matrix1,3,3);
	Matrix *matrix2 = InitMatrix(matrix2,3,3);

	ValueMatrix(matrix1,value);
	// CopyMatrix(matrix1,matrix2);	//复制赋值
	ValueMatrix(matrix2,value2);

	printf("矩阵1 乘以 矩阵2: \n");
	Matrix *matrix3 = MulMatrix(matrix1,matrix2);	//乘法
	PrintMatrix(matrix3);	
	printf("矩阵1 加上 矩阵2: \n");
	Matrix *matrix4 = AddMatrix(matrix1,matrix2);	//加法
	PrintMatrix(matrix4);
	printf("矩阵1进行转置: \n");
	TransMatrix(matrix1);					//转置
	PrintMatrix(matrix1);
	
	return 0;
}

Matrix* InitMatrix(Matrix *matrix,int row,int line)				//初始化一个矩阵
{
	if (row>0 && line>0)
	{
		matrix = (Matrix*)malloc(sizeof(Matrix));
		matrix->row = row;
		matrix->line = line;
		matrix->data = (double*)malloc(sizeof(double)*row*line);
		memset(matrix->data,0,sizeof(double)*row*line);
		return matrix;
	}
	else 
		return NULL;
} 

void ValueMatrix(Matrix *matrix,double *array) 		//给矩阵赋值
{
	if (matrix->data != NULL)
	{
		memcpy(matrix->data, array, matrix->row*matrix->line*sizeof(double));
	}
}

int SizeMatrix(Matrix *matrix)
{
	return matrix->row*matrix->line;
}

void FreeMatrix(Matrix *matrix)
{
	free(matrix->data);		//释放掉矩阵的data存储区
	matrix->data = NULL;
	printf("释放成功\n");
}

void CopyMatrix(Matrix *matrix_A, Matrix *matrix_B)
{
	matrix_B->row = matrix_A->row;
	matrix_B->line = matrix_A->line;
	memcpy(matrix_B->data, matrix_A->data, SizeMatrix(matrix_A)*sizeof(double));
}

void PrintMatrix(Matrix *matrix)
{
	for (int i=0;i<SizeMatrix(matrix);i++)
	{
		printf("%lf\t", matrix->data[i]);
		if ((i+1)%matrix->line == 0)
			printf("\n");
	}
			
}
//加法
Matrix* AddMatrix(Matrix *matrix_A,Matrix *matrix_B)
{
	if (matrix_A->row == matrix_B->row && matrix_A->line == matrix_B->line)
	{
		Matrix *matrix_C = InitMatrix(matrix_C,matrix_A->row,matrix_A->line);
		for (int i=0;i<matrix_A->line;i++)
		{
			for (int j=0;j<matrix_A->row;j++)
			{
				matrix_C->data[i*matrix_C->row + j] = \
				matrix_A->data[i*matrix_A->row + j] + matrix_B->data[i*matrix_A->row + j];
			}
		}
		return matrix_C;
	}
	else 
	{
		printf("不可相加\n");
		return NULL;
	}
}

//乘法
Matrix* MulMatrix(Matrix *matrix_A,Matrix *matrix_B)
{
	if (matrix_A->row == matrix_B->line)		//列==行
	{
		Matrix *matrix_C = InitMatrix(matrix_C,matrix_B->row,matrix_A->line);
		// matrix_C->line = matrix_A->line;		//A行
		// matrix_C->row = matrix_B->row;			//B列
		for (int i=0;i<matrix_A->row;i++)
		{
			for (int j=0;j<matrix_B->line;j++)
			{
				for (int k=0;k<matrix_A->line;k++)
				{
					matrix_C->data[i*matrix_C->line + j] += \
					matrix_A->data[i*matrix_A->line + k] * matrix_B->data[k*matrix_B->row + j];
				}
			}
		}
		return matrix_C;
	}
	else
	{
		printf("不可相乘\n");
		return NULL;
	}
}

//矩阵转置
void TransMatrix(Matrix *matrix)			//条件为方阵
{
	if (matrix->row == matrix->line)
	{
		Matrix *matrixTemp = InitMatrix(matrixTemp, matrix->row,matrix->line);       	//创建一个临时矩阵
		CopyMatrix(matrix,matrixTemp);	//将目标矩阵的data复制给临时矩阵

		for (int i=0;i<matrix->row;i++)
		{
			for (int j=0;j<matrix->line;j++)
			{
				matrix->data[i*matrix->row + j] = matrixTemp->data[j*matrix->row + i];
			}
		}
	}
	else
	{
		printf("转置的矩阵必须为方阵\n");
	}
}


恩…都是代码…尽情享用吧!

Matrix_hub

矩阵运算库--C语言

##The lib of Matrix operation for C language. (矩阵运算库--C语言)

Author: Amoiensis

Email: Amoiensis@outlook.com

Data:2020.02.12

下载地址：

https://github.com/Amoiensis/Matrix_hub/releases/tag/v1.4

【点击下载🔗】

具体代码和信息 见链接：

https://github.com/Amoiensis/Matrix_hub

具体应用：

Optimization-Algorithm(最优化算法)：https://github.com/Amoiensis/Optimization-Algorithm

具体：

Folder_--_lib_.lib文件_+_.h文件

Folder_--_code_.c文件_+_.h文件


CONTENT

####（操作-函数）

操作
			
OPERATION
			
func_NAME
		
生成矩阵
			
generation
			
Matrix_gen
		
复制矩阵
			
copy
			
Matrix_copy
		
乘法
			
multiply
			
M_mul
		
加减法
			
add/sub
			
M_add_sub
		
矩阵显示
			
print
			
M_print
		
单位矩阵(生成)
			
identity_matrix(gen)
			
M_I
		
矩阵基本变换
			
matrix_element_teransf
			
M_E_trans
		
基本变换矩阵
			
Element_trans2Matrix
			
Etrans_2_Matrix
		
基本变换矩阵的逆矩阵
			
inv_Element_trans2Matrix
			
Etrans_2_Inverse
		
上三角化
			
Upper_triangular_transformation
			
M_Uptri_
		
上三角化(求逆用)
			
Upper_triangular_transformation_for_Inverse
			
M_Uptri_4inv
		
下三角化
			
Lower_triangular_transformation
			
M_Lowtri_
		
下三角化(求逆用)
			
Lower_triangular_transformation_for_Inverse
			
M_Lowtri_4inv
		
对角矩阵求逆
			
Matrix_Inv_for_Dia_matrix
			
M_Dia_Inv
		
对角化
			
Diagonalization
			
M_Diatri_
		
求逆
			
Matrix_Inverse
			
M_Inverse
		
矩阵行(列)调换
			
Swap_Line
			
M_Swap
		
转置
			
Transpose
			
M_T
		
切取部分矩阵
			
Cut_out_part_of_Matrix
			
M_Cut
		
释放内存
			
free_mempry_of_Matrix
			
M_free
		
迹
			
trace
			
M_tr
		
行列式
			
Determinant
			
M_det
		
填充
			
Full
			
M_full
		
范数
			
Norm
			
M_norm
		
矩阵数乘
			
Number Multiplication
			
M_numul
		
(使用矩阵)填充矩阵
			
Full with matrix
			
M_matFull
		
生成(全)零矩阵
			
Generation Zeros Matrix
			
M_Zeros
		
生成(全)一矩阵
			
Generation Ones Matrix
			
M_Ones
		
寻找矩阵对应值位置(列优先)
			
Find position with the value in Matrix
			
M_find
		
矩阵按列求和/向量元素和
			
Matrix column sum / Vector element sum
			
M_sum
		
矩阵按列最小行位置/向量最小元素位置
			
Matrix minimum row position / Vector minimum element position
			
M_min
		
矩阵按列最大行位置/向量最大元素位置
			
Matrix maximum row position / Vector maximum element position
			
M_max
		
矩阵各列指定行位置的值
			
The value of the specified row position

			of each column of the matrix
			
M_minax_val
		
矩阵各位置与给定值比较(返回矩阵,取值0/1)
			
Compare each position of the matrix with the given value

			(return the matrix, the value is 0/1)
			
M_logic_equal
		
两矩阵对应位置逻辑运算
			
Logical operation of corresponding positions of two matrices
			
M_logic
		
矩阵对应元素乘/除
			
Multiply / divide corresponding elements of matrix
			
M_pmuldiv
		
矩阵批量赋值(使用矩阵传递)
			
Matrix batch assignment (using matrix transfer)
			
M_setval
		
矩阵对矩阵，对各行进行数乘
			
Matrix Number Multiplication (using matrix transfer)
			
M_numul_m ()
		
帮助
			
Help File
			
help
		
[更新说明 Matrix Hub v1.4]


	
新增 help() 函数，可以输入各函数名称，查看具体使用方法；如，help("help")、help("Matrix_gen")、help("README")、help("Update")，等;
	
	

	
新增函数“M_numul_m ()”，用于矩阵数乘 ，矩阵对于矩阵进行操作，各行对应数乘 ；
	
	

	
将原 M_matFull() 函数中，最左侧，和最上侧，row_up和column_left取值从“0”设置为“1（HEAD）”;
	
	

	
修正原代码中"Matirx"的误写，修正为"Matrix";
	
code:Demo (Matrix_hub)

/*
%% IMFORMATION
%% MATRIX_HUB
% Author: Xiping Yu
% Email:Amoiensis@outlook.com
% Github: https://github.com/Amoiensis/Matrix_hub
% Data: 2020.02.12 
% Case: Matrix Operation 
% Dtailed: the code_file of Matrix_hub
*/ 

#include <stdio.h>
#include <stdlib.h>
#include "matrix.h"


int main(int argc, char *argv[]) {
// Matrix
	/*...[具体矩阵，详见github中demo文件]*/
	
//	Operation
	// 乘法 
	Matirx*  mat_3 = M_mul(mat_2,mat_1);
	M_print(mat_3);	
	// 加减法
	Matirx*  mat_diff = M_add_sub(1,mat_21,1,mat_21b);
	M_print(mat_diff);	
	// 单位矩阵 
	M_print(M_I(5));
	// 初等变换to矩阵 
	Matirx* mat_4 = Etrans_2_Matrix(&_Etrans_,5,_ROW_);
	M_print(mat_4);
	Matirx* mat_5 = Etrans_2_Inverse(&_Etrans_,5,_ROW_);
	M_print(mat_5);
	// 上三角变换
	Uptri_struct* _Uptri_ =  M_Uptri_(mat_21);
	M_print(_Uptri_->trans_matrix);
	M_print(_Uptri_->Uptri_matrix );
	// 下三角变换
	Lowtri_struct* _Lowtri_ =  M_Lowtri_(mat_21);
	M_print(_Lowtri_->Lowtri_matrix);
	M_print(_Lowtri_->trans_matrix);
	// 对角化
	Dia_struct* _Dia_ = M_Diatri_(mat_21);
	M_print(_Dia_->trans_leftmatrix);
	M_print(_Dia_->Diatri_matrix);
	M_print(_Dia_->trans_rightmatrix);
	// 矩阵求逆 
	Matirx* _mat_inv = M_Inverse(mat_21);
	M_print(_mat_inv );
	// 行列交换
	M_Swap(_mat_inv,1,2,_ROW_);
	M_print(_mat_inv); 
	// 切割部分
	Matirx* _mat_cut = M_Cut(_mat_inv,_END_,_END_,2,3);
	M_print(_mat_cut);
	// 转置
	Matirx* _mat_T = M_T(_mat_inv);
	M_print(_mat_T);
	// 迹
	MATRIX_TYPE _tr_mat = M_tr(_mat_inv);
	printf("Tr(Matrix_%x) = %.4lf\n",_mat_inv,_tr_mat);
	// 行列式
	MATRIX_TYPE _det_mat = M_det(_mat_inv);
	printf("Det(Matrix_%x) = %.4lf\n",_mat_inv,_det_mat);
	
	
// Application
	// 解线性方程
		// mat_A*x = mat_b
	Matirx* _mat_result = M_mul(M_Inverse(mat_A),mat_b);
	M_print(_mat_result);
	
// Others
	M_free(_mat_T);

// Help 函数
	help("help"); 
	help("Update"); 
	
//	system("pause"); 
	return 0;
}


ATTENTION

Please feel free to contact with me for any questions, thank you!

Don't spread the files without permission!

所有文件仅仅供学习交流！

[PTA]矩阵运算（C语言）
矩阵运算
给定一个n×n的方阵，本题要求计算该矩阵除副对角线、最后一列和最后一行以外的所有元素之和。副对角线为从矩阵的右上角至左下角的连线。
输入格式:
输入第一行给出正整数n（1<n≤10）；随后n行，每行给出n个整数，其间以空格分隔。
输出格式:
在一行中给出该矩阵除副对角线、最后一列和最后一行以外的所有元素之和。
输入样例:
4
2 3 4 1
5 6 1 1
7 1 8 1
1 1 1 1

输出样例:
35

作者只是一个小白，目前才学习到for循环，这是我用自己已学知识解出来的题目。

题目给出一个整数n，然后输入一个n*n的矩形，然后求和。

这个矩形我们可以通过两个for循环来实现，第一个for循环

for (i = 1; i <= n; i++)代表的是行，它会在第n行的时候跳出循环。

第二个for循环

for (l = 1; l <= n; l++)代表的是每一行的数值，它会在每行输入的第n个数值后跳出循环，也就是象征着列。

矩阵有了，然后就是求和，在我的双for循环中，每输入一个数值，就会记录入我的数值和s中，题目要求了在这个矩阵中，最后一列和最后一行还有副对角线不计入和中，那么，我们就设一个if()进行条件筛选，满足(i = = n)最后一行，(l = = n)最后一列，(l = = n - i + 1)副对角线这三个条件的将不会进行操作，反之，不满足这三个条件的则计入数值和s中，最后在双for循环外，输出整数s。
#include <stdio.h>

int main()
{
	int n, i, l, m, s=0;
	scanf("%d", &n);
	for (i = 1; i <= n; i++)
	{
		for (l = 1; l <= n; l++)
		{
			scanf("%d ", &m);
			if (l == n || l == n - i + 1||i==n)
            {
                
            }
			else
				s = s + m;
		}
	}
	printf("%d",s);
	return 0;
}