Programa Java para Encontrar el Elemento Máximo en una Array

Dada una array 2D multidimensional de n filas y m orden de columnas N × M. La tarea es encontrar el elemento máximo en la array dada.

Ilustración:

Input  : mat[][] = { {1,3,4,19}, {11,10,12,1}, {7,9,0,4,99} }
Output : 99

Métodos:

1. Método iterativo (enfoque ingenuo)
2. Usando el principio de recursión (enfoque un poco más óptimo)

Método 1: método iterativo 

El enfoque es simple para iterar cada elemento de la array uno por uno y almacenar el máximo de dos elementos en la variable max como se usa a continuación en el programa y devuelve la variable max que contiene el elemento máximo de la array.

Ejemplo 

// Java Program to Find the Maximum Element in a Matrix
 
// Importing input output classes
import java.io.*;
 
// Main class
class GFG {
 
    // Method 1
    // To find the maximum element
    static int max(int mat[][])
    {
        // Declaring and initializing variable to unity
        // holding the maximum element value
        int max = 0;
 
        // Iterating over matrix
        // using nested for loops
 
        // Outer loop for rows
        for (int i = 0; i < mat.length; ++i) {
 
            // Inner loop for columns
            for (int j = 0; j < mat[0].length; ++j) {
 
                // Storing the maximum element
                max = Math.max(mat[i][j], max);
            }
        }
 
        // Return the maximum element
        return max;
    }
 
    // Method 2
    // Main driver method
    public static void main(String[] args)
    {
        // Custom input 2D matrix
        int mat[][] = { { 1, 3, 4, 19 },
                        { 11, 10, 12, 1 },
                        { 7, 9, 0, 99 } };
 
        // Calling the method 1 to get max element
        // and storing that integer element
        int max_element = max(mat);
 
        // Printing the maximum element
        System.out.println(max_element);
    }
}

99

Complejidad temporal: O(n ² )

Espacio Auxiliar: O(1)

Método 2: Usando el principio de recursividad 

Procedimiento:

• Llame recursivamente a cada elemento de la array al último elemento de la array.
• Devuelve el máximo del elemento actual al siguiente elemento de llamada recursiva.

Ejemplo

// Java Program to Find the Maximum Element in a Matrix
// Using Recursion
 
// Importing input output classes
import java.io.*;
 
// main class
class GFG {
 
    // Method 1
    // To find the max element
    static int max(int mat[][], int i, int j)
 
    {
        // Handling the base cases
        if (j == mat[0].length && i < mat.length) {
 
            // Changing the row and column index
            j = 0;
            ++i;
        }
 
        // Generic case
        if (i == mat.length) {
 
            // Simply return
            return 0;
        }
 
        // By far if we reach here then
        // return the max element
        return Math.max(mat[i][j], max(mat, i, j + 1));
    }
 
    // Method 2
    // Main driver method
    public static void main(String[] args)
    {
        // Custom input 2D array
        int mat[][] = { { 1, 3, 4, 19 },
                        { 11, 10, 12, 1 },
                        { 7, 9, 0, 99 } };
        // Calling the method 1 that is recursive function to
        // find out maximum element
        int max_element = max(mat, 0, 0);
 
        // Print and display the maximum element
        System.out.println(max_element);
    }
}

99

Complejidad de tiempo: O(n)

Espacio Auxiliar: O(n)