Programa Java para obtener el elemento máximo de un vector

Prerrequisito: Vectores en Java

¿Por qué usamos vectores?

Hasta ahora, hemos aprendido dos formas de declarar, ya sea con un tamaño fijo de array o una entrada de tamaño según la demanda del usuario según la array asignada en la memoria. 

int Array_name[Fixed_size] ;
int array_name[variable_size] ;

En ambos sentidos, terminamos desperdiciando memoria, por lo que se introducen vectores de optimización de memoria para utilizar correctamente.

Ventajas de usar vectores 

• Tamaño dinámico
• Funciones de biblioteca enriquecidas
• Tamaño fácil de saber.
• No es necesario pasar el tamaño
• Puede ser devuelto desde una función.
• Por defecto se inicializa con valores por defecto

Las funciones de biblioteca enriquecidas incluyen

1. Encuentra un elemento
2. Borrar un elemento
3. Insertar un elemento

Aquí, usamos funciones de biblioteca enriquecidas para obtener un elemento máximo.

Nota: Los arreglos siempre se pasan como un puntero en los arreglos, por lo que otro parámetro que debe pasar es el tamaño del arreglo, pero eso no es necesario en el caso de los vectores. 

Sintaxis:

En el caso de arrays

type function_Name(type arrayName[], type sizeOfArray) ;

En el caso de Vectores

type function_Name(vector<type> vectorName) ;

Considerando un ejemplo dado un vector, la tarea es encontrar el elemento máximo. 

Ejemplos:

Entrada: v1={1,2,3,4,5}

Salida: 5

Entrada: v2={7,50,0,67,98}

Salida: 98

Método 1: usar una función predefinida

• Primero , inicializaremos un vector, digamos v, luego almacenaremos valores en ese vector.
• Después de eso , llamaremos al método predefinido llamado max() definido en la clase java.util.Collections.
• Imprime el elemento max.

A continuación se muestra la implementación del enfoque anterior.

// Java Program to find maximum element
// in a vector using predefined method
  
import java.io.*;
 
// Importing Vector Class
import java.util.Collections;
 
// Importing Vector Class
import java.util.Vector;
 
class GFG {
   
    // Main Method
    public static void main(String[] args)
    {
        // initializing a Vector
        Vector<Integer> v = new Vector<Integer>();
       
        // adding values to the Vector
        v.add(7);
        v.add(50);
        v.add(0);
        v.add(67);
        v.add(98);
       
        // finding the largest element
        int n = Collections.max(v);
       
        // printing the largest element
        System.out.println(
            "The maximum value present in Vector is : "
            + n);
    }
}

Producción :

The maximum value present in Vector is : 98

Complejidad temporal en el peor de los casos: O(n) donde n es el número de elementos presentes en el vector.

Método 2: Comparando cada elemento presente en Vector

• Primero, inicializaremos un vector, digamos v, luego almacenaremos valores en ese vector.
• A continuación, tomaremos una variable, digamos maxNumber y le asignaremos el valor mínimo posible.
• Recorra hasta el final del vector y compare cada elemento de un vector con maxNumber.
• Si el elemento presente en el vector es mayor que maxNumber, actualice maxNumber a ese valor.
• Imprimir maxNumber.

A continuación se muestra la implementación del enfoque anterior.

// Java program to find largest element
// present in Vector via comparison
 
import java.io.*;
 
// Importing Vector Class
import java.util.Vector;
 
// Importing Iterator Class
import java.util.Iterator;
 
class GFG {
   
    // Main Method
    public static void main(String[] args)
    {
        // initializing vector of Integer type
        Vector<Integer> v = new Vector<Integer>();
       
        // Adding elements in vector
        v.add(1);
        v.add(2);
        v.add(3);
        v.add(4);
        v.add(5);
       
        // Assigning min value possible
        int maxValue = Integer.MIN_VALUE;
       
        // Creating an iterator to traverse through vector
        // in the beginning itr will point to index just
        // before first element
        Iterator itr = v.iterator();
       
        // See if there is any next element
        while (itr.hasNext())
        {
            // Moving iterator to next element
            int element = (Integer)itr.next();
 
            // Comparing if element is larger than maxValue
            if (element > maxValue)
            {
                // Update maxValue
                maxValue = element;
            }
        }
       
        // Print maxVaue
        System.out.println(
            "The largest element present in Vector is : "
            + maxValue);
    }
}

Producción :

The largest element present in Vector is : 5

Complejidad temporal: O(n) donde n es el número de elementos presentes en el vector.