C语言实现简单的矩阵运算

原创 已于 2024-12-02 20:48:46 修改 · 673 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#矩阵 #线性代数 #c语言
于 2024-11-29 17:15:51 首次发布

        最近实验室的一个项目，要求使用c语言，并且需要使用大量的向量、矩阵计算。于是自己突然来了兴趣，想自己用c语言复现一下matlab中各种简单的矩阵运算（包括+、-、.*、*、./、inv、cross、各种按位操作的初等函数计算、行列交换、切片、粘贴、赋值等）。代码分享在如下网盘连接。（2024/12/2修改）

通过网盘分享的文件：catlab
链接: https://pan.baidu.com/s/1GeP76rTOiaJSEkDfWss0Tg?pwd=1111 提取码: 1111
--来自百度网盘超级会员v5的分享

1.定义矩阵

        无论是矩阵，还是向量，都能通过mat来定义。注意，只接受double的矩阵。

        定义矩阵可以通过手动赋值、对角阵、单位阵、全0矩阵、随机数矩阵赋值。

（1）手动赋值：

        mat* make_mat(int row, int column, double data[]);

double arr[25] = { 0.814723686393179,	0.905791937075619,	0.126986816293506,	0.913375856139019,	0.632359246225410,
0.0975404049994095,	0.278498218867048,	0.546881519204984,	0.957506835434298,	0.964888535199277,
0.157613081677548,	0.970592781760616,	0.957166948242946,	0.485375648722841,	0.800280468888800,	
0.141886338627215,	0.421761282626275,	0.915735525189067,	0.792207329559554,	0.959492426392903,
0.655740699156587,	0.0357116785741896,	0.849129305868777,	0.933993247757551,	0.678735154857774 };
mat * mat1 = make_mat(5, 5, arr);

        由于我的mat是通过结构体+指针实现，所以要通过mat* 来定义。同时，在定义时，需要输入row和coluumn。输入的数组是一维的，make_mat函数会有限排布第一列，然后第二列……（就像matlab那样）

（2）对角阵：

        mat* _diag(int n, double data[]);

	double diag_num[5] = { 1, 2, 3, 4, 5 };
	mat* mat1 = _diag(5,diag_num);

        通过对角阵定义矩阵，需要输入行数（列数），以及对角线元素组成的数组。

（3）单位阵：

        mat* _eye(int n)；

mat* mat1 = _eye(5);

（4）全0矩阵：

        mat* _zeros(int n);

mat* mat1 = _zeros(5);

（5）随机数矩阵：

        mat* _rand(int row, int column, int max_num, int min_num);

mat* mat1 = _rand(5, 5,-2,4);

        前两个变量表示几行几列，第三个和第四个变量表示最小和最大范围（但因为写的时候不小心，把他写成了int，想用double边界话可能需要配合后续的矩阵乘法）

（6）标准正态初始化：

        mat* _randn(int row, int column);

mat* mat2 = _randn(5, 5);

        两个变量表示行和列。

（7）矩阵复制：

        mat* copy_mat(mat* mat1);

	mat* mat1 = _rand(5, 5,-2,4);
	mat* mat2 = copy_mat(mat1);

2.矩阵展示

（1）打印矩阵

        由于我的矩阵全是用链表写的，在IDE里看也会比较麻烦，因此写了void print_mat(mat* mat1);函数。用法如下：

	mat* mat1 = _rand(5, 5,-2,4);
	print_mat(mat1);

         打印出的效果为：

1.846065     1.355144     0.473281     1.493942     1.046419
2.161199     3.540025     2.194891     1.440657     1.652150
3.642201     -1.685965     3.414228     0.209052     0.146428
2.223273     -0.796594     -1.569506     -0.918546     3.016877
-0.502335     -1.694388     2.877346     -1.076754     -1.518052

（2）行列信息

        可以通过结构体的.row 和 .column查看行列数量。

	mat* mat1 = _rand(5, 4,-2,4);
	printf("%d %d", mat1->row, mat1->column);

3.二元运算

（0）简介

        所有的二元运算，都实现了广播机制(即，一个矩阵可以加上一个行或者列与其相等的向量)。同时，为了能让矩阵与常数的运算和矩阵和矩阵的运算能在相同的函数执行（但c语言本身不支持重载），所以在一些二元运算中加入了参数ismat。二元运算的第二个参数是mat，就填1，是double就填0.不支持填写int或者float。

        由于定义时用到了void*,所以传递double时，需要取其地址。

（1）加法

       

mat* _add(mat* mat1, void* Mat2, int is_mat);

        可以理解为matlab中矩阵加法。mat1必须是mat，但Mat2可以是mat或者是double(注：向量就是行或者列为1的矩阵)。

        eg:

	mat* mat1 = _randn(2, 2); 
	mat* mat2= _randn(2, 2);
	mat* mat3 = _randn(1, 2);
	double m4 = 0.2;
	print_mat(mat1);
	print_mat(mat2);
    print_mat(mat3);
	print_mat(_add(mat1 , mat2,1));
	print_mat(_add(mat1, mat3, 1));
	print_mat(_add(mat1, &m4, 0));

        结果：

-0.756292     -0.172082
2.056440     1.413671

0.917249     2.019091
0.377900     -2.635316

0.888399     0.507530

0.160957     1.847009
2.434340     -1.221646

0.132107     0.335448
2.944839     1.921200

-0.556292     0.027918
2.256440     1.613671

（2）减法

mat* _minus(mat* mat1, void* Mat2, int is_mat);

        eg:

	mat* mat1 = _randn(2, 2); 
	mat* mat2= _randn(2, 2);
	mat* mat3 = _randn(1, 2);
	double m4 = 0.2;
	print_mat(mat1);
	print_mat(mat2);
	print_mat(mat3);
	print_mat(_minus(mat1 , mat2,1));
	print_mat(_minus(mat1, mat3, 1));
	print_mat(_minus(mat1, &m4, 0));

        结果：

-0.583496     1.025506
0.162181     -0.950831

0.250197     1.230143
0.301872     0.043749

-0.448799     0.375249

-0.833694     -0.204637
-0.139690     -0.994580

-0.134697     0.650257
0.610981     -1.326079

-0.783496     0.825506
-0.037819     -1.150831

（3）乘法

        乘法分为按元素相乘、矩阵乘法、叉乘。按元素相乘逻辑同加、减；矩阵乘法就是线性代数中的矩阵乘法。叉乘含有长度为2的向量的叉乘和长度为3的向量的叉乘。

（a）按元素乘法

mat* _mult(mat* mat1, void* Mat2, int is_mat);

        eg:

	mat* mat1 = _randn(2, 2); 
	mat* mat2= _randn(2, 2);
	mat* mat3 = _randn(1, 2);
	double m4 = 0.2;
	print_mat(mat1);
	print_mat(mat2);
	print_mat(mat3);
	print_mat(_mult(mat1 , mat2,1));
	print_mat(_mult(mat1, mat3, 1));
	print_mat(_mult(mat1, &m4, 0));

        结果：

-0.454299     0.031380
1.922025     -2.636598

1.433463     -0.072987
-0.150606     -0.838485

-0.913822     0.183255

-0.651221     -0.002290
-0.289469     2.210747

0.415149     0.005751
-1.756389     -0.483169

-0.090860     0.006276
0.384405     -0.527320

（b）矩阵乘法

mat* mult(mat* mat1, mat* mat2);

        需要注意的是，两种乘法的函数名只有“_”的区别。

        eg:

	mat* mat1 = _randn(2, 2); 
	mat* mat2= _randn(2, 2);
	print_mat(mat1);
	print_mat(mat2);
	print_mat(mult(mat1 , mat2));

        结果：

-0.902194     0.001637
-0.626816     1.224671

0.083982     -0.773807
-0.360299     0.791817

-0.076358     0.699420
-0.493889     1.454750

（c） 叉乘

        叉乘实现的是二维向量和三维向量的叉乘。前者返回一个1*1的mat，后者返回一个三维向量。虽然这里叫做向量，但其实定义的是1*2、1*3或者2*1、3*1的mat.

mat* _cross(mat* mat1, mat* mat2);

        eg_1:3维列向量叉乘

	double v3_1[3] = { 5, 3, 6 };
	double v3_2[3] = { 1,3,9.5 };
	mat* mat1 = make_mat(3,1, v3_1);
	mat* mat2 = make_mat(3, 1, v3_2);
	print_mat(mat1);
	print_mat(mat2);
	print_mat(_cross(mat1, mat2));

        结果1：

5.000000
3.000000
6.000000

1.000000
3.000000
9.500000

10.500000
-41.500000
12.000000

        eg_2：二维行向量叉乘

	double v3_1[3] = { 5, 3 };
	double v3_2[3] = { 1,3 };
	mat* mat1 = make_mat(1,2, v3_1);
	mat* mat2 = make_mat(1, 2, v3_2);
	print_mat(mat1);
	print_mat(mat2);
	print_mat( _cross(mat1,mat2));

        运行结果：

5.000000     3.000000

1.000000     3.000000

12.000000

（4）除法

        除法分成了两个部分：按元素除法和求线性方程组。矩阵求逆在后续

（a）按元素除法

mat* _divide(mat* mat1, void* Mat2, int is_mat);

        eg：

	mat* mat1 = _randn(2, 2);
	mat* mat2 = _randn(2, 2);
	mat* mat3 = _randn(1, 2);
	double m4 = 0.2;
	print_mat(mat1);
	print_mat(mat2);
	print_mat(mat3);
	print_mat(_divide(mat1, mat2, 1));
	print_mat(_divide(mat1, mat3, 1));
	print_mat(_divide(mat1, &m4, 0));

        结果：

-0.979410     0.141544
0.793791     0.367250

-0.420435     0.420065
0.146240     0.803229

-0.858580     0.255745

2.329514     0.336958
5.428000     0.457217

1.140732     0.553459
-0.924540     1.436001

-4.897049     0.707721
3.968957     1.836248

（b）解线性方程组

        采用的算法：列主高斯-乔丹消去。

mat* _solve(mat* mat1, mat* mat2);

        eg:

	double A[4] = { 5, 3, 6, 2 };
	double b[2] = { 8, 9 };
	mat* mat1 = make_mat(2,2,A);
	mat* mat2 = make_mat(2, 1, b);
	print_mat(mat1);
	print_mat(mat2);
	print_mat(_solve(mat1, mat2));

        结果：

5.000000     6.000000
3.000000     2.000000

8.000000
9.000000

4.750000
-2.625000

4.按元素的初等函数

        包括如下函数：

mat* _pow(mat* mat1, int p);
mat* _exp(mat* mat1);
mat* _log(mat* mat1);
mat* _log10(mat* mat1);
mat* _sin(mat* mat1);
mat* _cos(mat* mat1);
mat* _tan(mat* mat1);
mat* _asin(mat* mat1);
mat* _acos(mat* mat1);
mat* _atan(mat* mat1);
mat* _abs(mat* mat1);

        这里实现了幂函数、指数函数、对数函数（10和e为底），三角、反三角、绝对值。

未完待续……

5.一元矩阵运算、操作

（0）简介

        这一部分包括了：矩阵求逆、转置、计算行列式、行列交换

（1）矩阵求逆

        采用的算法为列主高斯-乔丹消去。函数不自带检测条件数的功能，可能因此报错。

mat* _inv(mat* mat1);

        eg:

	double arr[4] = { -5, 3 ,5.4 ,2};
	mat* mat1 = make_mat(2, 2, arr);
	print_mat(mat1);
	print_mat(_inv(mat1));

        结果：

-5.000000     5.400000
3.000000     2.000000

-0.076336     0.206107
0.114504     0.190840

        matlab计算结果：

   -0.0763    0.2061
    0.1145    0.1908

（2）转置

        声明：

mat* _trans(mat* mat1);

        eg:

	double arr[4] = { -5, 3 ,5.4 ,2};
	mat* mat1 = make_mat(2, 2, arr);
	print_mat(mat1);
	print_mat(_trans(mat1));

        结果：

-5.000000     5.400000
3.000000     2.000000

-5.000000     3.000000
5.400000     2.000000

（3）行列式计算

        行列式计算分为两步：第一步，进行LU分解；第二步，提取U对角阵元素并连乘。

（a）LU分解

        LU分解的声明为：

mat_m1_m2* _LU(mat* mat1);

        返回的结果为mat_m1_m2* 类。可以通过.m1获取L矩阵，.m2获取U矩阵。

        eg:

	double arr[25] = { 0.814723686393179,	0.905791937075619,	0.126986816293506,	0.913375856139019,	0.632359246225410,
	0.0975404049994095,	0.278498218867048,	0.546881519204984,	0.957506835434298,	0.964888535199277,
	0.157613081677548,	0.970592781760616,	0.957166948242946,	0.485375648722841,	0.800280468888800,
	0.141886338627215,	0.421761282626275,	0.915735525189067,	0.792207329559554,	0.959492426392903,
	0.655740699156587,	0.0357116785741896,	0.849129305868777,	0.933993247757551,	0.678735154857774 };
	mat* mat1 = make_mat(5, 5, arr);
	mat_m1_m2* ans = _LU(mat1);
	print_mat(mat1);
	print_mat(ans->m1);
	print_mat(ans->m2);
	print_mat(mult(ans->m1, ans->m2));

        结果：

0.814724     0.097540     0.157613     0.141886     0.655741
0.905792     0.278498     0.970593     0.421761     0.035712
0.126987     0.546882     0.957167     0.915736     0.849129
0.913376     0.957507     0.485376     0.792207     0.933993
0.632359     0.964889     0.800280     0.959492     0.678735

1.000000     0.000000     0.000000     0.000000     0.000000
1.111778     1.000000     0.000000     0.000000     0.000000
0.155865     3.126510     1.000000     0.000000     0.000000
1.121087     4.987539     2.353907     1.000000     0.000000
0.776164     5.228788     2.239765     0.810083     1.000000

0.814724     0.097540     0.157613     0.141886     0.655741
0.000000     0.170055     0.795362     0.264015     -0.693326
0.000000     0.000000     -1.554106     0.068174     2.914614
0.000000     0.000000     0.000000     -0.844122     -3.203886
0.000000     0.000000     0.000000     0.000000     -0.137606

0.814724     0.097540     0.157613     0.141886     0.655741
0.905792     0.278498     0.970593     0.421761     0.035712
0.126987     0.546882     0.957167     0.915736     0.849129
0.913376     0.957507     0.485376     0.792207     0.933993
0.632359     0.964889     0.800280     0.959492     0.678735

  （b）获取对角线元素

        通过如下函数能够获取矩阵的对角线元素,结果为列向量：

mat* _get_diag(mat* mat1);

        eg:

	double arr[25] = { 0.814723686393179,	0.905791937075619,	0.126986816293506,	0.913375856139019,	0.632359246225410,
	0.0975404049994095,	0.278498218867048,	0.546881519204984,	0.957506835434298,	0.964888535199277,
	0.157613081677548,	0.970592781760616,	0.957166948242946,	0.485375648722841,	0.800280468888800,
	0.141886338627215,	0.421761282626275,	0.915735525189067,	0.792207329559554,	0.959492426392903,
	0.655740699156587,	0.0357116785741896,	0.849129305868777,	0.933993247757551,	0.678735154857774 };
	mat* mat1 = make_mat(5, 5, arr);
	print_mat(mat1);
	print_mat(_get_diag(mat1));

        结果：

0.814724     0.097540     0.157613     0.141886     0.655741
0.905792     0.278498     0.970593     0.421761     0.035712
0.126987     0.546882     0.957167     0.915736     0.849129
0.913376     0.957507     0.485376     0.792207     0.933993
0.632359     0.964889     0.800280     0.959492     0.678735

0.814724
0.278498
0.957167
0.792207
0.678735

（c）行列式计算

        行列式计算的函数内部封装了LU分解、获取U矩阵对角线元素，以实现求行列式。其声明如下：

double _det(mat* mat1);

       需要注意的是，返回值是double而不是mat*

         eg:

	double arr[25] = { 0.814723686393179,	0.905791937075619,	0.126986816293506,	0.913375856139019,	0.632359246225410,
	0.0975404049994095,	0.278498218867048,	0.546881519204984,	0.957506835434298,	0.964888535199277,
	0.157613081677548,	0.970592781760616,	0.957166948242946,	0.485375648722841,	0.800280468888800,
	0.141886338627215,	0.421761282626275,	0.915735525189067,	0.792207329559554,	0.959492426392903,
	0.655740699156587,	0.0357116785741896,	0.849129305868777,	0.933993247757551,	0.678735154857774 };
	mat* mat1 = make_mat(5, 5, arr);
	print_mat(mat1);
	printf("%f", _det(mat1));

        结果：

0.814724     0.097540     0.157613     0.141886     0.655741
0.905792     0.278498     0.970593     0.421761     0.035712
0.126987     0.546882     0.957167     0.915736     0.849129
0.913376     0.957507     0.485376     0.792207     0.933993
0.632359     0.964889     0.800280     0.959492     0.678735

-0.025011

        matlab验算：

mat=[0.814724     0.097540     0.157613     0.141886     0.655741
0.905792     0.278498     0.970593     0.421761     0.035712
0.126987     0.546882     0.957167     0.915736     0.849129
0.913376     0.957507     0.485376     0.792207     0.933993
0.632359     0.964889     0.800280     0.959492     0.678735];
>> det(mat)

ans =

   -0.0250

（4）行列交换

        行列交换是矩阵的初等变换（其余的初等变换，诸如某一行乘以多少，这种需要配合后续会提到的切片来处理）。这里分别展示行变换、列交换的声明：

mat* change_row(mat* mat1, int row1, int row2);
mat* change_column(mat* mat1, int column1, int column2);

        eg:

	double arr[25] = { 0.814723686393179,	0.905791937075619,	0.126986816293506,	0.913375856139019,	0.632359246225410,
	0.0975404049994095,	0.278498218867048,	0.546881519204984,	0.957506835434298,	0.964888535199277,
	0.157613081677548,	0.970592781760616,	0.957166948242946,	0.485375648722841,	0.800280468888800,
	0.141886338627215,	0.421761282626275,	0.915735525189067,	0.792207329559554,	0.959492426392903,
	0.655740699156587,	0.0357116785741896,	0.849129305868777,	0.933993247757551,	0.678735154857774 };
	mat* mat1 = make_mat(5, 5, arr);
	print_mat(mat1);
	print_mat(change_row(mat1,0,2));
	print_mat(change_column(mat1, 1, 4));

        结果：

0.814724     0.097540     0.157613     0.141886     0.655741
0.905792     0.278498     0.970593     0.421761     0.035712
0.126987     0.546882     0.957167     0.915736     0.849129
0.913376     0.957507     0.485376     0.792207     0.933993
0.632359     0.964889     0.800280     0.959492     0.678735

0.126987     0.546882     0.957167     0.915736     0.849129
0.905792     0.278498     0.970593     0.421761     0.035712
0.814724     0.097540     0.157613     0.141886     0.655741
0.913376     0.957507     0.485376     0.792207     0.933993
0.632359     0.964889     0.800280     0.959492     0.678735

0.814724     0.655741     0.157613     0.141886     0.097540
0.905792     0.035712     0.970593     0.421761     0.278498
0.126987     0.849129     0.957167     0.915736     0.546882
0.913376     0.933993     0.485376     0.792207     0.957507
0.632359     0.678735     0.800280     0.959492     0.964889

6.尚未在此说明的功能（但代码里包含）

（1）按行、列求最大、最小、均值、和

（2）切片

（3）替换

（4）横向、纵向拼接

ion_ura
关注
c语言之矩阵
m0_62633482的博客
07-10 1万+
c语言之矩阵（转置矩阵，上三角矩阵，杨氏矩阵）
定义矩阵
kktyk的博客
03-13 877
template<class ElemType>class Matrix{    protected:        ElemType* Elems;    //存储矩阵元素        int rows,cols;      //矩阵的行数和列数    public:        Matrix(int rs,int cs);        ~Matrix();        in...
C语言 计算矩阵(二维数组)
weixin_44119517的博客
04-14 2万+
#include<stdio.h> #include<stdlib.h> main() { int i,j,k,N,M; printf("\t\t矩阵的加减法运算\n"); printf("你要输入几行的矩阵"); scanf("%d",&N); printf("\n你要输入几列的矩阵"); sca...
C语言实现矩阵
hunhunee666的博客
08-19 1万+
#include<stdlib.h> #include<stdio.h> #include<math.h> typedef struct{ int row; // 行 int col; // 列 float **matrix; // 元素 }matrix; void create(matrix *m, int row, int col); // 创.
C语言刷题小结---矩阵篇
m0_57105290的博客
08-05 3916
电影黑客帝国有很多这样的场景 用矩阵表示我们看到的一切！ 而在编程中矩阵是用数组来表示的 目前小作者还只是学习编程的初学者，很多知识内容都还没有学习。但相信每一个学习编程的小伙伴在做C语言方面的练习时都会遇到有关矩阵相关的题目，以下是小作者总结的有关矩阵的题目，以供大家学习总结。 1.矩阵的创建 2.矩阵元素定位 3. 图像相似度 4.矩阵相等判断 5.上矩阵三角形判断 6.矩阵转置 7.矩阵交换 1.矩阵的创建 输入描述：第一行输入两个整数 n 和 m ,第二行包含 n*m
C语言矩阵实现库运算， 简单的数组直接运算两种方式
有塔耶奥多的专栏
09-27 1097
C语言需要实现矩阵的加和相乘，发现网上很多实现方法运行使用都有些问题，参考了一位博主的，基于C语言的矩阵实现库简单修改了，在此感谢 matrix.h typedef struct { int row; int column; float** data; }MATRIX_T; matrix.c static int16_t SizeMatrix(MATRIX_T* matrix) { return matrix->row * matrix->column
C语言实现一个简单的矩阵运算器
NingHai's blog
07-19 2641
源代码： 正文开始@Assassin 目录：源代码：运行结果：see you next blog~~ #include <stdio.h> #include <windows.h> #include <math.h> #include <stdlib.h> void Menu(void); //菜单 int Input(void); //输入 void Judge(void); //退出/循环判定 void Add(void);
r语言用c函数定义一个向量,R语言中向量和矩阵简单运算的实现
weixin_35686386的博客
05-20 1516
一、向量运算向量是有相同基本类型的元素序列，一维数组，定义向量的最常用办法是使用函数c()，它把若干个数值或字符串组合为一个向量。1.R语言向量的产生方法> x > x[1] 1 2 32.向量加减乘除都是对其对应元素进行的，例如下面> x > y > y[1] 2 4 6(注：向量的整数除法是%/%，取余是%%。)3.向量的内积，有两种方法。第一种方法：%*%&gt...
用C语言开发一个简单的矩阵运算工具
最新发布
qq_44723972的博客
04-15 296
这个程序展示了C语言在处理矩阵运算时的基本方法，包括数组操作、函数封装和用户交互。通过模块化设计，程序的可读性和可维护性得到了提升。对于初学者来说，这是一个很好的练习项目，可以帮助理解C语言的基本语法和编程思想。
C语言矩阵运算
FL1717的博客
06-14 1万+
矩阵运算C语言实现
用C语言实现一个矩阵
微小冷的学习笔记
10-06 1万+
C语言实现矩阵 矩阵作为一个结构体而言，至少要包含行数、列数以及数据。 #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct{ int row, col, size; double *data; } Matrix; 特殊矩阵 接下来通过这个结构体实现一些特殊的矩阵，例如包括相同元素的矩阵、对角矩阵等。 #define SetBase(mat) \ (M
C语言矩阵乘法
王元笙
06-01 3万+
具体讲解了矩阵乘法的原理，以及在C语言中如何创建矩阵乘法的函数（传统方法和2种优化方法）
C/C++定义二维数组（矩阵）
热门推荐
无鞋童鞋的博客
09-30 7万+
本文介绍了C/C++二维数组定义，分维度确定与否来介绍。
《C语言》矩阵问题
yj
01-23 5434
一.矩阵乘法 1.定理： 两个矩阵的乘法仅当第一个矩阵A的列数和另一个矩阵B的行数相等时才能定义。如A是m×n矩阵和B是n×p矩阵，它们的乘积C是一个m×p矩阵。 例如： 2.思路 1. i，j分别代表行和列，所以应该定义一个二维矩阵，其行和列都为2. 2.分析一下上面这个公式设a*b=C，C为矩阵乘法后的结果。 （1）C的第一行 C的第一行第一列等于a的第一行的每一个值乘b的第一列的每一个值 C的第一行第二列等于a的第一行的每一个值乘b的第二列的每一个值 （2...
菜鸟学编程之一：C定义、初始化矩阵
ZYTTAE的专栏
10-12 1万+
在进行科学计算的时候，矩阵是一种
C语言——矩阵计算（转置、加法、减法、数乘、乘法）
m0_67428547的博客
05-01 5031
C语言——矩阵计算（转置、加法、减法、数乘、乘法）
c语言矩阵
..
09-11 1万+
  思路：开辟一个新的同样规格的矩阵b，并将其全部置1. 遍历矩阵a(原矩阵)，发现有0的就在b的此行此列中插入0 // // main.c // test // // Created by 神威 on 2018/9/11. // Copyright © 2018年 神威. All rights reserved. // #include &lt;stdio.h&gt; #de...
c语言矩阵操作
qq_45784241的博客
12-23 8058
c语言实现矩阵操作
数据结构（c语言） 多维数组和矩阵
kkh01421的博客
08-29 7524
线性表是数学应用在计算机科学中一种相当简单与基本的数据结构，简单地说，线性表是n个元素的有限序列（n>=0) 例如：0 1 2 3 4就是五个阿拉伯数字组成的线性表， 一、线性表的定义 线性表的用途 c/c++程序中的数组或字符串结构就是一种典型的线性表应用，线性表在计算机中属于内存中的静态结构数据，特性是使用连续的存储空间来存储。在编译时必须把内存分配给相关的变量，但这容易造成内存的浪费。 链表结构在c/c++中多半是以指针变量类型来实现线性表结构，特点是链表节点的内存分配在执行时才会发生所
C语言中矩阵定义问题（续）
suyunyixuan的专栏
07-24 1524
使用二级指针定义矩阵，方便了矩阵运算，但是如果使用malloc函数进行初始化，空间没有得到及时释放的话，很容易报错，内存访问冲突。解决这个问题的方法就是，不用malloc函数初始化，定义一个指针数组和一个二维数组，通过指针数组将二级指针挂接到二维数组上去，虽然在计算的过程中没有使用到指针数组和二维数组，但是这样避免了指针失效等问题，具体实现的例子如下 定义  Matrix C_bn;   
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值