Programa Java para encontrar 2 elementos en la array de modo que la diferencia entre ellos sea mayor

Una array es la estructura de datos más eficiente que está diseñada para almacenar y acceder a un grupo de objetos. Dada una array de enteros, nuestra tarea es encontrar dos elementos de esa array tales que la diferencia entre ellos sea la máxima.

Discutiremos dos enfoques:

1. Comparando y verificando la diferencia entre cada par posible ejecutando dos bucles.
2. Calculando los valores mínimo y máximo de la array y devolviendo la diferencia entre ellos.

Input : arr = {2, 3, 10, 6, 4, 8, 1}
Output : Two elements with largest difference: 10 and 1
Explanation : The maximum difference is between 10 and 1.
 
Input : arr = {-7, 9, 5, 6, 3, 2}
Output : Two elements with largest difference:  9 and -7
Explanation : The maximum difference is between 9 and -7.
 
Input : arr = {10, 11, 88, 2, 12, 120}
Output : Two elements with largest difference:  2 and 120
Explanation : The maximum difference is between 2 and 120.

Método 1: comparando y verificando la diferencia entre cada par posible ejecutando dos bucles

• Usa dos bucles. En el ciclo externo, seleccione los elementos uno por uno y, en el ciclo interno, calcule la diferencia del elemento seleccionado con todos los demás elementos de la array.
• Y simultáneamente compare la diferencia con la diferencia máxima calculada hasta el momento.
• Verifique todas las diferencias posibles entre 2 elementos cualquiera en la array y finalmente seleccione los elementos cuya diferencia sea mayor.

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

// Java Program to Find 2
// Elements in an array
// such that the difference
// between them is the largest
 
import java.io.*;
 
class Largest_Difference_GFG {
    public static int[] Maximum_Diff(int a[], int n)
    {
        int diff, greatest_diff = a[1] - a[0];
        int ele1 = a[1], ele2 = a[0];
 
        // Array to store the difference and the
        // two elements ele1 and ele2 .
        int res[] = new int[3];
 
        // Check for all possible difference between
        // any 2 elements in the array and finally select
        // the elements whose difference is the largest
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                diff = Math.abs(a[i] - a[j]);
                if (diff > greatest_diff) {
                    greatest_diff = diff;
                    ele1 = a[i];
                    ele2 = a[j];
                }
            }
        }
        res[0] = greatest_diff;
        res[1] = ele1;
        res[2] = ele2;
 
        return (res);
    }
    public static void main(String[] args)
    {
 
        int arr[] = { 10, 11, 88, 2, 12, 120 };
 
        int size = arr.length;
        int[] result;
 
        result = Largest_Difference_GFG.Maximum_Diff(arr,
                                                     size);
 
        System.out.println("Greatest Difference:"
                           + result[0]);
        System.out.println(
            "Two elements with largest difference: "
            + result[1] + " and " + result[2]);
    }
}

Greatest Difference:118
Two elements with largest difference: 2 and 120

• Complejidad de tiempo : O (n ^ 2)
• Espacio Auxiliar : O(1)

Método 2: calculando los valores mínimo y máximo de la array y devolviendo la diferencia entre ellos

• La diferencia más grande entre 2 elementos en una array será siempre la diferencia absoluta entre el elemento más pequeño y el más grande presente en esa array.
• Usando 2 ciclos for independientes, determine el elemento mínimo y máximo de la array. A continuación se muestra la implementación del enfoque anterior:

// Java Program to Find 2
// Elements in an array
// such that the difference
// between them is the largest
import java.util.*;
class GFG {
 
    public static void main(String args[])
    {
        int array[] = new int[] { 10, 11, 88, 2, 12, 120 };
        int len = array.length;
 
        Arrays.sort(array); // sorting the array
        int max_diff = array[len - 1] - array[0];
        System.out.println("Maximum Difference is: "
                           + max_diff);
        System.out.println(
            "Two elements with largest difference: "
            + array[0] + " and " + array[len - 1]);
    }
}

Maximum Difference is: 118
Two elements with largest difference: 2 and 120

• Complejidad de tiempo : O(n)
• Espacio Auxiliar : O(1)

Nota: tanto el elemento mínimo como el máximo en el código anterior también se pueden determinar en un solo bucle for comparando cada elemento de una array con minValue y maxValue y actualizándolos en consecuencia. De esta forma, un único bucle for puede devolver tanto el valor mínimo como el valor máximo, y las líneas de código se reducirán.