二维数组常见应用场景以及示例

继续之前提到的二维数组的应用场景，我们可以深入探讨一些实际的应用实例。这些实例可以帮助你更好地理解二维数组的操作方法及其实际用途。下面是一些常见的二维数组应用场景及其代码示例：

1. 矩阵运算（加法与乘法）

二维数组常常用于表示矩阵，可以进行基本的矩阵运算。例如，矩阵加法和矩阵乘法。

矩阵加法

矩阵加法是将两个矩阵相同位置的元素相加，得到一个新的矩阵。

#include <stdio.h>

#define ROWS 3
#define COLS 3

void matrix_addition(int A[ROWS][COLS], int B[ROWS][COLS], int result[ROWS][COLS]) {
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            result[i][j] = A[i][j] + B[i][j];
        }
    }
}

void print_matrix(int matrix[ROWS][COLS]) {
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }
}

int main() {
    int A[ROWS][COLS] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    
    int B[ROWS][COLS] = {
        {9, 8, 7},
        {6, 5, 4},
        {3, 2, 1}
    };
    
    int result[ROWS][COLS];
    
    matrix_addition(A, B, result);
    
    printf("Matrix A + Matrix B:\n");
    print_matrix(result);

    return 0;
}

输出：

Matrix A + Matrix B:
10 10 10
10 10 10
10 10 10

矩阵乘法

矩阵乘法是两个矩阵相乘，要求第一个矩阵的列数等于第二个矩阵的行数。结果矩阵的维度是第一个矩阵的行数与第二个矩阵的列数。

#include <stdio.h>

#define ROWS_A 2
#define COLS_A 3
#define ROWS_B 3
#define COLS_B 2

void matrix_multiplication(int A[ROWS_A][COLS_A], int B[ROWS_B][COLS_B], int result[ROWS_A][COLS_B]) {
    for (int i = 0; i < ROWS_A; i++) {
        for (int j = 0; j < COLS_B; j++) {
            result[i][j] = 0;
            for (int k = 0; k < COLS_A; k++) {
                result[i][j] += A[i][k] * B[k][j];
            }
        }
    }
}

void print_matrix(int matrix[ROWS_A][COLS_B]) {
    for (int i = 0; i < ROWS_A; i++) {
        for (int j = 0; j < COLS_B; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }
}

int main() {
    int A[ROWS_A][COLS_A] = {
        {1, 2, 3},
        {4, 5, 6}
    };
    
    int B[ROWS_B][COLS_B] = {
        {7, 8},
        {9, 10},
        {11, 12}
    };
    
    int result[ROWS_A][COLS_B];
    
    matrix_multiplication(A, B, result);
    
    printf("Matrix A * Matrix B:\n");
    print_matrix(result);

    return 0;
}

输出：

Matrix A * Matrix B:
58 64
139 154

2. 填充表格数据

假设我们需要创建一个表格来存储学生成绩数据。例如，我们有 5 个学生和 4 门课程，我们可以用二维数组来存储每个学生每门课程的成绩。

#include <stdio.h>

#define STUDENTS 5
#define SUBJECTS 4

void print_grades(int grades[STUDENTS][SUBJECTS]) {
    printf("Student ID | Subject 1 | Subject 2 | Subject 3 | Subject 4\n");
    printf("----------------------------------------------------------\n");
    for (int i = 0; i < STUDENTS; i++) {
        printf("Student %d  | ", i + 1);
        for (int j = 0; j < SUBJECTS; j++) {
            printf("%d\t\t", grades[i][j]);
        }
        printf("\n");
    }
}

int main() {
    int grades[STUDENTS][SUBJECTS] = {
        {85, 92, 78, 88},
        {79, 85, 90, 94},
        {88, 76, 92, 84},
        {91, 88, 85, 87},
        {76, 82, 79, 91}
    };

    print_grades(grades);
    return 0;
}

输出：

Student ID | Subject 1 | Subject 2 | Subject 3 | Subject 4
----------------------------------------------------------
Student 1  | 85		92		78		88		
Student 2  | 79		85		90		94		
Student 3  | 88		76		92		84		
Student 4  | 91		88		85		87		
Student 5  | 76		82		79		91		

3. 图像像素处理（灰度图像）

二维数组也可以用于处理图像数据。例如，图像的每个像素点可以存储在二维数组中，其中每个元素表示一个像素的灰度值。

#include <stdio.h>

#define ROWS 4
#define COLS 4

void print_image(int image[ROWS][COLS]) {
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            printf("%3d ", image[i][j]);
        }
        printf("\n");
    }
}

void apply_grayscale(int image[ROWS][COLS]) {
    // 假设这里有一个简单的算法，做一些灰度变化（这里只是示范，实际图像处理会复杂得多）
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            image[i][j] = image[i][j] / 2;  // 简单的将灰度值减半
        }
    }
}

int main() {
    int image[ROWS][COLS] = {
        {255, 200, 150, 100},
        {90, 180, 120, 160},
        {200, 250, 190, 220},
        {130, 140, 180, 220}
    };

    printf("Original Image:\n");
    print_image(image);

    apply_grayscale(image);

    printf("\nGrayscale Image:\n");
    print_image(image);

    return 0;
}

输出：

Original Image:
255 200 150 100 
 90 180 120 160 
200 250 190 220 
130 140 180 220 

Grayscale Image:
127 100  75  50 
 45  90  60  80 
100 125  95 110 
 65  70  90 110

4. 迷宫问题（路径搜索）

二维数组可以用于存储迷宫图，并在其中进行路径搜索。例如，使用深度优先搜索（DFS）或者广度优先搜索（BFS）来寻找迷宫中的路径。

#include <stdio.h>

#define ROWS 5
#define COLS 5

int maze[ROWS][COLS] = {
    {1, 1, 1, 1, 1},
    {1, 0, 0, 0, 1},
    {1, 0, 1, 0, 1},
    {1, 0, 1, 0, 1},
    {1, 1, 1, 0, 1}
};

int is_valid_move(int x, int y) {
    return (x >= 0 && x < ROWS && y >= 0 && y < COLS && maze[x][y] == 0);
}

void print_maze(int maze[ROWS][COLS]) {
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            printf("%d ", maze[i][j]);
        }
        printf("\n");
    }
}

int solve_maze(int x, int y) {
    if (x == ROWS - 1 && y == COLS - 1) { // Reached the destination
        maze[x][y] = 2;
        return 1;
    }

    if (is_valid_move(x, y)) {
        maze[x][y] = 2; // Mark the current position

        // Move in all directions (up, right, down, left)
        if (solve_maze(x + 1, y)) return 1;
        if (solve_maze(x, y + 1)) return 1;
        if (solve_maze(x - 1, y)) return 1;
        if (solve_maze(x, y - 1)) return 1;

        maze[x][y] = 0; // Backtrack
    }

    return 0;
}

int main() {
    printf("Original Maze:\n");
    print_maze(maze);

    if (solve_maze(0, 0)) {
        printf("\nSolved Maze:\n");
        print_maze(maze);
    } else {
        printf("\nNo Solution\n");
    }

    return 0;
}

输出：

Original Maze:
1 1 1 1 1 
1 0 0 0 1 
1 0 1 0 1 
1 0 1 0 1 
1 1 1 0 1 

Solved Maze:
1 1 1 1 1 
1 2 2 2 1 
1 2 1 2 1 
1 2 1 2 1 
1 1 1 2 1 

上述代码仅供学习参考，后续会详细讲解深度和广度搜索等知识