C Program to Traverse a Multidimensional Array

Structures in C are namely multidimensional arrays, and they work as powerful data of different dimensions in the framework of a grid. Unlike one-dimensional arrays, which are just linear sets of elements, multidimensional arrays go further by having one more dimension, and this allows the storing of data in more complex forms. These arrays are especially suitable in a range of applications such as scientific computing, graphics programming, and data analysis, in which the data is normally multidimensional.

The two-dimensional (2D) array is often referred to as the multidimensional array that is frequently used in computer programming. It can be thought of as a framework, a grid-like structure in which data is arranged either in a horizontal manner or in boxes. The elements in this table can all be described by a simple set of coordinates, which consists of the row index and the column index. For example, if you have a 2D array that is put as a spreadsheet where each cell is an element in the array. The first index would describe the row, while the second index would describe the column. This makes it possible to store and process data that are most often presented in a tabular form.

In addition to 2D arrays, multidimensional arrays can go up to 3D or even more dimensions. In the case of the 3D array data can be described as a set of 2D tables where each table is at a different level as in a stack. It can come in handy in areas, for instance, in 3D images where it is needed to get the width, height, and length of some 3D data. Multidimensional arrays with dimensions of more than three are also feasible but are not usually used as the complexity of dealing with such a structure increase to a level that cannot be easily handled.

Memory Layout

The memory layout of multidimensional arrays is very important to be understood by anyone who would like to write the most efficient C programs. The multidimensional arrays in C are stored in a row-major form that implies that the elements of each row of a two-dimensional array are placed in consecutive memory locations one after the other. This is, however, different from the column-major order that exists in some other programming languages wherein elements of each column are stored sequentially.

The elements are in row-major order. The elements of the first row are placed first, then the aspects of the second row, and this is followed by the sequence. This means that if you are accessing elements in a row in sequence, then this implies that the memory locations are consecutive and, hence, better utilization of the cache. Today's computer architectures are accompanied by memory caches where accessing sequential memory locations can help minimize the times that the processor needs to retrieve frequently used data from the main slow memory or RAM.

For instance, consider a 2-D array such as a matrix. In particular, row-major order means that all the elements of the first row are placed into consecutive memory addresses, same with elements of the second row and so on. This arrangement implies that as you move around the array, scanning through it based on the row-by-row format, you are actually accessing the memory linearly, which helps in improving performance.
It also helps the programmer to grasp some issues which may occur when working with multidimensional arrays. For instance, it is unproductive to read a 2D array by columns instead of rows because memory access is not optimized in this way. This is because the elements of a given column are not stored in consecutive memory locations. Hence, when a program is designed to access the columns sequentially, there will be more cache misses, hence slow execution of the program.

Examples:

1. Basic 2D Array Traversal in 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; 
} 

Output:

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

2. Dynamic 2D Array Traversal

#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; 
} 

Output:

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. Dynamic 3D Array Traversal

#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; 
} 

Output:

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

Real-Life Application

Sudoku Solver using Backtracking

Sudoku solving using methods like backtracking does apply in the real-world in addition to being a puzzle game. The most important area of application is in CSPs, which can be found in such areas as scheduling, planning, and resource management. For example, in the case of airline timetables, one can use algorithms that are quite close to solving the Sudoku with regard to the assignment of the personnel to flights, taking into account legal provisions on crew members' working time, the availability of each crew member, and his or her qualifications. Here is the implementation:

#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; 
} 

Output:

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

Conclusion:

In conclusion, the process of traversing multidimensional arrays in C is one of the key topics that creates a lot of potential for the creation and analysis of solutions to various computational tasks. Even simple concepts like iterating over a basic 2D matrix up to more complex things, such as the implementation of a Sudoku solver using backtracking, all form the basis for most advanced programming problems. Accomplishing multiple operations of multidimensional arrays in an efficient and dynamic manner enables the developer to handle high volumes of data pertinent to scientific computing, data analysis, and real-time simulation.

It is also important to note that the application of these techniques is not only applicable to classrooms or examples, as shown below. Whether it be in digital circuit design, equation solving involving scheduling, resource management, or even bioinformatics, ease of manipulating data structures is a great asset to have. Thus, having the knowledge of these array traversal techniques helps programmers to work out better, optimized, and reliable algorithms, which are important not only for researchers and scientists but also for practical applications of modern computer systems. Therefore, this topic strengthens the bases of programming in particular, with an additional consideration of general knowledge and preparation for solving complex problems in various fields of technology and science.

Next TopicJohnson-algorithm-in-c

← prev next →