实用有趣的C语言程序

C语言是国内外广泛使用的一种计算机语言。C语言具有简洁、实用、代码质量高、可移植性强等一系列优点，它既具有高级语言的特点，又具有低级语言的许多特点，因此目前C语言已成为学习和使用人数*多的一种计算机语言。本书不是一种介绍如何使用C语言的书，而是一本实用、有趣的C语言程序集。本书特色：（1）内容涉及面广，既包括初等数学方面的内容，也有高等数学方面的内容，还有些其他的内容。（2）通俗易懂，实例的选取兼顾了趣味性和实用性。既适合初学者，也适合有一定编程基础的爱好者及专业技术人员。（3）逻辑性强，对于每一个实例都是先分析问题，提出大致思路，再给出解决此问题的完整程序清单，*后给出程序运行结果。（4）实践性强，每一个实例都在Visual C 6.0下调试通过。提供完整的电子资料包，读者可以直接运行程序，也可以改变输入参数或修改程序再运行。 

本书共分9章，第1章日历和日期，内容是根据日期求星期，求两个日期之间的天数，编写并打印出任一年的日历，以及农历和公历之间的相互转换等。第2章大数计算，这里大数是指用普通计算器，包括电脑上的、手机上的计算器都无法正确计算出来的数。大数计算包括大数的加、减、乘、除、乘方、开平方、阶乘、排列和组合。第3章极限、级数和圆周率等，用程序实现数列极限和函数极限的计算或验证，用程序实现级数前N项和的计算和求出圆周率的精确值。第4章复数的运算，复数运算包括复数代数式与极坐标式的相互转换、复数求倒数、乘、除、乘方、开方、开N次方根、指数、对数、正弦、余弦等运算。第5章矩阵计算，包括求行列式的值、矩阵转置、矩阵相乘和矩阵求逆。第6章解多元一次方程组，包括解二元、三元、四元、五元、六元一次方程组。第7章解一元N次方程（上），包括用公式法解一元二次、一元三次、一元四次方程。第8章解一元N次方程（下），包括用迭代法解一元五次、一元六次、一元七次和一元八次方程。第9章其它，包括没归类到前8章的若干程序。*后，有一个介绍Visual C 6.0上机操作的附录A 。

杜树春，高级工程师，1947年12月4日生。吉林大学物理系毕业，现已退休，曾先后供职于（西安）兵器工业部205研究所和（太原）山西省自动化研究所。编著《单片机C语言和汇编语言混合编程实例详解》《单片机应用系统开发实例详解》《单片机C语言和汇编语言混合编程实践》《单片机与外围器件接口实例详解》《基于Proteus和Keil C51的单片机设计与仿真》《基于Proteus的数字集成电路快速上手》《基于Proteus的模拟电路分析与仿真》《基于Proteus的电路基础知识快速上手》《51单片机开发快速上手》《集成运算放大器应用经典实例》等多部图书。

目录

 

第1章日历和日期

 

1.1给出年月日,计算该日是星期几

 

1.2给出年份,计算该年元旦那天是星期几

 

1.3计算某年某月某日是本年度第几天

 

1.4求指定日期距离1990年1月1日的天数

 

1.5给定出生年月日及现在年月日，计算天数

 

1.6编制万年历

 

1.7公历转农历

 

1.8农历转公历

 

1.9小结

 

第2章大数计算

 

2.1什么是大数计算

 

2.2大数加法

 

2.3大数减法

 

2.4大数乘法

 

2.5大数除法

 

2.6大数阶乘n！

 

2.7大数乘方运算

 

2.8大数开平方

 

2.9大数排列

 

2.10大数组合

 

2.11小结

 

第3章极限、级数和圆周率等

 

3.1数列的极限和函数的极限

 

3.1.1数列的极限和函数的极限的介绍

 

3.1.2用C语言程序验证两种极限

 

3.2级数、幂级数

 

3.2.1级数的定义

 

3.2.2用C语言程序验证级数的收敛和发散

 

3.3圆周率π

 

3.3.1圆周率的来历

 

3.3.2求圆周率的方法

 

3.4自然对数的底e

 

3.4.1自然对数底的来历

 

3.4.2用C语言程序计算e值

 

3.5欧拉常数γ

 

3.5.1欧拉常数γ简介

 

3.5.2用C语言程序计算γ值

 

3.6小结

 

第4章复数运算

 

4.1复数简介

 

4.1.1复数

 

4.1.2复数的四种表示形式

 

4.1.3复数的四则运算

 

4.1.4复数的其他运算

 

4.2复数运算程序1

 

4.2.1复数代数形式和极坐标形式间的相互转换程序

 

4.2.2求代数形式复数的倒数程序

 

4.2.3求任一复数平方根的程序

 

4.2.4求两个代数形式复数之积的程序

 

4.2.5求两个代数形式复数之商的程序

 

4.3复数运算程序2

 

4.3.1求复数的乘幂程序

 

4.3.2求复数的N次方根程序

 

4.3.3求复数的指数程序

 

4.3.4求复数的自然对数程序

 

4.3.5求复数的常用对数程序

 

4.3.6求复数的正弦程序

 

4.3.7求复数的余弦程序

 

4.3.8求复数的正切程序

 

4.4小结

 

第5章矩阵计算

 

5.1矩阵简介

 

5.1.1行列式

 

5.1.2矩阵的加法、乘法和矩阵的转置

 

5.1.3矩阵的除法——矩阵求逆

 

5.2求行列式值的程序

 

5.2.1求3阶行列式值的程序

 

5.2.2求4阶行列式值的程序

 

5.2.3求5阶行列式值的程序

 

5.2.4求6阶行列式值的程序

 

5.3矩阵转置程序

 

5.3.1将3阶矩阵转置的程序

 

5.3.2将4阶矩阵转置的程序

 

5.3.3将5阶矩阵转置的程序

 

5.3.4将6阶矩阵转置的程序

 

5.4矩阵相乘程序

 

5.4.1两个3阶实矩阵相乘程序

 

5.4.2两个4阶实矩阵相乘程序

 

5.4.3两个5阶实矩阵相乘程序

 

5.4.4一个4×5矩阵与一个5×3矩阵相乘程序

 

5.5矩阵求逆程序

 

5.5.1求2阶矩阵的逆阵程序

 

5.5.2求3阶矩阵的逆阵程序

 

5.5.3求4阶矩阵的逆阵程序

 

5.5.4求5阶矩阵的逆阵程序

 

5.5.5求6阶矩阵的逆阵程序

 

5.6小结

 

第6章解多元一次线性方程组

 

6.1多元一次方程组简介

 

6.2解实系数多元一次方程组

 

6.2.1求解实系数二元一次方程组

 

6.2.2求解实系数三元一次方程组

 

6.2.3求解实系数四元一次方程组

 

6.2.4求解实系数五元一次方程组

 

6.2.5求解实系数六元一次方程组

 

6.3解复系数多元一次方程组

 

6.3.1求解复系数二元一次方程组

 

6.3.2求解复系数三元一次方程组

 

6.3.3求解复系数四元一次方程组

 

6.3.4求解复系数五元一次方程组

 

6.3.5求解复系数六元一次方程组

 

6.4小结

 

第7章解一元n次方程(上)

 

7.1实系数一元二次方程

 

7.2用卡尔丹公式解实系数一元三次方程

 

7.3用盛金公式解实系数一元三次方程

 

7.4用谢国芳公式解实系数一元三次方程

 

7.5实系数一元四次方程

 

7.6复系数一元二次方程(1)

 

7.7复系数一元二次方程(2)

 

7.8小结

 

第8章解一元n次方程（下）

 

8.1实系数一元代数方程

 

8.1.1求解实系数一元五次方程的根

 

8.1.2求解实系数一元六次方程的根

 

8.1.3求解实系数一元七次方程的根

 

8.1.4求解实系数一元八次方程的根

 

8.2复系数一元代数方程

 

8.2.1求解复系数一元五次方程的根

 

8.2.2求解复系数一元六次方程的根

 

8.2.3求解复系数一元七次方程的根

 

8.2.4求解复系数一元八次方程的根

 

8.3小结

 

第9章其他程序

 

9.1乘法九九表1

 

9.2乘法九九表2

 

9.3杨辉三角形1

 

9.4杨辉三角形2

 

9.5斐波纳契数列

 

9.6无符号整数的任意进制的转换

 

9.7求指定区间［a，b］内的勾股数组

 

9.8百鸡问题

 

9.9求10000以内的完全数

 

9.10输入三角形三边求此三角形面积、外接圆半径和内切圆半径

 

9.11围棋的棋局——千古无同局

 

9.12求1000以内的素数

 

9.13求3~1000以内的孪生素数

 

9.14求1000以内的阿姆斯特朗数

 

9.15计算气压随高度变化

 

9.16小结

 

附录Visual C 6.0的上机操作

 

附.1Visual C 6.0的安装和启动

 

附.2输入和编辑源程序

 

附.3编译、连接和运行

 

附.4编译和运行C语言程序的另一种方法

 

参考文献

前言C语言是国内外广泛使用的一种计算机语言。C语言具有简洁、实用、代码质量高、可移植性强等优点，它同时具有高级语言和低级语言的特点，因此目前C语言已成为学习和使用人数多的一种计算机语言。本书不是一本介绍如何使用C语言的书，而是一本实用、有趣的C语言程序集。本书具有以下特点： ①内容涉及面广，既包括初等数学方面的内容，也有高等数学方面的内容，还兼有其他的内容。②实例的选取兼顾了趣味性和实用性。③对于每一个C语言应用实例，本书都是先分析问题，提出大致思路，再给出解决此问题的完整的C语言程序清单，后给出程序运行结果。全书共分9章。第1章日历和日期，内容是根据日期求星期，求两个日期之间的天数，编写并打印出任一年的日历，以及农历和公历之间的相互转换等。第2章大数计算，这里的大数是指用普通计算器，包括计算机和手机上的计算器都无法正确计算出来的数。大数计算包括大数的加、减、乘、除、乘方、开平方、阶乘、排列和组合。第3章涉及极限、级数和圆周率等，用程序实现数列极限和函数极限的计算或验证； 用程序实现级数前N项和的计算； 以及用程序求出圆周率的精确值。第4章复数的运算，复数运算包括复数代数式与极坐标式的相互转换、复数求倒数、乘、除、乘方、开方、开N次方根、指数、对数、正弦、余弦等运算。第5章矩阵计算，包括求行列式的值、矩阵转置、矩阵相乘和矩阵求逆。第6章求解多元一次方程组，包括解二元、三元、四元、五元、六元一次方程组。第7章求解一元N次方程(上)，包括用公式法解一元二次、一元三次、一元四次方程。第8章求解一元N次方程(下)，包括用迭代法解一元五次、一元六次、一元七次和一元八次方程。第9章包括了没归类到前8章的其他若干程序。后是介绍Visual C 6.0上机操作的附录。本书提供的电子资料包的内容，仍是以书中章节为单位。在每一章(指第1章到第9章)下，都有一个章文件夹，每章下面有［例N.1］，［例N.2］，…，［例N.N］的例文件夹，例文件夹内是这个例子的名称，打开名称文件夹，又有多个文件。其中，扩展名为DSW的文件是Visual C 6.0的工程文件； 扩展名为c的文件是Visual C 6.0的源文件。在Visual C 6.0软件已安装在电脑中的前提下，双击具有DSW扩展名的文件就可进入Visual C 6.0软件集成环境，也就是Visual C 6.0的编辑、编译、连接、调试、运行环境。书中的所有例子都已在Visual C 6.0环境下调试通过，读者既可以原封不动地运行书中实例，也可以改变输入参数运行，还可以修改程序(包括少量改动和大刀阔斧的改动)运行。
本书所用C语言编译集成环境是Visual C 6.0，这个软件既可以用来编译、运行C 语言程序，也可以用来编译、运行C语言程序。本书所有例子都已在Visual C 6.0下通过调试。对于初次接触C语言的人，在读本书正文之前，可以先看一下介绍Visual C 6.0用法的附录。本书的另一特点是实践性强。书中每一个实例，读者无须重新输入程序，无须重新建立项目工程，只需用鼠标双击一下，程序就可以运行。本书既适合初学者，也适合有一定编程基础的爱好者及专业技术人员。
本书适合以下人员阅读或参考： 一是学习C语言课程的大、中专及高等职业学校、中等职业学校的在校学生； 二是使用C语言的广大工程技术人员； 三是C语言编程的初学者； 四是广大程序设计爱好者和C语言编程爱好者。
由于编著者水平有限且时间仓促，书中难免存在不足，恳请读者批评指正。作者的电子邮箱为[email protected]。本书电子资料包请扫描二维码下载。

编著者2016年12月

评论

第5章矩阵计算5.1矩阵简介5.1.1行列式1. 二、三阶行列式
我们用

a11a12…a1na21a22…a2nan1an2…ann

表示一个n阶行列式。其中元素aij(i,j=1,2,…,n)都是数域P中的数。行列式中的横排称为行，竖的称为列。例如，aij表示第i行第j列处的元素，a23表示行列式中第2行第3列处的元素。我们知道，凡行列式都可算出一个数值来。先看简单的二阶行列式。1） 二阶行列式

a11a12a21a22=a11a22- a12a21（51）

由式（51）可见，一个2阶行列式值是由对角的两个元素相乘之差形成的。再看三阶行列式。2） 三阶行列式

a11a12a13a21a22a23a31a32a33=a11a22a33 a12a23a31 a13a21a32- a11a23a32- a12a21a33- a13a22a31（52）

由式（52）可见，一个3阶行列式是由不同行不同列的三个数相乘而得到的六个项的代数和。下面分别给出了二阶行列式和3阶行列式的行列式值计算实例： 211－3=2×(-3)-1×1=-7； 212－431235= 2×3×5 1×1×2 2×(-4)×3-2×3×1-1×(-4)×5-2×3×2=30 2-24-6 20-12=10。2. 余子式和代数余子式在n阶行列式

a11a12…a1na21a22…a2nan1an2…ann

中，划去元素aij所在的第i行第j列，剩下的元素按原来的排法，构成一个n-1阶行列式

a11…a1,j－1a1,j 1…a1nai－1,1…ai－1,j－1ai－1,j 1…ai－1,nai 1,1…ai 1,j－1ai 1,j 1…ai 1,nan1an,j－1an,j 1ann

称为元素aij的余子式，记为Mij。例如，对于3阶行列式

D=a11a12a13a21a22a23a31a32a33

来说，各个元素的余子式分别为： 

M11=a22a23a32a33，M12=a21a23a31a33，M13=a21a22a31a32，
M21=a12a13a32a33，M22=a11a13a31a33，M23=a11a12a31a32，
M31=a12a13a22a23，M32=a11a13a21a23，M33=a11a12a21a22。

而3阶行列式D可以通过各行的余子式来表示： 

D=a11M11-a12M12 a13M13
=-a21M21 a22M22-a23M23(53)
=a31M31-a32M32 a33M33

也可以用各列的余子式来表示： 

D=a11M11-a21M21 a31M31
=-a12M12 a22M22-a32M32(54)
=a13M13- a23M23 a33M33

从式（52）和式（53）可以看出： Mij前的符号，有时正，有时负。为了弄清这个问题，引入下述定义： 定义1令

Aij=(-1)i jMij

Aij称为元素aij的代数余子式。应用代数余子式的概念，3阶行列式可以表示成： 

D=ai1Ai1 ai2Ai2 ai3Ai3(i=1,2,3)
D=a1jA1j a2jA2j a3jA3j(j=1,2,3)

这表明，行列式的值是任意一行的所有元素与它们的对应代数余子式的乘积之和。以下给出了求解行列式及其余子式的例子： 求

D=10－1120－132

的余子式M11，M12，M13及代数余子式A11， A12， A13并求D。解： M11=2032=4，M12=10-12=2，M13=12-13=5A11= (-1)1 1 M11=4，A12= (-1)1 2 M12=-2A13= (-1)1 3 M13=5D=1·A11 0·A12 (-1)·A13=-13. 用代数余子式表示n阶行列式的展开式前已说明，n阶行列式

a11a12…a1na21a22…a2nan1an2…ann

等于它任意一行的所有元素与它们的对应代数余子式的乘积之和，即

D= ak1Ak1 ak2Ak2 … aknAkn(k=1,2,…,n)

这就是行列式按一行(第k行)展开的公式。由于行列式中行与列的对称性，所以同样也可以将行列式按一列展开，即n阶行列式

a11a12…a1na21a22…a2nan1an2…ann

等于它任意一列的所有元素与它们的对应代数余子式的乘积之和，即

D= a1lA1l a2lA2l … anlAnl(l=1,2,…,n)

这就是行列式按一列(第l列)展开的公式。下例是根据行列式及余子式求行列式的值： 

D=212-431235

解： 把D按第2行展开，得

212-431235=41235 32225-2123=-4 18-4=10

把D按第3列展开，得

212-431235=2-4323-2123 521-43=-36-4 50=10

5.1.2矩阵的加法、乘法和矩阵的转置1. 矩阵的加法
设

A=a11a12…a1na21a22…a2nas1as2…asn
B=b11b12…b1nb21b22…b2nbs1bs2…bsn

是两个s×n矩阵，则s×n矩阵

C=a11 b11a12 b12…a1n b1na21 b21a22 b22…a2n b2nas1 bs1as2 bs2…asn bsn

称为A和B的和，记作

C=A B

从定义可以看出： 两个矩阵必须在行数与列数分别相同的情况下才能相加。矩阵相加的例子如下： 

123501－1231202132 001-1123121－124501=1 02 03 15-10 11 2－1 32 13 21 12－10 22 41 53 02 1
=1244132352126633

2. 矩阵的乘法设A是个s×n矩阵： 

A=a11a12…a1na21a22…a2nas1as2…asn

B是个n×m矩阵： 

B=b11b12…b1mb21b22…b2mbn1bn2…bnm

作s×m矩阵： 

C=c11c12…c1mc21c22…c2mcs1cs2…csm

其中，cij=ai1b1j ai2b2j … ainbnj=∑nk=1aikbkj(i=1,2，…,s； j=1,2，…,m)
矩阵C称为矩阵A与B的乘积，记为

C=AB

注意： 在矩阵乘积的定义中，要求第1个矩阵的列数必须等于第2个矩阵的行数。设有矩阵A和矩阵B： 

A=102-101-13-1201,B=12210314

则

AB=1×1 0×2 2×0 (-1)×11×2 0×1 2×3 (－1)×40×1 1×2 (－1)×0 3×10×2 1×1 (－1)×3 3×4(－1)×1 2×2 0×0 1×1(－1)×2 2×1 0×3 1×4
=0451044

矩阵的乘法与数的乘法有一重要区别，就是矩阵的乘法不满足交换律，也就是说，矩阵的乘积AB与BA不一定相等。看下面的例子。设

A=1232－11024,B=21－102110－2

则

AB=55－550－544－6
BA=4134061－2－5

可见，在本例中，AB和BA完全不同。3. 矩阵的转置把一个矩阵的行列互换，所得到的矩阵称为这个矩阵的转置。设A是个s×n矩阵： 

A=a11a12…a1na21a22…a2nas1as2…asn

n×s

矩阵a11a21…as1a12a22…as2a1na2n…asn

称为A的转置矩阵，记作A′。设

A=1232－11024

则A的转置矩阵为： 

A′=1202-12314

5.1.3矩阵的除法——矩阵求逆以上谈了矩阵的加法、减法和乘法，矩阵有没有除法呢？有，求矩阵的逆就是矩阵除法。1. E矩阵单位矩阵矩阵中有一类特殊的矩阵，起着与数的乘法中1相同的作用，即所谓单位矩阵。单位矩阵是指主对角线上的元素全是1，其余元素全是0的n×n矩阵

10…001…000…1

称为n级单位矩阵，记作En。2. 矩阵的逆矩阵对于矩阵A，如果有矩阵B,使得

AB=BA=E

则A称为可逆的； B称为A的逆矩阵，记作A－1。3. 伴随矩阵设Aij是矩阵

A=a11a12…a1na21a22…a2nan1an2…ann

中元素aij的代数余子式。矩阵

A=A11A12…A1nA21A22…A2nAn1An2…Ann

称为A的伴随矩阵。4. 逆矩阵计算公式矩阵A可逆的充分必要条件是： A是非退化的(指|A|≠0),而且当A可逆时，

A－1=1|A|A

判断矩阵

A=2113120-10

是否可逆。如果可逆，求A－1。解： 因为

|A|=2113120-10=2≠0

所以，A是可逆的。又因

A11=2，A12=2，A13=-4
A21=-2，A22=-1，A23=3
A31=1，A32=-1，A33=-1

所以A－1=122-112-1-1-43-1
5.2求行列式值的程序5.2.1求3阶行列式值的程序

求两个三阶行列式的值。1) 程序清单
#include “stdio.h”
#include “math.h”
main()
{ 
double bsdet(double a［］,int n)； 
static double a［3］［3］={ {1.0,2.0,3.0},
{5.0,6.0,7.0},
{13.0,14.0,15.0}}； 
static double b［3］［3］={ {3.0,-3.0,-2.0},
{5.0,-5.0,1.0},
{5.0,-1.0,-3.0}}； 
double det； 
det=bsdet(a,3)； 
if (fabs(det)<0.00001) det=0.0；  
printf(“det(A)=%10.4e＼n”,det)； 
printf(“＼n”)； 
det=bsdet(b,3)； 
if (fabs(det)<0.00001) det=0.0；  
printf(“det(B)=%10.4e＼n”,det)； 
printf(“＼n”)； 
}
double bsdet(double a［］,int n)
{ 
int i,j,k,is,js,l,u,v； 
double f,det,q,d； 
f=1.0；  det=1.0； 
for (k=0；  k<=n-2；  k )
{ q=0.0； 
for (i=k；  i<=n-1；  i )
for (j=k；  j<=n-1；  j )
{ l=i*n j；  d=fabs(a［l］)； 
if (d>q) { q=d；  is=i；  js=j； }
}
if (q 1.0==1.0)
{ det=0.0；  return(det)； }
if (is!=k)
{ f=-f； 
for (j=k；  j<=n-1；  j )
{ u=k*n j；  v=is*n j； 
d=a［u］；  a［u］=a［v］；  a［v］=d； 
}
}
if (js!=k)
{ f=-f； 
for (i=k；  i<=n-1；  i )
{ u=i*n js；  v=i*n k； 
d=a［u］；  a［u］=a［v］；  a［v］=d； 
}
}
l=k*n k； 
det=det*a［l］； 
for (i=k 1；  i<=n-1；  i )
{ d=a［i*n k］/a［l］； 
for (j=k 1；  j<=n-1；  j )
{ u=i*n j； 
a［u］=a［u］-d*a［k*n j］； 
}
}
}
det=f*det*a［n*n-1］； 
return(det)； 
}
2) 程序运行【例5.1】求以下两个三阶行列式的值： 

A=123567131415,B=3－325－515-1－3

解： 打开“求3阶行列式值”文件夹，双击扩展名为DSW的文件，进入Visual C 6.0编译环境，编译程序并执行，运行结果为： 
这表明行列式A的值为0； 行列式B的值为-52。5.2.2求4阶行列式值的程序求两个四阶行列式的值。1） 程序清单
#include “stdio.h”
#include “math.h”
main()
{ 
double bsdet(double a［］,int n)； 
static double a［4］［4］={ {1.0,2.0,3.0,4.0},
{5.0,6.0,7.0,8.0},
{9.0,10.0,11.0,12.0},
{13.0,14.0,15.0,16.0}}； 
static double b［4］［4］={ {1.0,0.0,-1.0,2.0},
{-2.0,1.0,3.0,1.0},
{0.0,1.0,0.0,-1.0},
{1.0,3.0,4.0,-2.0}}； 
double det； 
det=bsdet(a,4)； 
if (fabs(det)<0.00001) det=0.0；  
printf(“det(A)=%10.4e＼n”,det)； 
printf(“＼n”)； 
det=bsdet(b,4)； 
if (fabs(det)<0.00001) det=0.0；  
printf(“det(B)=%10.4e＼n”,det)； 
printf(“＼n”)； 
}
double bsdet(double a［］,int n)
{ 
int i,j,k,is,js,l,u,v； 
double f,det,q,d； 
f=1.0；  det=1.0； 
for (k=0；  k<=n-2；  k )
{ q=0.0； 
for (i=k；  i<=n-1；  i )
for (j=k；  j<=n-1；  j )
{ l=i*n j；  d=fabs(a［l］)； 
if (d>q) { q=d；  is=i；  js=j； }
}
if (q 1.0==1.0)
{ det=0.0；  return(det)； }
if (is!=k)
{ f=-f； 
for (j=k；  j<=n-1；  j )
{ u=k*n j；  v=is*n j； 
d=a［u］；  a［u］=a［v］；  a［v］=d； 
}
}
if (js!=k)
{ f=-f； 
for (i=k；  i<=n-1；  i )
{ u=i*n js；  v=i*n k； 
d=a［u］；  a［u］=a［v］；  a［v］=d； 
}
}
l=k*n k； 
det=det*a［l］； 
for (i=k 1；  i<=n-1；  i )
{ d=a［i*n k］/a［l］； 
for (j=k 1；  j<=n-1；  j )
{ u=i*n j； 
a［u］=a［u］-d*a［k*n j］； 
}
}
}
det=f*det*a［n*n-1］； 
return(det)； 
}
2） 程序运行【例5.2】求以下两个四阶行列式的值。

A=12345678910111213141516,B=10－12-2131010－1134－2

解： 打开“求4阶行列式值”文件夹，双击扩展名为DSW的文件，进入Visual C 6.0编译环境，编译程序并执行，运行结果为： 
这表明行列式A的值为0； 行列式B的值为31。5.2.3求5阶行列式值的程序求两个五阶行列式的值。1） 程序清单
#include “stdio.h”
#include “math.h”
main()
{ 
double bsdet(double a［］,int n)； 
static double a［5］［5］={ {1.0,1.0,2.0,3.0,4.0},
{1.0,5.0,6.0,7.0,8.0},
{1.0,9.0,10.0,11.0,12.0},
{1.0,9.0,10.0,11.0,1.0},
{13.0,14.0,15.0,16.0,1.0}}； 
static double b［5］［5］={ {3.0,-3.0,-2.0,4.0,1.0},
{5.0,-5.0,1.0,8.0,1.0},
{11.0,8.0,5.0,-7.0,1.0},
{10.0,8.0,5.0,-7.0,2.0},
{5.0,-1.0,-3.0,-1.0,1.0}}； 
double det； 
det=bsdet(a,5)； 
if (fabs(det)<0.00001) det=0.0；  
printf(“det(A)=%10.4e＼n”,det)； 
printf(“＼n”)； 
det=bsdet(b,5)； 
if (fabs(det)<0.00001) det=0.0；  
printf(“det(B)=%10.4e＼n”,det)； 
printf(“＼n”)； 
}
注： double bsdet(double a［］,int n)函数同上，这里略去。2） 程序运行【例5.3】求以下两个五阶行列式的值。

A=1123415678191011121910111131415161,B=3－32415－51811185－711085－725－1－3－11

解： 打开“求5阶行列式值”文件夹，双击扩展名为DSW的文件，进入Visual C 6.0编译环境，编译程序并执行，运行结果为：
这表明行列式A的值为0； 行列式B的值为-686。5.2.4求6阶行列式值的程序求两个六阶行列式的值。1） 程序清单
#include “stdio.h”
#include “math.h”
main()
{ 
double bsdet(double a［］,int n)； 
static double a［6］［6］={ {1.0,1.0,2.0,3.0,4.0,1.0},
{1.0,5.0,6.0,7.0,8.0,1.0},
{1.0,9.0,10.0,11.0,12.0,1.0},
{1.0,9.0,10.0,11.0,1.0,2.0},
{2.0,9.0,10.0,11.0,12.0,1.0},
{13.0,14.0,15.0,16.0,1.0,0.0}}； 
static double b［6］［6］={ {3.0,-3.0,-2.0,4.0,1.0,0.0},
{5.0,-5.0,1.0,8.0,1.0,1.0},
{11.0,8.0,5.0,-7.0,1.0,0.0},
{1.0,9.0,10.0,11.0,12.0,1.0},
{10.0,8.0,5.0,-7.0,2.0,0.0},
{5.0,-1.0,-3.0,-1.0,1.0,0.0}}； 
double det； 
det=bsdet(a,6)； 
if (fabs(det)<0.00001) det=0.0；  
printf(“det(A)=%10.4e＼n”,det)； 
printf(“＼n”)； 
det=bsdet(b,6)； 
if (fabs(det)<0.00001) det=0.0；  
printf(“det(B)=%10.4e＼n”,det)； 
printf(“＼n”)； 
}
注： double bsdet(double a［］,int n)函数同上，这里略去。2） 程序运行【例5.4】求以下两个6阶行列式的值。

A=1123411567811910111211910111222910111211314151610B=3－3－24105－518111185－71001910111211085－7205－1－3－110

解： 打开“求6阶行列式值”文件夹，双击扩展名为DSW的文件，进入Visual C 6.0编译环境，编译程序并执行，运行结果为
这表明行列式A的值为0； 行列式B的值为-2688。5.3矩阵转置程序5.3.1将3阶矩阵转置的程序
1） 程序清单
/**********************************************************/
/* 1.c将一个3×3矩阵转置*/
/**********************************************************/
#include
#include
void main()
{
void move(int *pointer)； 
int *p,i； 
static int a［3］［3］={ {1,2,3},
{4,5,6},
{7,8,9}}； 
p=&a［0］［0］； 
move(p)； 
printf(” 转置后的矩阵为： ＼n”)； 
for (i=0； i<3； i )
printf(” %d %d %d＼n”,a［i］［0］,a［i］［1］,a［i］［2］)； 
}
void move(int *pointer)
{
int i,j,t； 
for (i=0； i<3； i ) 
for (j=i； j<3； j ) 
{ t=*(pointer 3*i j)； 
*(pointer 3*i j)=*(pointer 3*j i)； 
*(pointer 3*j i)=t； 
}
}
2） 程序运行【例5.5】将以下的3阶矩阵转置。

A=123456789

解： 打开“将一个3阶方阵转置”文件夹，双击扩展名为DSW的文件，进入Visual C 6.0编译环境，编译程序并执行，运行结果如下： 

由运行结果可见，3阶矩阵A已转置。5.3.2将4阶矩阵转置的程序1） 程序清单
/**************************************************************/
/* 1.c将一个4×4矩阵转置*/
/**************************************************************/
#include
#include
void main()
{
void move(int *pointer)； 
int *p,i； 
static int a［4］［4］={ {1,2,3,4},
{5,6,7,8},
{9,0,1,2},
{3,4,5,6}}； 
p=&a［0］［0］； 
move(p)； 
printf(” 转置后的矩阵为： ＼n”)； 
for (i=0； i<4； i )
printf(” %d %d %d %d＼n”,a［i］［0］,a［i］［1］,a［i］［2］,a［i］［3］)； 
}
void move(int *pointer)
{
int i,j,t； 
for (i=0； i<4； i ) 
for (j=i； j<4； j ) 
{ t=*(pointer 4*i j)； 
*(pointer 4*i j)=*(pointer 4*j i)； 
*(pointer 4*j i)=t； 
}
}
2) 程序运行【例5.6】将以下4阶方阵转置。

A=1234567890123456

解： 打开“将一个4阶方阵转置”文件夹，双击扩展名为DSW的文件，将进入Visual C 6.0编译环境，编译程序并执行，运行结果如下： 

由运行结果可见，4阶矩阵A已转置。5.3.3将5阶矩阵转置的程序1） 程序清单
/**************************************************************/
/* 1.c将一个5阶方阵转置*/
/**************************************************************/
#include
#include
void main()
{
void move(int *pointer)； 
int *p,i； 
static int a［5］［5］={ {1,2,3,4,5},
  {6,7,8,9,0},
  {9,0,1,2,3},
  {8,1,7,6,9},
  {3,4,5,6,2}}； 
p=&a［0］［0］； 
move(p)； 
printf(” 转置后的矩阵为： ＼n”)； 
for (i=0； i<5； i )
printf(” %d %d %d %d %d＼n”,a［i］［0］,a［i］［1］,a［i］［2］,a［i］［3］,a［i］［4］)； 
}
void move(int *pointer)
{
int i,j,t； 
for (i=0； i<5； i ) 
for (j=i； j<5； j ) 
{ t=*(pointer 5*i j)； 
*(pointer 5*i j)=*(pointer 5*j i)； 
*(pointer 5*j i)=t； 
}
}
2） 程序运行【例5.7】将以下5阶方阵转置。

A=1234567890901238176934562

解： 打开“将一个5阶方阵转置”文件夹，双击扩展名为DSW的文件，进入Visual C 6.0编译环境，编译程序并执行，运行结果如下： 

由运行结果可见，5阶矩阵A已转置。5.3.4将6阶矩阵转置的程序1） 程序清单
/***************************************************************/
/* 1.c将一个6阶方阵转置*/
/***************************************************************/
#include
#include
void main()
{
void move(int *pointer)； 
int *p,i； 
static int a［6］［6］={ {1,2,3,4,5,6},
  {7,8,9,0,1,2},
  {3,4,5,6,7,8},
  {9,0,1,2,3,4},
  {5,6,7,8,9,0},
  {1,2,3,4,5,6}}； 
p=&a［0］［0］； 
move(p)； 
printf(” 转置后的矩阵为： ＼n”)； 
for (i=0； i<6； i )
printf(” %d %d %d %d %d %d＼n”,a［i］［0］,a［i］［1］,a［i］［2］,a［i］［3］,a［i］［4］,a［i］［5］)； 
}
void move(int *pointer)
{
int i,j,t； 
for (i=0； i<6； i ) 
for (j=i； j<6； j ) 
{ t=*(pointer 6*i j)； 
*(pointer 6*i j)=*(pointer 6*j i)； 
*(pointer 6*j i)=t； 
}
}
2） 程序运行【例5.8】将以下6阶方阵转置。

A=123456
789012345678901234567890123456

解： 打开“将一个6阶方阵转置”文件夹，双击扩展名为DSW的文件，进入Visual C 6.0编译环境，编译程序并执行，运行结果如下： 

由运行结果可见，6阶矩阵A已转置。5.4矩阵相乘程序5.4.1两个3阶实矩阵相乘程序
1） 程序清单
//3阶实方阵相乘
#include “stdio.h”
main()
{ 
void brmul(double a［］,double b［］,int m,int n,int k,double c［］)； 
int i,j； 
static double a［3］［3］={ {1.0,3.0,-2.0},
{-2.0,-1.0,5.0},
{3.0,-3.0,2.0}}； 
static double c［3］［3］,b［3］［3］={ {4.0,5.0,-1.0},
{2.0,-2.0,6.0},
{0.0,3.0,-5.0}}； 
brmul(a,b,3,3,3,c)； 
for (i=0；  i<=2；  i )
{ for (j=0；  j<=2；  j )
printf(” %8.3e”,c［i］［j］)； 
printf(“＼n”)； 
}
printf(“＼n”)； 
}
void brmul(double a［］,double b［］,int m,int n,int k,double c［］)
{ 
int i,j,l,u； 
for (i=0；  i<=m-1；  i )
for (j=0；  j<=k-1；  j )
{ u=i*k j；  c［u］=0.0； 
for (l=0；  l<=n-1；  l )
c［u］=c［u］ a［i*n l］*b［l*k j］； 
}
return； 
}
2） 程序运行【例5.9】求以下两个3阶实方阵相乘之积。

A=13-2-2-153-32，B=45-12-2603-5

解： 打开“3阶实方阵相乘”文件夹，双击扩展名为DSW的文件，将进入Visual C 6.0编译环境，编译程序并执行，运行结果如下： 

由运行结果可见，两个3阶实方阵相乘的结果，仍是3阶实方阵。即C=AB=10－727-107－29627－31。5.4.2两个4阶实矩阵相乘程序1） 程序清单
//4阶实方阵相乘
#include “stdio.h”
main()
{ 
void brmul(double a［］,double b［］,int m,int n,int k,double c［］)； 
int i,j； 
static double a［4］［4］={ {1.0,3.0,-2.0,0.0},
{-2.0,-1.0,5.0,-7.0},
{0.0,8.0,4.0,1.0},
{3.0,-3.0,2.0,-4.0}}； 
static double c［4］［4］,b［4］［4］={ {4.0,5.0,-1.0,1.0},
{2.0,-2.0,6.0,1.0},
{7.0,8.0,1.0,1.0},
{0.0,3.0,-5.0,1.0}}； 
brmul(a,b,4,4,4,c)； 
for (i=0；  i<=3；  i )
{ for (j=0；  j<=3；  j )
printf(” %8.4e”,c［i］［j］)； 
printf(“＼n”)； 
}
printf(“＼n”)； 
}
void brmul(double a［］,double b［］,int m,int n,int k,double c［］)
{ 
int i,j,l,u； 
for (i=0；  i<=m-1；  i )
for (j=0；  j<=k-1；  j )
{ u=i*k j；  c［u］=0.0； 
for (l=0；  l<=n-1；  l )
c［u］=c［u］ a［i*n l］*b［l*k j］； 
}
return； 
}
2） 程序运行【例5.10】求以下两个4阶实方阵相乘之积。

A=13-20-2-15-708413-32-4,B=45-112-261781103-51

解： 打开“4阶实方阵相乘”文件夹，双击扩展名为DSW的文件，将进入Visual C 6.0编译环境，编译程序并执行，运行结果如下： 

由运行结果可见，两个4阶实方阵相乘的结果，仍是4阶实方阵。即C=AB=-4-17152251136-54419471320251-2。5.4.3两个5阶实矩阵相乘程序1） 程序清单
//5阶实方阵相乘
#include “stdio.h”
main()
{ 
void brmul(double a［］,double b［］,int m,int n,int k,double c［］)； 
int i,j； 
static double a［5］［5］={ {1.0,3.0,-2.0,0.0,1.0},
{-2.0,-1.0,5.0,-7.0,1.0},
{0.0,8.0,4.0,1.0,1.0},
{0.0,8.0,4.0,1.0,1.0},
{3.0,-3.0,2.0,-4.0,1.0}}； 
static double c［5］［5］,b［5］［5］={ {4.0,5.0,-1.0,1.0,0.0},
{2.0,-2.0,6.0,1.0,0.0},
{7.0,8.0,1.0,1.0,1.0},
{0.0,8.0,4.0,1.0,1.0},
{0.0,3.0,-5.0,1.0,0.0}}； 
brmul(a,b,5,5,5,c)； 
for (i=0；  i<=4；  i )
{ for (j=0；  j<=4；  j )
printf(” %8.4e”,c［i］［j］)； 
printf(“＼n”)； 
}
printf(“＼n”)； 
}
void brmul(double a［］,double b［］,int m,int n,int k,double c［］)
{ 
int i,j,l,u； 
for (i=0；  i<=m-1；  i )
for (j=0；  j<=k-1；  j )
{ u=i*k j；  c［u］=0.0； 
for (l=0；  l<=n-1；  l )
c［u］=c［u］ a［i*n l］*b［l*k j］； 
}
return； 
}
2） 程序运行【例5.11】求以下两个5阶实方阵相乘之积。

A=13-201-2-15-7108411084113-32-41,B=123452-2610781110841103-510

解： 打开“5阶实方阵相乘”文件夹，双击扩展名为DSW的文件，将进入Visual C 6.0编译环境，编译程序并执行，运行结果如下： 

由运行结果可见，两个5阶实方阵相乘的结果，仍是5阶实方阵。即C=AB=-4-14103-225-21-32-4-2442751145442751145208-40-1-2。5.4.4一个4×5矩阵与一个5×3矩阵相乘程序1） 程序清单
//4×5矩阵与5×3矩阵相乘
#include “stdio.h”
main()
{ 
void brmul(double a［］,double b［］,int m,int n,int k,double c［］)； 
int i,j； 
static double a［4］［5］={ {1.0,3.0,-2.0,0.0,4.0},
{-2.0,-1.0,5.0,-7.0,2.0},
{0.0,8.0,4.0,1.0,-5.0},
{3.0,-3.0,2.0,-4.0,1.0}}； 
static double c［4］［3］,b［5］［3］={ {4.0,5.0,-1.0},
{2.0,-2.0,6.0},{7.0,8.0,1.0},
{0.0,3.0,-5.0},{9.0,8.0,-6.0}}； 
brmul(a,b,4,5,3,c)； 
for (i=0；  i<=3；  i )
{ for (j=0；  j<=2；  j )
printf(“%8.4e”,c［i］［j］)； 
printf(“＼n”)； 
}
printf(“＼n”)； 
}
void brmul(double a［］,double b［］,int m,int n,int k,double c［］)
{ 
int i,j,l,u； 
for (i=0；  i<=m-1；  i )
for (j=0；  j<=k-1；  j )
{ u=i*k j；  c［u］=0.0； 
for (l=0；  l<=n-1；  l )
c［u］=c［u］ a［i*n l］*b［l*k j］； 
}
return； 
}
2） 程序运行【例5.12】求以下4×5实矩阵与5×3实矩阵相乘之积。

A=13-204-2-15-720841-53-32-41,B=45-12-2678103-598-6

解： 打开“4×5实矩阵与5×3实矩阵相乘”文件夹，双击扩展名为DSW的文件，将进入Visual C 6.0编译环境，编译程序并执行，运行结果如下： 

由运行结果可见，4×5实矩阵与5×3实矩阵相乘的结果，是一个4×3实矩阵。即C=AB=3215-9432724-1-21772933-5
5.5矩阵求逆程序5.5.1求2阶矩阵的逆阵程序
1） 程序清单
#include “stdio.h”
#include “stdlib.h”
#include “math.h”
main()
{ 
int brinv(double a［］,int n)； 
void brmul(double a［］,double b［］,int m,int n,int k,double c［］)； 
int i,j； 
static double a［2］［2］={ {2.0,1.0},
{1.0,-1.0}}； 
static double b［2］［2］,c［2］［2］； 
for (i=0；  i<=1；  i )
for (j=0；  j<=1；  j )
b［i］［j］=a［i］［j］； 
i=brinv(a,2)； 
if (i!=0)
{ printf(“MAT A IS： ＼n”)； 
for (i=0；  i<=1；  i )
{ for (j=0；  j<=1；  j ){
if (fabs(b［i］［j］)<0.00001) b［i］［j］=0.0；  
printf(“%8.4e “,b［i］［j］)； }
printf(“＼n”)； 
}
printf(“＼n”)； 
printf(“MAT A- IS： ＼n”)； 
for (i=0；  i<=1；  i )
{ for (j=0；  j<=1；  j ){
if (fabs(a［i］［j］)<0.00001) a［i］［j］=0.0；  
printf(“%8.4e “,a［i］［j］)； }
printf(“＼n”)； 
}
printf(“＼n”)； 
printf(“MAT AA- IS： ＼n”)； 
brmul(b,a,2,2,2,c)； 
for (i=0；  i<=1；  i )
{ for (j=0；  j<=1；  j ){
if (fabs(c［i］［j］)<0.00001) c［i］［j］=0.0；  
printf(“%8.4e “,c［i］［j］)； }
printf(“＼n”)； 
}
}
}
int brinv(double a［］,int n)
{ 
int *is,*js,i,j,k,l,u,v； 
double d,p； 
is=malloc(n*sizeof(int))； 
js=malloc(n*sizeof(int))； 
for (k=0；  k<=n-1；  k )
{ d=0.0； 
for (i=k；  i<=n-1；  i )
for (j=k；  j<=n-1；  j )
{ l=i*n j；  p=fabs(a［l］)； 
if (p>d) { d=p；  is［k］=i；  js［k］=j； }
}
if (d 1.0==1.0)
{ free(is)；  free(js)；  printf(“err**not inv＼n”)； 
return(0)； 
}
if (is［k］!=k)
for (j=0；  j<=n-1；  j )
{ u=k*n j；  v=is［k］*n j； 
p=a［u］；  a［u］=a［v］；  a［v］=p； 
}
if (js［k］!=k)
for (i=0；  i<=n-1；  i )
{ u=i*n k；  v=i*n js［k］； 
p=a［u］；  a［u］=a［v］；  a［v］=p； 
}
l=k*n k； 
a［l］=1.0/a［l］； 
for (j=0；  j<=n-1；  j )
if (j!=k)
{ u=k*n j；  a［u］=a［u］*a［l］； }
for (i=0；  i<=n-1；  i )
if (i!=k)
for (j=0；  j<=n-1；  j )
if (j!=k)
{ u=i*n j； 
a［u］=a［u］-a［i*n k］*a［k*n j］； 
}
for (i=0；  i<=n-1；  i )
if (i!=k)
{ u=i*n k；  a［u］=-a［u］*a［l］； }
}
for (k=n-1；  k>=0；  k–)
{ if (js［k］!=k)
for (j=0；  j<=n-1；  j )
{ u=k*n j；  v=js［k］*n j； 
p=a［u］；  a［u］=a［v］；  a［v］=p； 
}
if (is［k］!=k)
for (i=0；  i<=n-1；  i )
{ u=i*n k；  v=i*n is［k］； 
p=a［u］；  a［u］=a［v］；  a［v］=p； 
}
}
free(is)；  free(js)； 
return(1)； 
}
void brmul(double a［］,double b［］,int m,int n,int k,double c［］)
{ 
int i,j,l,u； 
for (i=0；  i<=m-1；  i )
for (j=0；  j<=k-1；  j )
{ u=i*k j；  c［u］=0.0； 
for (l=0；  l<=n-1；  l )
c［u］=c［u］ a［i*n l］*b［l*k j］； 
}
return； 
}
2） 程序运行【例5.13】求以下2阶实矩阵的逆阵： 

A=211-1

解： 打开“2阶实矩阵求逆”文件夹，双击扩展名为DSW的文件，将进入Visual C 6.0编译环境，编译程序并执行，运行结果如下： 

由运行结果可见，图中MAT A为输入的矩阵A；  MAT A-为输出的逆阵； MAT AA—为输入矩阵和逆阵的乘积。输出的逆阵为： 

A-1=0.33330.33330.3333-0.6666

输入矩阵和逆阵的乘积AA-1为

AA-1=1.00.00.01.0

5.5.2求3阶矩阵的逆阵程序1) 程序清单
#include “stdio.h”
#include “stdlib.h”
#include “math.h”
main()
{ 
int brinv(double a［］,int n)； 
void brmul(double a［］,double b［］,int m,int n,int k,double c［］)； 
int i,j； 
static double a［3］［3］={ {2.0,1.0,1.0},
{3.0,1.0,2.0},
{1.0,-1.0,0.0}}； 
static double b［3］［3］,c［3］［3］； 
for (i=0；  i<=2；  i )
for (j=0；  j<=2；  j )
b［i］［j］=a［i］［j］； 
i=brinv(a,3)； 
if (i!=0)
{ printf(” MAT A IS： ＼n”)； 
for (i=0；  i<=2；  i )
{ for (j=0；  j<=2；  j ){
if (fabs(b［i］［j］)<0.00001) b［i］［j］=0.0；  
printf(” %8.4e “,b［i］［j］)； }
printf(“＼n”)； 
}
printf(“＼n”)； 
printf(” MAT A- IS： ＼n”)； 
for (i=0；  i<=2；  i )
{ for (j=0；  j<=2；  j ){
if (fabs(a［i］［j］)<0.00001) a［i］［j］=0.0；  
printf(” %8.4e “,a［i］［j］)； }
printf(“＼n”)； 
}
printf(“＼n”)； 
printf(” MAT AA- IS： ＼n”)； 
brmul(b,a,3,3,3,c)； 
for (i=0；  i<=2；  i )
{ for (j=0；  j<=2；  j ){
if (fabs(c［i］［j］)<0.00001) c［i］［j］=0.0；  
printf(” %8.4e “,c［i］［j］)； }
printf(“＼n”)； 
}
}
}
注： 函数“int brinv(double a［］,int n)”和“void brmul(double a［］,double b［］,int m,int n,int k,double c［］)”同5.5.1节程序，这里为节省篇幅略去。2） 程序运行【例5.14】求以下3阶实矩阵的逆阵。

A=2113121-10

解： 打开“3阶实矩阵求逆”文件夹，双击扩展名为DSW的文件，将进入Visual C 6.0编译环境，编译程序并执行，运行结果如下： 

运行结果中MAT A为输入的矩阵A；  MAT A-为输出的逆阵； MAT AA-为输入矩阵和逆阵的乘积。由运行结果可见，输出的逆阵为： 

A-1=1.0-0.50.51.0-0.5-0.5-21.5-0.5

输入矩阵和逆阵的乘积AA-1为

AA-1=1.00.00.00.01.00.00.00.01.0

5.5.3求4阶矩阵的逆阵程序1） 程序清单
#include “stdio.h”
#include “stdlib.h”
#include “math.h”
main()
{ 
int brinv(double a［］,int n)； 
void brmul(double a［］,double b［］,int m,int n,int k,double c［］)； 
int i,j； 
static double a［4］［4］={ {0.2368,0.2471,0.2568,1.2671},
{1.1161,0.1254,0.1397,0.1490},
{0.1582,1.1675,0.1768,0.1871},
{0.1968,0.2071,1.2168,0.2271}}； 
static double b［4］［4］,c［4］［4］； 
for (i=0；  i<=3；  i )
for (j=0；  j<=3；  j )
b［i］［j］=a［i］［j］； 
i=brinv(a,4)； 
if (i!=0)
{ printf(” MAT A IS： ＼n”)； 
for (i=0；  i<=3；  i )
{ for (j=0；  j<=3；  j ){
if (fabs(b［i］［j］)<0.00001) b［i］［j］=0.0；  
printf(” %8.4e “,b［i］［j］)； }
printf(“＼n”)； 
}
printf(“＼n”)； 
printf(” MAT A- IS： ＼n”)； 
for (i=0；  i<=3；  i )
{for (j=0；  j<=3；  j ){
if (fabs(a［i］［j］)<0.00001) a［i］［j］=0.0；  
printf(” %8.4e “,a［i］［j］)； }
printf(“＼n”)； 
}
printf(“＼n”)； 
printf(” MAT AA- IS： ＼n”)； 
brmul(b,a,4,4,4,c)； 
for (i=0；  i<=3；  i )
{ for (j=0；  j<=3；  j ){
if (fabs(c［i］［j］)<0.00001) c［i］［j］=0.0；  
printf(” %8.4e “,c［i］［j］)； }
printf(“＼n”)； 
}
}
}
注： 函数“int brinv(double a［］,int n)”和“void brmul(double a［］,double b［］,int m,int n,int k,double c［］)”同5.5.1节程序，这里为节省篇幅略去。2） 程序运行【例5.15】求以下4阶实矩阵的逆阵。

A=0.23680.24710.25681.26711.11610.12540.13970.14900.15821.16750.17680.18710.19680.20711.21680.2271

解： 打开“4阶实矩阵求逆”文件夹，双击扩展名为DSW的文件，将进入Visual C 6.0编译环境，编译程序并执行，运行结果如下： 
运行结果中MAT A为输入的矩阵A；  MAT A-为输出的逆阵； MAT AA-为输入矩阵和逆阵的乘积。由运行结果可见，输出的逆阵为： 

A-1=-0.08590.9379-0.0684-0.0796-0.1055-0.08850.9059-0.0991-0.1270-0.1113-0.11690.87840.8516-0.1354-0.1401-0.1438

输入矩阵和逆阵的乘积AA-1为

AA-1=1.00.00.00.00.01.00.00.00.00.01.00.00.00.00.01.0

5.5.4求5阶矩阵的逆阵程序1) 程序清单
#include “stdio.h”
#include “stdlib.h”
#include “math.h”
main()
{ 
int brinv(double a［］,int n)； 
void brmul(double a［］,double b［］,int m,int n,int k,double c［］)； 
int i,j； 
static double a［5］［5］={ {0.2368,0.2471,0.2568,1.2671,1.0},
{1.1161,0.1254,0.1397,0.1490,1.0},
{0.1582,1.1675,0.1768,0.1871,1.0},
{0.1582,1.1675,0.1768,0.1871,0.0},
{0.1968,0.2071,1.2168,0.2271,2.0}}； 
static double b［5］［5］,c［5］［5］； 
for (i=0；  i<=4；  i )
for (j=0；  j<=4；  j )
b［i］［j］=a［i］［j］； 
i=brinv(a,5)； 
if (i!=0)
{ printf(” MAT A IS： ＼n”)； 
for (i=0；  i<=4；  i )
{ for (j=0；  j<=4；  j ){
if (fabs(b［i］［j］)<0.00001) b［i］［j］=0.0；  
printf(” %8.4e “,b［i］［j］)； }
printf(“＼n”)； 
}
printf(“＼n”)； 
printf(” MAT A- IS： ＼n”)； 
for (i=0；  i<=4；  i )
{ for (j=0；  j<=4；  j ){
if (fabs(a［i］［j］)<0.00001) a［i］［j］=0.0；  
printf(” %8.4e “,a［i］［j］)； }
printf(“＼n”)； 
}
printf(“＼n”)； 
printf(” MAT AA- IS： ＼n”)； 
brmul(b,a,5,5,5,c)； 
for (i=0；  i<=4；  i )
{ for (j=0；  j<=4；  j ){
if (fabs(c［i］［j］)<0.00001) c［i］［j］=0.0；  
printf(” %8.4e “,c［i］［j］)； }
printf(“＼n”)； 
}
}
}
注： 函数“int brinv(double a［］,int n)”和“void brmul(double a［］,double b［］,int m,int n,int k,double c［］)”同5.5节程序，这里为节省篇幅略去。2） 程序运行【例5.16】求以下5阶实矩阵的逆阵。

A=0.23680.24710.25681.26711.01.11610.12540.13970.14901.00.15821.16750.17680.18711.00.15821.16750.17680.18710.00.19680.20711.21680.22712.0

解： 打开“5阶实矩阵求逆”文件夹，双击扩展名为DSW的文件，将进入Visual C 6.0编译环境，编译程序并执行，运行结果如下： 
运行结果中MAT A为输入的矩阵A；  MAT A-为输出的逆阵； MAT AA-为输入矩阵和逆阵的乘积。由运行结果可见，输出的逆阵为： 

A-1=-0.08590.9379-0.69280.6243-0.0796-0.1055-0.08850.39250.5134-0.0992-0.1270-0.1114-1.51841.40150.87840.8516-0.1355-0.42850.2884-0.14380.00000.00001.0000-1.0000.0000

输入矩阵和逆阵的乘积AA-1为

AA-1=1.00.00.00.00.00.01.00.00.00.00.00.01.00.00.00.00.00.01.00.00.00.00.00.01.0

5.5.5求6阶矩阵的逆阵程序1) 程序清单
#include “stdio.h”
#include “stdlib.h”
#include “math.h”
main()
{ 
int brinv(double a［］,int n)； 
void brmul(double a［］,double b［］,int m,int n,int k,double c［］)； 
int i,j； 
static double a［6］［6］={ {0.2368,0.2471,0.2568,1.2671,1.0,1.0},
{1.1161,0.1254,0.1397,0.1490,1.0,0.4},
{0.1582,1.1675,0.1768,0.1871,1.0,0.3},
{0.1582,1.1675,0.1768,0.1871,0.0,0.0},
{0.1582,1.1675,0.1768,0.1871,1.0,0.2},
{0.1968,0.2071,1.2168,0.2271,2.0,0.0}}； 
static double b［6］［6］,c［6］［6］； 
for (i=0；  i<=5；  i )
for (j=0；  j<=5；  j )
b［i］［j］=a［i］［j］； 
i=brinv(a,6)； 
if (i!=0)
{ printf(” MAT A IS： ＼n”)； 
for (i=0；  i<=5；  i )
{ for (j=0；  j<=5；  j ){
if (fabs(b［i］［j］)<0.00001) b［i］［j］=0.0；  
printf(” %7.3e “,b［i］［j］)； }
printf(“＼n”)； 
}
printf(“＼n”)； 
printf(” MAT A- IS： ＼n”)； 
for (i=0；  i<=5；  i )
{ for (j=0；  j<=5；  j ){
if (fabs(a［i］［j］)<0.00001) a［i］［j］=0.0；  
printf(” %7.3e “,a［i］［j］)； }
printf(“＼n”)； 
}
printf(“＼n”)； 
printf(” MAT AA- IS： ＼n”)； 
brmul(b,a,6,6,6,c)； 
for (i=0；  i<=5；  i )
{ for (j=0；  j<=5；  j ){
if (fabs(c［i］［j］)<0.00001) c［i］［j］=0.0；  
printf(” %7.3e “,c［i］［j］)； }
printf(“＼n”)； 
}
}
}
注： 函数“int brinv(double a［］,int n)”和“void brmul(double a［］,double b［］,int m,int n,int k,double c［］)”同5.5.1节程序，这里为节省篇幅略去。2） 程序运行【例5.17】求以下6阶实矩阵的逆阵。

A=0.23680.24710.25681.26701.01.01.11600.12540.13970.14901.00.40.15821.16800.17680.18711.00.30.15821.16800.17680.18710.00.00.15821.16800.17680.18711.00.20.19680.20711.21700.22712.00.0

解： 打开“6阶实矩阵求逆”文件夹，双击扩展名为DSW的文件，将进入Visual C 6.0编译环境，编译程序并执行，运行结果如下： 
运行结果中MAT A为输入的矩阵A；  MAT A-为输出的逆阵； MAT AA-为输入矩阵和逆阵的乘积。由运行结果可见，输出的逆阵为： 

A-1=－0.08590.9379－1.50700.62440.8141－0.0796－0.1056－0.08850.62500.5135－0.2325－0.0992－0.1271－0.11144.75301.4010－6.27100.87840.8516－0.1355－7.1170.28846.6890－0.14380.00.0－2.0－1.03.00.00.00.010.00.0－10.00.0

输入矩阵和逆阵的乘积AA-1为

AA-1= 1.00.00.00.00.00.00.01.00.00.00.00.00.00.01.00.00.00.00.00.00.01.00.00.00.00.00.00.01.00.00.00.00.00.00.01.0

5.6小结本章矩阵计算，包括用C语言程序求行列式的值、矩阵转置、矩阵相乘和矩阵求逆等。有的初学者，对行列式和矩阵的区别不甚清楚。行列式和矩阵在外观上很相似，行列式用双竖杠“||”括起来，矩阵用圆括号“( )”括起来。其实行列式是一个数，不管阶数多高的行列式终都可以算成一个数； 矩阵是一个表，不管阶数高还是低，都不能算成一个数。除非说它是矩阵行列式，那就又能算成一个数了。