# Linear Search in a 3D Array with Java

10

Linear Search in a 3D Array with Java

Linear Search, a versatile algorithm for element retrieval, becomes a fascinating exploration when applied to three-dimensional (3D) arrays. In this guide, we’ll dive into the intricacies of implementing Linear Search in a 3D array using Java, unravelling the complexities of navigating through multi-dimensional data structures.

Understanding 3D Array Linear Search:

Searching for a specific element in a 3D array involves traversing not only rows and columns but also the depth of the array. Systematically check each element in a 3D array until you find the desired target or explore the entire array. This algorithmic approach sets the groundwork for efficient searching in multidimensional datasets.

### Linear Search in a 3D Array Program:

Program – Linear Search in 3D Array
``````public class LinearSearch3D {
// Method: Perform Linear Search in a 3D array
public static int[] linearSearch3D(int[][][] array, int target) {
// Loop through layers
for (int i = 0; i < array.length; i++) {
// Loop through rows in each layer
for (int j = 0; j < array[i].length; j++) {
// Loop through columns in each row
for (int k = 0; k < array[i][j].length; k++) {
if (array[i][j][k] == target) {
// Return indices when finding the target element
return new int[]{i, j, k};
}
}
}
}
// Return {-1, -1, -1} if the target element is not found in the 3D array
return new int[]{-1, -1, -1};
}

// Main method: Test Linear Search in 3D array
public static void main(String[] args) {
// Example 3D array
int[][][] array3D = {
{{1, 2, 3}, {4, 5, 6}},
{{7, 8, 9}, {10, 11, 12}}
};
int targetElement = 11; // Target element for demonstration

// Perform Linear Search and store the result in the 'result' array
int[] result = linearSearch3D(array3D, targetElement);

// Targeted element
System.out.println("Element to find: "+targetElement);
// Check if the target element was found and print the result accordingly
if (result[0] != -1) {
System.out.println("Found element " + targetElement + " at position: (" + result[0] + ", " + result[1] + ", " + result[2] + ")");
} else {
System.out.println("Element " + targetElement + " not found in the 3D array");
}
}
}``````

### Breaking Down the Implementation:

Let’s break down the Java program that implements Linear Search in a 3D array:

Method `linearSearch3D`:

• This method performs Linear Search in a 3D array.
• It takes a 3D array (`array`) and a target element (`target`) as parameters.
• The method uses nested loops to traverse through layers (`i`), rows (`j`), and columns (`k`) of the 3D array.
• If the target element is found, it returns an array containing the indices (`new int[]{i, j, k}`).
• If the algorithm doesn’t find the target element, it returns {-1, -1, -1}.

Main Method:

• In the `main` method, an example 3D array (`array3D`) is declared and initialized.
• The target element (`targetElement`) is set to 11 for demonstration purposes.
• The `linearSearch3D` method is called with the 3D array and the target element, and the result is stored in the `result` array.
• The program then checks if the first index of the result is not -1. If the condition is true, the program prints the position where it found the element. If false, it prints a message indicating the element’s absence in the 3D array.

Output:

Output – Linear Search in 3D Array
``````Element to find: 11
Found element 11 at position: (1, 1, 1)``````

Conclusion:

Implementing Linear Search in a 3D array opens up new dimensions of understanding array manipulation in Java. This foundational knowledge lays the groundwork for more complex algorithms and efficient data retrieval in multidimensional scenarios. Happy coding!