C 语言遍历多维数组的程序

2025 年 1 月 7 日 | 阅读 9 分钟

C 语言中的结构体，顾名思义，就是多维数组，它们在网格框架中充当不同维度的强大数据。与仅是一系列线性元素的一维数组不同，多维数组通过增加一个维度来进一步扩展，这使得能够以更复杂的形式存储数据。这些数组尤其适用于科学计算、图形编程和数据分析等领域，因为这些领域中的数据通常是多维的。

二维 (2D) 数组通常被称为计算机编程中最常用的多维数组。它可以被看作是一个框架，一种网格状的结构，数据可以在其中以水平方式或以方格形式排列。此表中的元素都可以由一组简单的坐标来描述，该坐标由行索引和列索引组成。例如，如果您有一个被视为电子表格的 2D 数组，其中每个单元格都是数组中的一个元素。第一个索引描述行，第二个索引描述列。这使得存储和处理通常以表格形式呈现的数据成为可能。

除了二维数组，多维数组还可以扩展到三维甚至更多维度。对于三维数组，数据可以被描述为一组二维表，其中每个表都位于不同的层，就像堆叠一样。它在三维图像等领域可能很有用，在这些领域中需要获取三维数据的宽度、高度和长度。维度超过三的多维数组也是可行的，但由于处理这种结构的复杂性增加到难以处理的程度，因此通常不使用它们。

内存布局

对于任何想要编写最有效 C 程序的人来说，理解多维数组的内存布局都非常重要。C 语言中的多维数组以行主序（row-major）形式存储，这意味着二维数组的每一行的元素都依次放置在连续的内存位置中。然而，这与某些其他编程语言中的列主序（column-major）不同，在列主序中，每一列的元素是顺序存储的。

元素按行主序排列。第一行的元素先放置，然后是第二行的元素，依此类推。这意味着如果您按顺序访问行中的元素，则意味着内存位置是连续的，因此缓存得到了更好的利用。如今的计算机体系结构都配备了内存缓存，访问连续的内存位置有助于最大程度地减少处理器需要从主慢内存或 RAM 中检索常用数据的次数。

例如，考虑一个二维数组，如矩阵。特别是，行主序意味着第一行的所有元素都放置在连续的内存地址中，第二行的元素也是如此，依此类推。这种排列意味着当您在数组中移动时，通过逐行扫描数组，您实际上是在线性访问内存，这有助于提高性能。
它还有助于程序员理解处理多维数组时可能出现的一些问题。例如，按列而不是按行读取二维数组效率低下，因为这样访问内存不是最优化的。这是因为给定列的元素不存储在连续的内存位置中。因此，当程序设计为顺序访问列时，会出现更多的缓存未命中，从而导致程序执行缓慢。

示例

1. C 语言中的基本二维数组遍历

#include <stdio.h> 
  
int main() { 
// Declare and initialize a 3x4 matrix (2D array) 
int matrix[3][4] = { 
{1, 2, 3, 4}, 
{5, 6, 7, 8}, 
{9, 10, 11, 12} 
}; 
  
// Get the number of rows and columns 
int rows = 3; 
int cols = 4; 
  
// Traverse the matrix and print each element 
    printf("The elements of the matrix are:\n"); 
for (int i = 0; i < rows; i++) { // Loop through each row 
for (int j = 0; j < cols; j++) { // Loop through each column 
            printf("%d ", matrix[i][j]); // Print the element at position [i][j] 
} 
        printf("\n"); // Move to the next line after printing each row 
} 
  
return 0; 
} 

输出

The elements of the matrix are: 
1 2 3 4  
5 6 7 8  
9 10 11 12

2. 动态二维数组遍历

#include <stdio.h> 
#include <stdlib.h> 
  
int main() { 
int rows, cols; 
  
// Ask the user for the number of rows and columns 
    printf("Enter the number of rows: "); 
    scanf("%d", &rows); 
    printf("Enter the number of columns: "); 
    scanf("%d", &cols); 
  
// Dynamically allocate memory for the 2D array 
int** matrix = (int**)malloc(rows * sizeof(int*)); 
for (int i = 0; i < rows; i++) { 
matrix[i] = (int*)malloc(cols * sizeof(int)); 
} 
  
// Fill the matrix with values 
    printf("Enter the elements of the matrix:\n"); 
for (int i = 0; i < rows; i++) { 
for (int j = 0; j < cols; j++) { 
            scanf("%d", &matrix[i][j]); 
} 
} 
  
// Traverse the matrix and print each element 
    printf("The elements of the matrix are:\n"); 
for (int i = 0; i < rows; i++) { 
for (int j = 0; j < cols; j++) { 
            printf("%d ", matrix[i][j]); 
} 
        printf("\n"); 
} 
  
// Deallocate the memory 
for (int i = 0; i < rows; i++) { 
free(matrix[i]); 
} 
free(matrix); 
  
return 0; 
} 

输出

Enter the number of rows: 3 
Enter the number of columns: 4 
Enter the elements of the matrix: 
1 2 3 4 
5 6 7 8 
9 10 11 12 
The elements of the matrix are: 
1 2 3 4 
5 6 7 8 
9 10 11 12

3. 动态三维数组遍历

#include <stdio.h> 
#include <stdlib.h> 
  
int main() { 
int x, y, z; 
  
// Get dimensions for the 3D array from the user 
    printf("Enter the size of the first dimension (x): "); 
    scanf("%d", &x); 
    printf("Enter the size of the second dimension (y): "); 
    scanf("%d", &y); 
    printf("Enter the size of the third dimension (z): "); 
    scanf("%d", &z); 
  
// Allocate memory for the 3D array 
int ***array = (int ***)malloc(x * sizeof(int **)); 
for (int i = 0; i < x; i++) { 
array[i] = (int **)malloc(y * sizeof(int *)); 
for (int j = 0; j < y; j++) { 
array[i][j] = (int *)malloc(z * sizeof(int)); 
} 
} 
  
// Fill the 3D array with values 
    printf("Enter the elements of the 3D array:\n"); 
for (int i = 0; i < x; i++) { 
for (int j = 0; j < y; j++) { 
for (int k = 0; k < z; k++) { 
                printf("Element at [%d][%d][%d]: ", i, j, k); 
                scanf("%d", &array[i][j][k]); 
} 
} 
} 
  
// Traverse and print the 3D array 
    printf("The elements of the 3D array are:\n"); 
for (int i = 0; i < x; i++) { 
for (int j = 0; j < y; j++) { 
for (int k = 0; k < z; k++) { 
                printf("%d ", array[i][j][k]); 
} 
            printf("\n"); 
} 
        printf("\n"); 
} 
  
// Free the allocated memory 
for (int i = 0; i < x; i++) { 
for (int j = 0; j < y; j++) { 
free(array[i][j]); 
} 
free(array[i]); 
} 
free(array); 
  
return 0; 
} 

输出

Enter the size of the first dimension (x): 2 
Enter the size of the second dimension (y): 2 
Enter the size of the third dimension (z): 2 
Enter the elements of the 3D array: 
Element at [0][0][0]: 1 
Element at [0][0][1]: 2 
Element at [0][1][0]: 3 
Element at [0][1][1]: 4 
Element at [1][0][0]: 5 
Element at [1][0][1]: 6 
Element at [1][1][0]: 7 
Element at [1][1][1]: 8 
The elements of the 3D array are: 
1 2  
3 4  
  
5 6  
7 8

实际应用

使用回溯法解决数独

使用回溯等方法解决数独，除了作为一种益智游戏，在现实世界中也有应用。最重要的应用领域是约束满足问题 (CSPs)，例如调度、规划和资源管理。例如，在航空公司时刻表的情况下，可以使用与解决数独非常相似的算法，将人员分配给航班，同时考虑机组人员工作时间的法律规定、每位机组人员的可用性以及他们的资质。以下是实现：

#include <stdio.h> 
  
#define UNASSIGNED 0 
#define N 9 
  
// Function to print the Sudoku grid 
void printGrid(int grid[N][N]) { 
for (int row = 0; row < N; row++) { 
for (int col = 0; col < N; col++) { 
            printf("%d ", grid[row][col]); 
} 
        printf("\n"); 
} 
} 
  
// Function to check if a number can be placed in a given cell 
int isSafe(int grid[N][N], int row, int col, int num) { 
// Check the row 
for (int x = 0; x < N; x++) { 
if (grid[row][x] == num) { 
return 0; 
} 
} 
  
// Check the column 
for (int x = 0; x < N; x++) { 
if (grid[x][col] == num) { 
return 0; 
} 
} 
  
// Check the 3x3 subgrid 
int startRow = row - row % 3, startCol = col - col % 3; 
for (int i = 0; i < 3; i++) { 
for (int j = 0; j < 3; j++) { 
if (grid[i + startRow][j + startCol] == num) { 
return 0; 
} 
} 
} 
  
return 1; 
} 
  
// Function to solve the Sudoku puzzle using backtracking 
int solveSudoku(int grid[N][N], int row, int col) { 
// If we have reached the last cell 
if (row == N - 1 && col == N) { 
return 1; 
} 
  
// Move to the next row if we've reached the end of the current row 
if (col == N) { 
row++; 
col = 0; 
} 
  
// If the current cell is already filled, move to the next cell 
if (grid[row][col] != UNASSIGNED) { 
return solveSudoku(grid, row, col + 1); 
} 
  
// Try placing numbers 1-9 in the current cell 
for (int num = 1; num <= 9; num++) { 
if (isSafe(grid, row, col, num)) { 
grid[row][col] = num; 
if (solveSudoku(grid, row, col + 1)) { 
return 1; 
} 
grid[row][col] = UNASSIGNED; // Backtrack 
} 
} 
  
return 0; // Trigger backtracking 
} 
  
int main() { 
// 0 represents an empty cell 
int grid[N][N] = { 
{5, 3, 0, 0, 7, 0, 0, 0, 0}, 
{6, 0, 0, 1, 9, 5, 0, 0, 0}, 
{0, 9, 8, 0, 0, 0, 0, 6, 0}, 
{8, 0, 0, 0, 6, 0, 0, 0, 3}, 
{4, 0, 0, 8, 0, 3, 0, 0, 1}, 
{7, 0, 0, 0, 2, 0, 0, 0, 6}, 
{0, 6, 0, 0, 0, 0, 2, 8, 0}, 
{0, 0, 0, 4, 1, 9, 0, 0, 5}, 
{0, 0, 0, 0, 8, 0, 0, 7, 9} 
}; 
  
if (solveSudoku(grid, 0, 0)) { 
        printf("Solved Sudoku grid:\n"); 
        printGrid(grid); 
} else { 
        printf("No solution exists.\n"); 
} 
  
return 0; 
} 

输出

Solved Sudoku grid: 
5 3 4 6 7 8 9 1 2  
6 7 2 1 9 5 3 4 8  
1 9 8 3 4 2 5 6 7  
8 5 9 7 6 1 4 2 3  
4 2 6 8 5 3 7 9 1  
7 1 3 9 2 4 8 5 6  
9 6 1 5 3 7 2 8 4  
2 8 7 4 1 9 6 3 5  
3 4 5 2 8 6 1 7 9

结论

总之，C 语言中遍历多维数组的过程是创造和分析各种计算任务解决方案的许多潜力的关键主题之一。从遍历基本二维矩阵的简单概念到实现使用回溯法解决数独等更复杂的事物，它们都构成了大多数高级编程问题的基础。高效且动态地完成多维数组的多个操作，使开发人员能够处理与科学计算、数据分析和实时模拟相关的大量数据。

此外，值得注意的是，这些技术不仅适用于课堂或示例，如下所示。无论是数字电路设计、涉及调度、资源管理的方程求解，还是生物信息学，处理数据结构的便捷性都是一项宝贵的财富。因此，掌握这些数组遍历技术有助于程序员设计出更好、更优、更可靠的算法，这不仅对研究人员和科学家很重要，而且对现代计算机系统的实际应用也很重要。因此，该主题在很大程度上巩固了编程的基础，同时还考虑了通用知识以及为技术和科学各个领域的复杂问题做准备。

下一主题Johnson 算法 C 语言实现

C 语言遍历多维数组的程序

内存布局

示例

1. C 语言中的基本二维数组遍历

2. 动态二维数组遍历

3. 动态三维数组遍历

实际应用

使用回溯法解决数独

结论

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

C 语言教程

C 语言控制语句

C 语言函数

C 语言数组

C 语言指针

C 语言动态内存

C 语言字符串

C 语言数学

C 语言结构体和联合体

C 语言文件处理

C 语言预处理器

C 语言命令行

C 语言程序

C 语言面试

选择题

C 语言编程测试

C 语言基础测试

C 语言控制语句测试

C 语言函数测试

C 语言数组测试

C 语言指针测试

C 语言字符串测试

C 语言结构体测试

C 语言预处理器测试

数学

C 语言杂项

C 语言遍历多维数组的程序

内存布局

示例

1. C 语言中的基本二维数组遍历

2. 动态二维数组遍历

3. 动态三维数组遍历

实际应用

使用回溯法解决数独

结论

相关帖子

C 语言尾调用优化

C 语言 LRU 页替换算法

C 语言逻辑错误

C 语言特征值计算

C 语言约瑟夫问题

数据段

C 语言 printf, sprintf 和 fprintf 的区别

C 语言嵌套 switch case

C 语言用户定义数据类型

关于 C 语言的有趣事实

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器