Minimum et maximum de l'algorithme à l'aide d'un tableau en Java

Ok, alors que d'autres étaient déjà poster des réponses, j'ai pris le temps de modifier votre code dans quelque chose que je pense que ce serait plus utilisable.

1. Faire des méthodes statiques. Ceux-ci peuvent être réutilisés.
2. Utilisation des points de suspension (...) parce que vous pouvez appeler des méthodes sur des arguments de type tableau comme dans votre code, mais aussi avec un nombre variable d'arguments que min(5,3,8,4,1).
3. Initialiser avec le plus petit/plus grand nombre possible le type de données fournit
4. De vérifier que votre code fonctionne, vous devez imprimer les éléments du tableau d'abord, depuis quand vous ne savez pas ce que c', il n'y a aucun moyen de dire que le résultat est correct.
5. De la Base de votre code sur les méthodes existantes dans la bibliothèque standard, car ils sont connus pour être soigneusement testés et fonctionnent efficacement (je sais, min/max ressemble à un trop trivial exemple).
6. Je ne serais pas la peine de trop sur le rendement, à moins que vous ne pouvez vraiment montrer qu'il y a un problème de performance dans votre code. La priorité devrait être plus comme le 1er de l'exactitude, 2e de la lisibilité/maintenabilité, la 3e performance.

La plupart de ce qui a été déjà mentionné par d'autres, mais de toute façon, voici le code:

import java.util.Random;

public class MinMax {

    public static int min(int... args) {
        int m = Integer.MAX_VALUE;
        for (int a : args) {
            m = Math.min(m, a);
        }
        return m;
    }

    public static int max(int... args) {
        int m = Integer.MIN_VALUE;
        for (int a : args) {
            m = Math.max(m, a);
        }
        return m;
    }

    public static void main(String[] args) {

        //fill an array with random numbers between 0 and 50
        int[] ar = new int[10];
        for (int i = 0; i < 10; i++)
        {
            ar[i] = new Random().nextInt(50);
            System.out.println(ar[i]);
        }

        int maxValue = max(ar);
        int minValue = min(ar);

        System.out.println("The max is " + maxValue);
        System.out.println("The min is " + minValue);
    }
}

OriginalL'auteur Axel

Quelques conseils:

1. Initialiser min avec le premier élément et le début de la seconde:

   int min = ar[0];
   for(int i=1;i<10;i++)

2. ...ou commencer à partir de:

   int min = Integer.MAX_VALUE;

   cette approche est préférable si vous attendez de votre tableau peut être vide.

3. Utilisation Math.min pour éviter condition explicite (certains peuvent dire que c'est plus lent tout de même):

   for(int i=0;i<10;i++)
   {
      min = Math.min(min, ar[i]);
   }

OriginalL'auteur Tomasz Nurkiewicz

public static void main(String[] args) {
     int[] myArray = {9, 7,9, -40, -10, 40};
    //int[] myArray = {};
    //int[] myArray = {4};
    System.out.println("Difference between max and min = "
            + findDifference(myArray));
}

//Find difference between Max and Min values for a given array
public static int findDifference(int[] arr) {

    if (arr.length == 0) {
        //Log
        System.out.println("Input Array is empty");

        return Integer.MIN_VALUE;
    }

    int min = arr[0];
    int max = arr[0];

    for (int i = 1; i < arr.length; i++) {
        if (arr[i] < min)
            min = arr[i];
        else if (arr[i] > max)
            max = arr[i];
        //Just to check if logic works fine
        System.out.println("Min=" + min + " Max=" + max);
    }

    return max - min;

}

OriginalL'auteur Pankaj

En fonction de si vous voulez le max et le min-fonctions dans la même méthode, vous devez également considérer le type de retour.

Jusqu'à présent la plupart des suggestions ont gardé les deux sens c'est bien de retourner un int. Cependant, si vous mettez le max et le min-fonctions dans un findLargestDifference-la méthode que vous auriez à revenir d'un long voir que la plus grande différence entre tous les chiffres donnés dans le tableau int peut être la taille de 2 ints. Il faudrait aussi se débarrasser de l'avoir à boucle sur le tableau int deux fois.

En outre, je recommande d'écrire des tests unitaires pour les coins et les bords des cas, au lieu de l'impression dans la principale méthode. Il permet de tester votre logique au début, quand la mise en œuvre et donc souvent rend le code plus propre.

Voir l'exemple de code ci-dessous.

public class LargestDifference {

public static long find(int[] numbers) {
    if (numbers == null || numbers.length == 0) {
        throw new IllegalArgumentException("Input cannot be null or empty.");
    }else {
        long currentMax = numbers[0];
        long currentMin = numbers[0];

        for (int i=0; i < numbers.length; i++) {
            if (currentMin > numbers[i]) {
                currentMin = numbers[i];
            }else if (currentMax < numbers[i]) {
                currentMax = numbers[i];
            }
        }
        return currentMax - currentMin;
    }
}

OriginalL'auteur IsolaMonte