C语言需要掌握的基础知识点之矩阵

C语言需要掌握的基础知识点之矩阵

矩阵是数学和计算机科学中的重要概念，在C语言中通常用二维数组来表示。矩阵在图形处理、科学计算、机器学习等领域有广泛应用。

矩阵的基本概念

矩阵是一个按照长方阵列排列的数值集合，由行和列组成。在C语言中，我们使用二维数组来表示矩阵。

矩阵的声明和初始化

静态矩阵

#include <stdio.h>

#define ROWS 3
#define COLS 3

void staticMatrixDemo() {
    printf("=== 静态矩阵演示 ===\n");
    
    // 方法1：声明时初始化
    int matrix1[ROWS][COLS] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    
    // 方法2：先声明后赋值
    int matrix2[ROWS][COLS];
    int value = 1;
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            matrix2[i][j] = value++;
        }
    }
    
    // 打印矩阵
    printf("矩阵1:\n");
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            printf("%d ", matrix1[i][j]);
        }
        printf("\n");
    }
    
    printf("\n矩阵2:\n");
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            printf("%d ", matrix2[i][j]);
        }
        printf("\n");
    }
}

动态矩阵

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

void dynamicMatrixDemo() {
    printf("\n=== 动态矩阵演示 ===\n");
    
    int rows, cols;
    printf("请输入矩阵的行数和列数: ");
    scanf("%d %d", &rows, &cols);
    
    // 方法1：使用指针数组（推荐）
    int **matrix1 = (int**)malloc(rows * sizeof(int*));
    for (int i = 0; i < rows; i++) {
        matrix1[i] = (int*)malloc(cols * sizeof(int));
    }
    
    // 初始化矩阵
    int counter = 1;
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            matrix1[i][j] = counter++;
        }
    }
    
    // 方法2：使用一维数组模拟二维数组
    int *matrix2 = (int*)malloc(rows * cols * sizeof(int));
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            matrix2[i * cols + j] = counter++;
        }
    }
    
    // 打印矩阵
    printf("\n方法1 - 指针数组:\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%2d ", matrix1[i][j]);
        }
        printf("\n");
    }
    
    printf("\n方法2 - 一维数组模拟:\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%2d ", matrix2[i * cols + j]);
        }
        printf("\n");
    }
    
    // 释放内存
    for (int i = 0; i < rows; i++) {
        free(matrix1[i]);
    }
    free(matrix1);
    free(matrix2);
}

矩阵的基本运算

矩阵相加

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

// 矩阵相加
int** matrixAddition(int **A, int **B, int rows, int cols) {
    int **result = (int**)malloc(rows * sizeof(int*));
    for (int i = 0; i < rows; i++) {
        result[i] = (int*)malloc(cols * sizeof(int));
        for (int j = 0; j < cols; j++) {
            result[i][j] = A[i][j] + B[i][j];
        }
    }
    return result;
}

// 创建测试矩阵
int** createTestMatrix(int rows, int cols, int startValue) {
    int **matrix = (int**)malloc(rows * sizeof(int*));
    for (int i = 0; i < rows; i++) {
        matrix[i] = (int*)malloc(cols * sizeof(int));
        for (int j = 0; j < cols; j++) {
            matrix[i][j] = startValue++;
        }
    }
    return matrix;
}

// 打印矩阵
void printMatrix(int **matrix, int rows, int cols, const char *name) {
    printf("%s:\n", name);
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%3d ", matrix[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

// 释放矩阵内存
void freeMatrix(int **matrix, int rows) {
    for (int i = 0; i < rows; i++) {
        free(matrix[i]);
    }
    free(matrix);
}

void matrixOperationsDemo() {
    printf("=== 矩阵基本运算演示 ===\n");
    
    int rows = 3, cols = 3;
    
    // 创建测试矩阵
    int **A = createTestMatrix(rows, cols, 1);
    int **B = createTestMatrix(rows, cols, 10);
    
    printMatrix(A, rows, cols, "矩阵 A");
    printMatrix(B, rows, cols, "矩阵 B");
    
    // 矩阵相加
    int **C = matrixAddition(A, B, rows, cols);
    printMatrix(C, rows, cols, "A + B");
    
    // 释放内存
    freeMatrix(A, rows);
    freeMatrix(B, rows);
    freeMatrix(C, rows);
}

矩阵相乘

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

// 矩阵相乘
int** matrixMultiplication(int **A, int **B, int rowsA, int colsA, int colsB) {
    int **result = (int**)malloc(rowsA * sizeof(int*));
    for (int i = 0; i < rowsA; i++) {
        result[i] = (int*)malloc(colsB * sizeof(int));
        for (int j = 0; j < colsB; j++) {
            result[i][j] = 0;
            for (int k = 0; k < colsA; k++) {
                result[i][j] += A[i][k] * B[k][j];
            }
        }
    }
    return result;
}

void matrixMultiplicationDemo() {
    printf("\n=== 矩阵相乘演示 ===\n");
    
    int rowsA = 2, colsA = 3;
    int rowsB = 3, colsB = 2;
    
    // 创建矩阵 A (2x3)
    int **A = (int**)malloc(rowsA * sizeof(int*));
    int value = 1;
    for (int i = 0; i < rowsA; i++) {
        A[i] = (int*)malloc(colsA * sizeof(int));
        for (int j = 0; j < colsA; j++) {
            A[i][j] = value++;
        }
    }
    
    // 创建矩阵 B (3x2)
    int **B = (int**)malloc(rowsB * sizeof(int*));
    value = 1;
    for (int i = 0; i < rowsB; i++) {
        B[i] = (int*)malloc(colsB * sizeof(int));
        for (int j = 0; j < colsB; j++) {
            B[i][j] = value++;
        }
    }
    
    printMatrix(A, rowsA, colsA, "矩阵 A (2x3)");
    printMatrix(B, rowsB, colsB, "矩阵 B (3x2)");
    
    // 矩阵相乘
    int **C = matrixMultiplication(A, B, rowsA, colsA, colsB);
    printMatrix(C, rowsA, colsB, "A × B (2x2)");
    
    freeMatrix(A, rowsA);
    freeMatrix(B, rowsB);
    freeMatrix(C, rowsA);
}

矩阵转置

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

// 矩阵转置
int** matrixTranspose(int **matrix, int rows, int cols) {
    int **transpose = (int**)malloc(cols * sizeof(int*));
    for (int i = 0; i < cols; i++) {
        transpose[i] = (int*)malloc(rows * sizeof(int));
        for (int j = 0; j < rows; j++) {
            transpose[i][j] = matrix[j][i];
        }
    }
    return transpose;
}

void matrixTransposeDemo() {
    printf("\n=== 矩阵转置演示 ===\n");
    
    int rows = 3, cols = 4;
    
    int **matrix = createTestMatrix(rows, cols, 1);
    printMatrix(matrix, rows, cols, "原矩阵");
    
    int **transpose = matrixTranspose(matrix, rows, cols);
    printMatrix(transpose, cols, rows, "转置矩阵");
    
    freeMatrix(matrix, rows);
    freeMatrix(transpose, cols);
}

高级矩阵操作

矩阵行列式计算

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

// 计算2x2矩阵的行列式
int determinant2x2(int **matrix) {
    return matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
}

// 计算3x3矩阵的行列式
int determinant3x3(int **matrix) {
    return matrix[0][0] * (matrix[1][1] * matrix[2][2] - matrix[1][2] * matrix[2][1]) -
           matrix[0][1] * (matrix[1][0] * matrix[2][2] - matrix[1][2] * matrix[2][0]) +
           matrix[0][2] * (matrix[1][0] * matrix[2][1] - matrix[1][1] * matrix[2][0]);
}

// 获取子矩阵（用于计算余子式）
int** getSubmatrix(int **matrix, int size, int row, int col) {
    int **submatrix = (int**)malloc((size-1) * sizeof(int*));
    int sub_i = 0;
    
    for (int i = 0; i < size; i++) {
        if (i == row) continue;
        
        submatrix[sub_i] = (int*)malloc((size-1) * sizeof(int));
        int sub_j = 0;
        
        for (int j = 0; j < size; j++) {
            if (j == col) continue;
            submatrix[sub_i][sub_j++] = matrix[i][j];
        }
        sub_i++;
    }
    return submatrix;
}

// 计算n阶矩阵的行列式（递归）
int determinant(int **matrix, int size) {
    if (size == 1) {
        return matrix[0][0];
    }
    if (size == 2) {
        return determinant2x2(matrix);
    }
    
    int det = 0;
    int sign = 1;
    
    for (int j = 0; j < size; j++) {
        int **submatrix = getSubmatrix(matrix, size, 0, j);
        det += sign * matrix[0][j] * determinant(submatrix, size-1);
        sign = -sign;
        
        freeMatrix(submatrix, size-1);
    }
    
    return det;
}

void determinantDemo() {
    printf("=== 矩阵行列式计算 ===\n");
    
    // 测试2x2矩阵
    int rows2 = 2;
    int **matrix2 = createTestMatrix(rows2, rows2, 1);
    printMatrix(matrix2, rows2, rows2, "2x2矩阵");
    printf("行列式: %d\n\n", determinant(matrix2, rows2));
    
    // 测试3x3矩阵
    int rows3 = 3;
    int **matrix3 = createTestMatrix(rows3, rows3, 1);
    printMatrix(matrix3, rows3, rows3, "3x3矩阵");
    printf("行列式: %d\n\n", determinant(matrix3, rows3));
    
    freeMatrix(matrix2, rows2);
    freeMatrix(matrix3, rows3);
}

矩阵求逆（伴随矩阵法）

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

// 计算代数余子式
int cofactor(int **matrix, int size, int row, int col) {
    int **submatrix = getSubmatrix(matrix, size, row, col);
    int det = determinant(submatrix, size-1);
    freeMatrix(submatrix, size-1);
    
    return ((row + col) % 2 == 0) ? det : -det;
}

// 矩阵求逆
double** matrixInverse(int **matrix, int size) {
    int det = determinant(matrix, size);
    if (det == 0) {
        printf("矩阵不可逆（行列式为0）\n");
        return NULL;
    }
    
    // 创建伴随矩阵
    double **adjugate = (double**)malloc(size * sizeof(double*));
    for (int i = 0; i < size; i++) {
        adjugate[i] = (double*)malloc(size * sizeof(double));
        for (int j = 0; j < size; j++) {
            adjugate[i][j] = (double)cofactor(matrix, size, j, i) / det;
        }
    }
    
    return adjugate;
}

// 打印浮点数矩阵
void printDoubleMatrix(double **matrix, int rows, int cols, const char *name) {
    printf("%s:\n", name);
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%8.3f ", matrix[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

void matrixInverseDemo() {
    printf("\n=== 矩阵求逆演示 ===\n");
    
    int size = 3;
    
    // 创建一个可逆矩阵
    int **matrix = (int**)malloc(size * sizeof(int*));
    matrix[0] = (int[]){2, -1, 0};
    matrix[1] = (int[]){-1, 2, -1};
    matrix[2] = (int[]){0, -1, 2};
    
    printMatrix(matrix, size, size, "原矩阵");
    
    double **inverse = matrixInverse(matrix, size);
    if (inverse != NULL) {
        printDoubleMatrix(inverse, size, size, "逆矩阵");
        
        // 验证：原矩阵 × 逆矩阵 = 单位矩阵
        printf("验证（原矩阵 × 逆矩阵 ≈ 单位矩阵）:\n");
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                double sum = 0;
                for (int k = 0; k < size; k++) {
                    sum += matrix[i][k] * inverse[k][j];
                }
                printf("%8.3f ", sum);
            }
            printf("\n");
        }
        
        // 释放逆矩阵内存
        for (int i = 0; i < size; i++) {
            free(inverse[i]);
        }
        free(inverse);
    }
    
    freeMatrix(matrix, size);
}

矩阵的应用

线性方程组求解（高斯消元法）

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

// 高斯消元法求解线性方程组
void gaussianElimination(double **A, double *b, int n) {
    // 前向消元
    for (int i = 0; i < n; i++) {
        // 部分主元选择
        int maxRow = i;
        for (int k = i + 1; k < n; k++) {
            if (fabs(A[k][i]) > fabs(A[maxRow][i])) {
                maxRow = k;
            }
        }
        
        // 交换行
        if (maxRow != i) {
            for (int k = i; k < n; k++) {
                double temp = A[i][k];
                A[i][k] = A[maxRow][k];
                A[maxRow][k] = temp;
            }
            double temp = b[i];
            b[i] = b[maxRow];
            b[maxRow] = temp;
        }
        
        // 消元
        for (int k = i + 1; k < n; k++) {
            double factor = A[k][i] / A[i][i];
            for (int j = i; j < n; j++) {
                A[k][j] -= factor * A[i][j];
            }
            b[k] -= factor * b[i];
        }
    }
    
    // 回代
    double *x = (double*)malloc(n * sizeof(double));
    for (int i = n - 1; i >= 0; i--) {
        x[i] = b[i];
        for (int j = i + 1; j < n; j++) {
            x[i] -= A[i][j] * x[j];
        }
        x[i] /= A[i][i];
    }
    
    // 输出解
    printf("方程组的解:\n");
    for (int i = 0; i < n; i++) {
        printf("x%d = %.6f\n", i + 1, x[i]);
    }
    
    free(x);
}

void linearEquationsDemo() {
    printf("\n=== 线性方程组求解（高斯消元法） ===\n");
    
    int n = 3;
    
    // 系数矩阵 A
    double **A = (double**)malloc(n * sizeof(double*));
    A[0] = (double[]){2.0, 1.0, -1.0};
    A[1] = (double[]){-3.0, -1.0, 2.0};
    A[2] = (double[]){-2.0, 1.0, 2.0};
    
    // 常数向量 b
    double *b = (double[]){8.0, -11.0, -3.0};
    
    printf("系数矩阵 A:\n");
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            printf("%6.1f ", A[i][j]);
        }
        printf("\n");
    }
    
    printf("\n常数向量 b:\n");
    for (int i = 0; i < n; i++) {
        printf("%6.1f\n", b[i]);
    }
    printf("\n");
    
    gaussianElimination(A, b, n);
    
    free(A[0]);
    free(A[1]);
    free(A[2]);
    free(A);
}

图像处理中的矩阵操作（卷积）

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

// 图像卷积操作
int** imageConvolution(int **image, int imageRows, int imageCols, 
                      double **kernel, int kernelSize) {
    int padding = kernelSize / 2;
    int outputRows = imageRows - 2 * padding;
    int outputCols = imageCols - 2 * padding;
    
    int **output = (int**)malloc(outputRows * sizeof(int*));
    for (int i = 0; i < outputRows; i++) {
        output[i] = (int*)malloc(outputCols * sizeof(int));
        for (int j = 0; j < outputCols; j++) {
            double sum = 0.0;
            
            // 应用卷积核
            for (int ki = 0; ki < kernelSize; ki++) {
                for (int kj = 0; kj < kernelSize; kj++) {
                    int image_i = i + ki;
                    int image_j = j + kj;
                    sum += image[image_i][image_j] * kernel[ki][kj];
                }
            }
            
            // 确保像素值在合理范围内
            output[i][j] = (int)sum;
            if (output[i][j] < 0) output[i][j] = 0;
            if (output[i][j] > 255) output[i][j] = 255;
        }
    }
    
    return output;
}

void imageProcessingDemo() {
    printf("\n=== 图像处理 - 卷积操作 ===\n");
    
    // 创建测试图像（6x6灰度图）
    int imageRows = 6, imageCols = 6;
    int **image = createTestMatrix(imageRows, imageCols, 10);
    
    printf("原始图像:\n");
    printMatrix(image, imageRows, imageCols, "");
    
    // 创建模糊卷积核（3x3）
    int kernelSize = 3;
    double **kernel = (double**)malloc(kernelSize * sizeof(double*));
    kernel[0] = (double[]){1/9.0, 1/9.0, 1/9.0};
    kernel[1] = (double[]){1/9.0, 1/9.0, 1/9.0};
    kernel[2] = (double[]){1/9.0, 1/9.0, 1/9.0};
    
    printf("卷积核（模糊）:\n");
    for (int i = 0; i < kernelSize; i++) {
        for (int j = 0; j < kernelSize; j++) {
            printf("%5.3f ", kernel[i][j]);
        }
        printf("\n");
    }
    printf("\n");
    
    // 应用卷积
    int **blurredImage = imageConvolution(image, imageRows, imageCols, kernel, kernelSize);
    
    printf("模糊后的图像:\n");
    printMatrix(blurredImage, imageRows - 2, imageCols - 2, "");
    
    freeMatrix(image, imageRows);
    freeMatrix(blurredImage, imageRows - 2);
    free(kernel[0]);
    free(kernel[1]);
    free(kernel[2]);
    free(kernel);
}

矩阵工具函数库

完整的矩阵操作库

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

// 矩阵结构体
typedef struct {
    double **data;
    int rows;
    int cols;
} Matrix;

// 创建矩阵
Matrix* createMatrix(int rows, int cols) {
    Matrix *matrix = (Matrix*)malloc(sizeof(Matrix));
    matrix->rows = rows;
    matrix->cols = cols;
    
    matrix->data = (double**)malloc(rows * sizeof(double*));
    for (int i = 0; i < rows; i++) {
        matrix->data[i] = (double*)malloc(cols * sizeof(double));
        for (int j = 0; j < cols; j++) {
            matrix->data[i][j] = 0.0;
        }
    }
    
    return matrix;
}

// 从数组创建矩阵
Matrix* createMatrixFromArray(double *array, int rows, int cols) {
    Matrix *matrix = createMatrix(rows, cols);
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            matrix->data[i][j] = array[i * cols + j];
        }
    }
    return matrix;
}

// 复制矩阵
Matrix* copyMatrix(Matrix *src) {
    Matrix *dest = createMatrix(src->rows, src->cols);
    for (int i = 0; i < src->rows; i++) {
        for (int j = 0; j < src->cols; j++) {
            dest->data[i][j] = src->data[i][j];
        }
    }
    return dest;
}

// 打印矩阵
void printMatrixStruct(Matrix *matrix, const char *name) {
    printf("%s (%dx%d):\n", name, matrix->rows, matrix->cols);
    for (int i = 0; i < matrix->rows; i++) {
        for (int j = 0; j < matrix->cols; j++) {
            printf("%8.3f ", matrix->data[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

// 矩阵相加
Matrix* matrixAdd(Matrix *A, Matrix *B) {
    if (A->rows != B->rows || A->cols != B->cols) {
        printf("矩阵维度不匹配，无法相加\n");
        return NULL;
    }
    
    Matrix *result = createMatrix(A->rows, A->cols);
    for (int i = 0; i < A->rows; i++) {
        for (int j = 0; j < A->cols; j++) {
            result->data[i][j] = A->data[i][j] + B->data[i][j];
        }
    }
    return result;
}

// 矩阵相乘
Matrix* matrixMultiply(Matrix *A, Matrix *B) {
    if (A->cols != B->rows) {
        printf("矩阵维度不匹配，无法相乘\n");
        return NULL;
    }
    
    Matrix *result = createMatrix(A->rows, B->cols);
    for (int i = 0; i < A->rows; i++) {
        for (int j = 0; j < B->cols; j++) {
            result->data[i][j] = 0.0;
            for (int k = 0; k < A->cols; k++) {
                result->data[i][j] += A->data[i][k] * B->data[k][j];
            }
        }
    }
    return result;
}

// 矩阵转置
Matrix* matrixTransposeStruct(Matrix *matrix) {
    Matrix *result = createMatrix(matrix->cols, matrix->rows);
    for (int i = 0; i < matrix->rows; i++) {
        for (int j = 0; j < matrix->cols; j++) {
            result->data[j][i] = matrix->data[i][j];
        }
    }
    return result;
}

// 释放矩阵内存
void freeMatrixStruct(Matrix *matrix) {
    for (int i = 0; i < matrix->rows; i++) {
        free(matrix->data[i]);
    }
    free(matrix->data);
    free(matrix);
}

void matrixLibraryDemo() {
    printf("=== 矩阵工具库演示 ===\n");
    
    // 创建矩阵
    double arrayA[] = {1, 2, 3, 4, 5, 6};
    double arrayB[] = {7, 8, 9, 10, 11, 12};
    
    Matrix *A = createMatrixFromArray(arrayA, 2, 3);
    Matrix *B = createMatrixFromArray(arrayB, 3, 2);
    
    printMatrixStruct(A, "矩阵 A");
    printMatrixStruct(B, "矩阵 B");
    
    // 矩阵相乘
    Matrix *C = matrixMultiply(A, B);
    if (C != NULL) {
        printMatrixStruct(C, "A × B");
        freeMatrixStruct(C);
    }
    
    // 矩阵转置
    Matrix *AT = matrixTransposeStruct(A);
    printMatrixStruct(AT, "A 的转置");
    
    freeMatrixStruct(A);
    freeMatrixStruct(B);
    freeMatrixStruct(AT);
}

int main() {
    staticMatrixDemo();
    dynamicMatrixDemo();
    matrixOperationsDemo();
    matrixMultiplicationDemo();
    matrixTransposeDemo();
    determinantDemo();
    matrixInverseDemo();
    linearEquationsDemo();
    imageProcessingDemo();
    matrixLibraryDemo();
    
    return 0;
}