上三角矩阵行列式C语言求解：主对角线乘积的代码实现
行列式这个概念在高等代数里挺绕的，但咱们今天要聊的上三角矩阵行列式，简直就是开挂级别的简单。你想想，一个矩阵里，主对角线以下全都是零，这不就是给咱们省去了大半的计算量嘛。接下来我就带你一步步把这个事儿捋清楚，代码也会写得明明白白的。
先别急着看代码，咱们得先把”为什么上三角矩阵的行列式等于主对角线乘积”这个事儿想明白，不然敲代码就是无脑复制粘贴，回头换了个需求还是不会。
上三角矩阵长啥样
所谓上三角矩阵，就是一个方阵，它的主对角线以下的所有元素都是0。
举个例子，一个3阶的上三角矩阵长这样：
\[ A = \begin{pmatrix} 2 & 3 & 5 \\ 0 & 4 & 7 \\ 0 & 0 & 6 \end{pmatrix} \]
你看，第二行第一列是0，第三行第一列、第二列也都是0。这个0填得整整齐齐，就像楼梯一样往上走。
如果是4阶的呢？
\[ B = \begin{pmatrix} 1 & 2 & 3 & 4 \\ 0 & 5 & 6 & 7 \\ 0 & 0 & 8 & 9 \\ 0 & 0 & 0 & 10 \end{pmatrix} \]
规律很明显：当行号大于列号时，元素为0，也就是所有满足 i > j 的位置都是0。
为什么主对角线乘积就是行列式
这一步是关键，咱用小学都能懂的方式来想。
行列式有一个基本性质：如果把某一行乘以一个数加到另一行上去，行列式的值不变。这个性质叫”行变换不改变行列式”。
对于一般的方阵，计算行列式最常用的方法就是高斯消元法——通过行变换把矩阵变成上三角矩阵，然后行列式就等于主对角线的乘积。
但是！如果你拿到的矩阵本身就是上三角矩阵，那高斯消元这一步都省了，直接：
\[ \det(A) = a_{11} \times a_{22} \times a_{33} \times \cdots \times a_{nn} \]
拿上面那个3阶的例子验证一下：
\[ \det(A) = 2 \times 4 \times 6 = 48 \]
不信？你可以用拉普拉斯展开验证。按第一列展开：
\[ \det(A) = 2 \times \begin{vmatrix} 4 & 7 \\ 0 & 6 \end{vmatrix} = 2 \times (4 \times 6 - 7 \times 0) = 2 \times 24 = 48 \]
再按第二列展开那个二阶行列式：
\[ = 2 \times 4 \times 6 = 48 \]
结果完全一致。推广到n阶，证明思路也是类似的——每次按第一列展开，都会消掉一阶，最后就是主对角线元素一路乘到底。
所以记住这一条就够了：上三角矩阵的行列式 = 主对角线元素之积。就是这么任性。
C语言实现
下面我把完整的代码给你写出来，包含详细的注释，保证你看了就能上手。
基础版本：直接计算上三角矩阵的行列式
#include <stdio.h>
/**
* 计算上三角矩阵的行列式
* @param matrix n x n 的二维数组，存储上三角矩阵
* @param n 矩阵的阶数
* @return 行列式的值
*/
double determinantUpperTriangular(double matrix[][100], int n) {
double det = 1.0; // 行列式的初始值为1（乘法单位元）
// 遍历主对角线上的每一个元素，连乘
for (int i = 0; i < n; i++) {
det *= matrix[i][i];
}
return det;
}
int main() {
// 定义一个3阶上三角矩阵
double matrix[3][100] = {
{2.0, 3.0, 5.0},
{0.0, 4.0, 7.0},
{0.0, 0.0, 6.0}
};
int n = 3;
double result = determinantUpperTriangular(matrix, n);
printf("上三角矩阵的行列式为: %.2f\n", result);
// 输出结果应该是 48.00
return 0;
}
运行这段代码，你会看到输出：
上三角矩阵的行列式为: 48.00
进阶版本：带输入验证的通用实现
实际编程中，我们可能需要从用户输入读取矩阵，或者需要判断这个矩阵到底是不是上三角矩阵。下面这个版本更完整：
#include <stdio.h>
#include <stdbool.h>
#include <math.h>
#define EPSILON 1e-9 // 浮点数比较的容差
/**
* 检查一个矩阵是否为上三角矩阵
* @param matrix n x n 的二维数组
* @param n 矩阵的阶数
* @return 如果是上三角矩阵返回true，否则返回false
*/
bool isUpperTriangular(double matrix[][100], int n) {
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
// 主对角线以下（i > j）的元素应该为0
if (fabs(matrix[i][j]) > EPSILON) {
return false;
}
}
}
return true;
}
/**
* 计算上三角矩阵的行列式
* @param matrix n x n 的二维数组，存储上三角矩阵
* @param n 矩阵的阶数
* @return 行列式的值；如果矩阵不是上三角矩阵则返回NaN
*/
double determinantUpperTriangular(double matrix[][100], int n) {
// 先验证矩阵是否真的是上三角矩阵
if (!isUpperTriangular(matrix, n)) {
printf("警告：该矩阵不是上三角矩阵！\n");
return 0.0 / 0.0; // 返回NaN表示非法输入
}
double det = 1.0;
// 主对角线元素连乘
for (int i = 0; i < n; i++) {
det *= matrix[i][i];
}
return det;
}
/**
* 打印矩阵（方便调试和查看）
*/
void printMatrix(double matrix[][100], int n) {
printf("矩阵内容 (%d阶):\n", n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
printf("%10.2f", matrix[i][j]);
}
printf("\n");
}
printf("\n");
}
int main() {
// ========== 测试用例1：标准的3阶上三角矩阵 ==========
double matrix1[3][100] = {
{2.0, 3.0, 5.0},
{0.0, 4.0, 7.0},
{0.0, 0.0, 6.0}
};
printf("===== 测试用例1 =====\n");
printMatrix(matrix1, 3);
double result1 = determinantUpperTriangular(matrix1, 3);
printf("行列式 = %.2f (预期: 48.00)\n\n", result1);
// ========== 测试用例2：对角矩阵（特殊的上三角矩阵） ==========
double matrix2[4][100] = {
{1.0, 0.0, 0.0, 0.0},
{0.0, 5.0, 0.0, 0.0},
{0.0, 0.0, 8.0, 0.0},
{0.0, 0.0, 0.0, 10.0}
};
printf("===== 测试用例2 =====\n");
printMatrix(matrix2, 4);
double result2 = determinantUpperTriangular(matrix2, 4);
printf("行列式 = %.2f (预期: 400.00)\n\n", result2);
// ========== 测试用例3：不是上三角矩阵（测试验证功能） ==========
double matrix3[3][100] = {
{1.0, 2.0, 3.0},
{4.0, 5.0, 6.0}, // 这个4.0打破了上三角结构
{0.0, 0.0, 7.0}
};
printf("===== 测试用例3（非上三角矩阵，测试验证） =====\n");
printMatrix(matrix3, 3);
double result3 = determinantUpperTriangular(matrix3, 3);
printf("行列式 = %s (预期: 非法输入提示)\n\n",
result3 != result3 ? "NaN (非法)" : "错误");
return 0;
}
这个程序的输出结果：
===== 测试用例1 =====
矩阵内容 (3阶):
2.00 3.00 5.00
0.00 4.00 7.00
0.00 0.00 6.00
行列式 = 48.00 (预期: 48.00)
===== 测试用例2 =====
矩阵内容 (4阶):
1.00 0.00 0.00 0.00
0.00 5.00 0.00 0.00
0.00 0.00 8.00 0.00
0.00 0.00 0.00 10.00
行列式 = 400.00 (预期: 400.00)
===== 测试用例3（非上三角矩阵，测试验证） =====
矩阵内容 (3阶):
1.00 2.00 3.00
4.00 5.00 6.00
0.00 0.00 7.00
警告：该矩阵不是上三角矩阵！
行列式 = NaN (非法) (预期: 非法输入提示)
从键盘输入的版本
如果你想在运行的时候自己输入矩阵，可以用下面这个版本：
#include <stdio.h>
#include <stdbool.h>
#include <math.h>
#define EPSILON 1e-9
/**
* 检查是否为上三角矩阵
*/
bool isUpperTriangular(double matrix[][100], int n) {
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (fabs(matrix[i][j]) > EPSILON) {
return false;
}
}
}
return true;
}
/**
* 计算上三角矩阵的行列式
*/
double determinantUpperTriangular(double matrix[][100], int n) {
if (!isUpperTriangular(matrix, n)) {
return 0.0 / 0.0;
}
double det = 1.0;
for (int i = 0; i < n; i++) {
det *= matrix[i][i];
}
return det;
}
int main() {
int n;
printf("请输入矩阵的阶数 n: ");
scanf("%d", &n);
if (n <= 0) {
printf("阶数必须为正整数！\n");
return 1;
}
// 动态创建矩阵（使用变长数组，C99标准支持）
double matrix[n][n];
printf("请输入 %d x %d 矩阵的元素（行优先顺序）:\n", n, n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
printf(" matrix[%d][%d] = ", i, j);
scanf("%lf", &matrix[i][j]);
}
}
printf("\n你输入的矩阵为:\n");
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
printf("%10.2f", matrix[i][j]);
}
printf("\n");
}
if (isUpperTriangular(matrix, n)) {
printf("\n✓ 这是一个上三角矩阵\n");
double det = determinantUpperTriangular(matrix, n);
printf("行列式的值 = %.6f\n", det);
// 显示计算过程
printf("计算过程: ");
for (int i = 0; i < n; i++) {
if (i > 0) printf(" × ");
printf("%.2f", matrix[i][i]);
}
printf(" = %.6f\n", det);
} else {
printf("\n✗ 这不是一个上三角矩阵，无法用主对角线乘积法计算行列式\n");
printf(" 请使用高斯消元法将其化为上三角矩阵后再计算。\n");
}
return 0;
}
运行这个程序，输入一个3阶上三角矩阵：
请输入矩阵的阶数 n: 3
请输入 3 x 3 矩阵的元素（行优先顺序）:
matrix[0][0] = 2
matrix[0][1] = 3
matrix[0][2] = 5
matrix[1][0] = 0
matrix[1][1] = 4
matrix[1][2] = 7
matrix[2][0] = 0
matrix[2][1] = 0
matrix[2][2] = 6
你输入的矩阵为:
2.00 3.00 5.00
0.00 4.00 7.00
0.00 0.00 6.00
✓ 这是一个上三角矩阵
行列式的值 = 48.000000
计算过程: 2.00 × 4.00 × 6.00 = 48.000000
一些重要的细节
写代码的时候有几个小坑，我在这儿提醒你一下，免得你踩进去。
1. 关于数据类型
上面用的是 double，这是因为行列式的计算结果可能是小数。如果你的矩阵元素全是整数，且你确定结果也是整数，用 int 也行，但不推荐。因为实际应用中，矩阵元素经常来自测量或中间计算结果，会有小数，double 兼容性更好。
不过要注意浮点数的精度问题。当矩阵阶数比较高（比如20阶以上），主对角线元素又比较小时，连乘可能会导致下溢（结果趋近于0）；如果主对角线元素比较大，又可能上溢。遇到这种情况，可以用对数域来计算：
\[ \ln|\det(A)| = \sum_{i=1}^{n} \ln|a_{ii}| \]
最后再取指数。但这种情况比较罕见，大多数课程作业用 double 就够了。
2. 矩阵阶数为0的情况
严格来说，0阶矩阵的行列式定义为1（空积）。不过实际编程中很少遇到这种情况，如果输入 n=0，上面的代码返回的是 det=1.0，这是符合数学定义的。
3. 主对角线有0元素
如果主对角线上有一个元素是0，那行列式就是0。这是正确的，因为上三角矩阵可逆的充要条件就是所有主对角线元素都不为0。代码里不需要特殊处理，det *= 0 自然就是0了。
如果矩阵不是上三角怎么办？
你可能会问：如果给我的矩阵不是上三角的，是不是就没法用了？
当然不是。任何一个方阵都可以通过高斯消元法化为上三角矩阵。行变换过程中，行列式的变化规则如下：
- 交换两行：行列式变号（乘以-1）
- 某一行乘以非零常数k：行列式变为原来的k倍
- 某一行加上另一行的k倍：行列式不变
所以完整的思路是：先通过行变换把矩阵化成上三角形式，记录变换过程中行列式的变化，最后用主对角线乘积乘以相应的系数就行。
这里给一个完整的通用方阵行列式求解代码，包含高斯消元的过程：
#include <stdio.h>
#include <math.h>
#define EPSILON 1e-9
#define MAX_N 100
/**
* 通用方阵行列式计算（高斯消元法）
* 通过行变换化为上三角矩阵后计算
*/
double determinant(double matrix[][MAX_N], int n) {
double det = 1.0;
double temp;
// 复制矩阵，避免修改原矩阵
double mat[MAX_N][MAX_N];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
mat[i][j] = matrix[i][j];
}
}
// 高斯消元：将矩阵化为上三角形式
for (int col = 0; col < n; col++) {
// 找主元（当前列中绝对值最大的行，用于数值稳定性）
int maxRow = col;
for (int row = col + 1; row < n; row++) {
if (fabs(mat[row][col]) > fabs(mat[maxRow][col])) {
maxRow = row;
}
}
// 交换当前行和最大行
if (maxRow != col) {
for (int j = col; j < n; j++) {
temp = mat[col][j];
mat[col][j] = mat[maxRow][j];
mat[maxRow][j] = temp;
}
det *= -1.0; // 交换两行，行列式变号
}
// 检查主元是否为零
if (fabs(mat[col][col]) < EPSILON) {
return 0.0; // 行列式为0（矩阵奇异）
}
// 消去主元下方的元素
for (int row = col + 1; row < n; row++) {
double factor = mat[row][col] / mat[col][col];
for (int j = col; j < n; j++) {
mat[row][j] -= factor * mat[col][j];
}
// mat[row][col] 理论上变为0
}
}
// 上三角矩阵的行列式 = 主对角线乘积
for (int i = 0; i < n; i++) {
det *= mat[i][i];
}
return det;
}
int main() {
// 测试：一个普通的4阶方阵
double matrix[4][MAX_N] = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12},
{13,14, 15, 16}
};
printf("4阶方阵的行列式 = %.6f\n", determinant(matrix, 4));
// 这个矩阵的行之间线性相关，行列式应该为0
// 测试：一个非奇异的3阶方阵
double matrix2[3][MAX_N] = {
{2, 1, 3},
{1, -2, 4},
{3, 5, -1}
};
printf("3阶方阵的行列式 = %.6f\n", determinant(matrix2, 3));
// 手动验证: 2(2+20) - 1(-1-12) + 3(5+6) = 44 + 13 + 33 = 90
return 0;
}
这个通用版本用了列主元消元法（每次选当前列绝对值最大的元素做主元），这样做的好处是数值稳定性更好，不容易因为主元太小导致计算误差放大。
总结一下
上三角矩阵行列式的计算就是这么简单——主对角线元素相乘，代码也就几行。但背后的数学原理值得理解：高斯消元法把任意方阵化为上三角形式，行列式的性质保证了变换过程中（除了行交换）值不变，所以最后取主对角线乘积就是答案。
如果你是在做课程作业或者面试题，把第一个基础版本记住就够了。如果是实际工程应用，建议用通用版本，因为它不要求输入矩阵已经是上三角形式。
有什么不清楚的地方，或者想深入探讨高斯消元的过程，随时问我！