Traversing 3D Arrays

Introduction

Traversing a 3D array means systematically visiting every element in the three-dimensional structure in a specific order. Unlike 1D arrays that require one loop or 2D arrays that need nested loops, 3D arrays require triple-nested loops to access each layer, row, and column.

Understanding 3D array traversal is crucial for processing complex data structures like RGB image data, 3D game worlds, scientific simulations, and multi-dimensional datasets. This lesson will teach you multiple approaches to efficiently traverse 3D arrays in Java.

What is 3D Array Traversal?

3D array traversal is the process of visiting each element in a three-dimensional array systematically. The traversal follows a specific pattern:

1. Layer by layer (depth dimension)
2. Row by row within each layer
3. Column by column within each row

Think of it like reading a book with multiple pages (layers), where you read each line (row) from left to right (columns) before moving to the next line, and complete each page before moving to the next page.

Illustration

Consider a 3D array with 2 layers, 3 rows, and 3 columns:

 Layer 0:          Layer 1:
┌─────────┐       ┌─────────┐
│ 1  2  3 │       │10 11 12 │
│ 4  5  6 │       │13 14 15 │
│ 7  8  9 │       │16 17 18 │
└─────────┘       └─────────┘

Traversal Order

Layer 0: 1 → 2 → 3 → 4 → 5 → 6 → 7 → 8 → 9
Layer 1: 10 → 11 → 12 → 13 → 14 → 15 → 16 → 17 → 18

Index access pattern

[0][0][0]=1  [0][0][1]=2  [0][0][2]=3
[0][1][0]=4  [0][1][1]=5  [0][1][2]=6
[0][2][0]=7  [0][2][1]=8  [0][2][2]=9
[1][0][0]=10 [1][0][1]=11 [1][0][2]=12
[1][1][0]=13 [1][1][1]=14 [1][1][2]=15
[1][2][0]=16 [1][2][1]=17 [1][2][2]=18

Basic 3D array operations

public class ThreeDimensionalArray {
    public static void main(String[] args) {
        // Create and initialize 3D array
        int[][][] cube = {
            {
                {1, 2, 3},
                {4, 5, 6}
            },
            {
                {7, 8, 9},
                {10, 11, 12}
            }
        };
        
        // Access elements
        System.out.println("Element at [0][0][0]: " + cube[0][0][0]); // 1
        System.out.println("Element at [1][1][2]: " + cube[1][1][2]); // 12
        
        // Modify element
        cube[0][1][1] = 99;
        System.out.println("Modified element at [0][1][1]: " + cube[0][1][1]); // 99
        
        // Get dimensions
        int depth = cube.length;           // Number of layers
        int rows = cube[0].length;         // Number of rows
        int columns = cube[0][0].length;   // Number of columns
        
        System.out.println("Dimensions: " + depth + "x" + rows + "x" + columns);
    }
}

Problem Statement

You are given a D × N × M integer 3D array. Print all elements in layer-by-layer order.

Example:

Input: cube = {
    {
        {1, 2, 3},
        {4, 5, 6}, 
        {7, 8, 9}
    },
    {
        {10, 11, 12},
        {13, 14, 15},
        {16, 17, 18}
    }
};

Output: 
Layer 0:
1 2 3 
4 5 6 
7 8 9 

Layer 1:
10 11 12 
13 14 15 
16 17 18

Method 1: Traditional Triple For-Loop

The traditional approach uses three nested for-loops to traverse each dimension systematically.

Code Implementation

public class Print3DArray {
    public static void main(String[] args) {
        int[][][] cube = {
            {
                {1, 2, 3},
                {4, 5, 6},
                {7, 8, 9}
            },
            {
                {10, 11, 12},
                {13, 14, 15},
                {16, 17, 18}
            }
        };
        
        printUsingTraditionalLoop(cube);
    }
    
    // Method 1: Traditional for-loop
    private static void printUsingTraditionalLoop(int[][][] cube) {
        int depth = cube.length;           // Number of layers
        int rows = cube[0].length;         // Number of rows per layer
        int columns = cube[0][0].length;   // Number of columns per row
        
        for (int layer = 0; layer < depth; layer++) {
            System.out.println("Layer " + layer + ":");
            for (int row = 0; row < rows; row++) {
                for (int col = 0; col < columns; col++) {
                    System.out.print(cube[layer][row][col] + " ");
                }
                System.out.println(); // New line after each row
            }
            System.out.println(); // New line after each layer
        }
    }
}

Step-by-Step Explanation

1. Get Dimensions: First, we extract the dimensions of the 3D array:

int depth = cube.length;           // 2 layers
int rows = cube[0].length;         // 3 rows per layer  
int columns = cube[0][0].length;   // 3 columns per row

2. Outer Loop (Layers): Iterates through each layer (depth dimension):

for (int layer = 0; layer < depth; layer++)

3. Middle Loop (Rows): For each layer, iterates through each row:

for (int row = 0; row < rows; row++)

4. Inner Loop (Columns): For each row, iterates through each column:

for (int col = 0; col < columns; col++)

5. Element Access: Access each element using three indices:

cube[layer][row][col]

Alternate syntax

private static void printTraditionalCompact(int[][][] cube) {
    for (int layer = 0; layer < cube.length; layer++) {
        System.out.println("Layer " + layer + ":");
        for (int row = 0; row < cube[layer].length; row++) {
            for (int col = 0; col < cube[layer][row].length; col++) {
                System.out.print(cube[layer][row][col] + " ");
            }
            System.out.println();
        }
        System.out.println();
    }
}

Method 2: Enhanced For-Loop (For-Each)

The enhanced for-loop provides cleaner, more readable code by eliminating index management.

Code Implementation

// Method 2: Enhanced for-loop (for-each)
private static void printUsingEnhancedLoop(int[][][] cube) {
    int layerIndex = 0;
    for (int[][] layer : cube) {
        System.out.println("Layer " + layerIndex + ":");
        for (int[] row : layer) {
            for (int element : row) {
                System.out.print(element + " ");
            }
            System.out.println();
        }
        System.out.println();
        layerIndex++;
    }
}

Step-by-Step Explanation

1. Layer Iteration: for (int[][] layer : cube)
   • Each layer is a 2D array representing one layer of the cube
2. Row Iteration: for (int[] row : layer)
   • Each row is a 1D array representing one row within the current layer
3. Element Iteration: for (int element : row)
   • Each element is an individual integer within the current row
4. Manual Index Tracking: Since we need layer numbers for output, we manually track layerIndex

Method 3: Functional Approach with Streams

For advanced users, Java 8+ streams provide a functional programming approach:

import java.util.Arrays;

private static void printUsingStreams(int[][][] cube) {
    for (int i = 0; i < cube.length; i++) {
        final int layerIndex = i;
        System.out.println("Layer " + layerIndex + ":");
        
        Arrays.stream(cube[i])
              .forEach(row -> {
                  Arrays.stream(row)
                        .forEach(element -> System.out.print(element + " "));
                  System.out.println();
              });
        System.out.println();
    }
}

Complete Working Example

Here's the complete program that demonstrates both traversal methods:

public class Complete3DTraversal {
    public static void main(String[] args) {
        // Create sample 3D array
        int[][][] cube = {
            {
                {1, 2, 3},
                {4, 5, 6},
                {7, 8, 9}
            },
            {
                {10, 11, 12},
                {13, 14, 15},
                {16, 17, 18}
            }
        };
        
        System.out.println("=== Traditional For-Loop Method ===");
        printUsingTraditionalLoop(cube);
        
        System.out.println("=== Enhanced For-Loop Method ===");
        printUsingEnhancedLoop(cube);
        
        System.out.println("=== Array Dimensions ===");
        printDimensions(cube);
        
        System.out.println("=== Element Count ===");
        System.out.println("Total elements: " + countElements(cube));
    }
    
    private static void printUsingTraditionalLoop(int[][][] cube) {
        int depth = cube.length;
        int rows = cube[0].length;
        int columns = cube[0][0].length;
        
        for (int layer = 0; layer < depth; layer++) {
            System.out.println("Layer " + layer + ":");
            for (int row = 0; row < rows; row++) {
                for (int col = 0; col < columns; col++) {
                    System.out.print(cube[layer][row][col] + " ");
                }
                System.out.println();
            }
            System.out.println();
        }
    }
    
    private static void printUsingEnhancedLoop(int[][][] cube) {
        int layerIndex = 0;
        for (int[][] layer : cube) {
            System.out.println("Layer " + layerIndex + ":");
            for (int[] row : layer) {
                for (int element : row) {
                    System.out.print(element + " ");
                }
                System.out.println();
            }
            System.out.println();
            layerIndex++;
        }
    }
    
    private static void printDimensions(int[][][] cube) {
        System.out.println("Depth (Layers): " + cube.length);
        System.out.println("Rows per layer: " + cube[0].length);
        System.out.println("Columns per row: " + cube[0][0].length);
    }
    
    private static int countElements(int[][][] cube) {
        return cube.length * cube[0].length * cube[0][0].length;
    }
}

Output:

=== Traditional For-Loop Method ===
Layer 0:
1 2 3 
4 5 6 
7 8 9 

Layer 1:
10 11 12 
13 14 15 
16 17 18 

=== Enhanced For-Loop Method ===
Layer 0:
1 2 3 
4 5 6 
7 8 9 

Layer 1:
10 11 12 
13 14 15 
16 17 18 

=== Array Dimensions ===
Depth (Layers): 2
Rows per layer: 3
Columns per row: 3

=== Element Count ===
Total elements: 18

Complexity Analysis

Time Complexity

1. Traditional For-Loop: O(D × N × M)

• Where D = depth, N = rows, M = columns
• Must visit every element exactly once

2. Enhanced For-Loop: O(D × N × M)

• Same time complexity as traditional approach
• Slight overhead from iterator objects

3. Space Complexity: O(1)

• No additional space used (excluding input array)
• Only variables for loop counters and temporary storage