Uitleg op integer.max_value en integer.min_value om min en max-waarde te vinden in een array

Ik leek niet te begrijpen hoe Integer.MAX_VALUEen Integer.MIN_VALUEhelpen bij het vinden van de MIN en MAX-waarde in een array.

Ik begrijp hoe deze methode (pseudocode hieronder) werkt bij het vinden van de MIN- en MAX-waarden:

max = A[0], min = A[0]
for each i in A
  if A[i] > max then max = A[i]
  if A[i] < min then min = A[i] 

Maar wat betreft deze methode begrijp ik het doel van Integer.MAX_VALUEen Integer.MIN_VALUE:

import java.util.Scanner;
class MyClass {
    public static void main(String[] args) {
        int[] numbers; // declaring the data type of numbers
        numbers = new int[3]; //assigning the number of values numbers will contain
        int smallest = Integer.MAX_VALUE, largest = Integer.MIN_VALUE;
        Scanner input = new Scanner(System.in);
        System.out.println("Please enter 3 numbers");
        for(int counter = 0; counter<numbers.length;counter++) {
            numbers[counter] = input.nextInt();
        }
        for(int i = 0; i<numbers.length; i++) {
            if(numbers[i]<smallest)
                smallest = numbers[i];
            else if(numbers[i]>largest)
                largest = numbers[i];
        }
        System.out.println("Largest is "+largest);
        System.out.println("Smallest is "+smallest);
    }
}

• system.out.println (integer.max_value) geeft 2147483647
• System.out.Println (integer.min_value) geeft -2147483648

Dus welk doel dienen integer.min_value en integer.min_value in de vergelijkingen?

Antwoord 1, Autoriteit 100%

maar wat deze methode betreft, ik begrijp het doel van Integer.MAX_VALUE en Integer.MIN_VALUE niet.

Door te beginnen met smallestingesteld op Integer.MAX_VALUEen largestingesteld op Integer.MIN_VALUE, maak je later geen zorgen over het speciale geval waarin smallesten largestnog geen waarde hebben. Als de gegevens die ik bekijk een 10als eerste waarde hebben, dan zijn numbers[i]<smallestwaar (omdat 10is <Integer.MAX_VALUE) en we updaten smallestnaar 10. Evenzo zullen numbers[i]>largesttruezijn omdat 10>Integer.MIN_VALUEen we werken largestbij. En zo verder.

Als u dit doet, moet u er natuurlijk voor zorgen dat u ten minste één waarde heeft in de gegevens die u bekijkt. Anders krijg je apocriefe getallen in smallesten largest.

Opmerking het punt dat Onome Sotumaakt in de opmerkingen:

…als het eerste item in de array groter is dan de rest, dan is het grootste item altijd Integer.MIN_VALUE vanwege de else-if-instructie.

Wat waar is; hier is een eenvoudiger voorbeeld dat het probleem demonstreert (live-kopie):

public class Example
{
    public static void main(String[] args) throws Exception {
        int[] values = {5, 1, 2};
        int smallest = Integer.MAX_VALUE;
        int largest  = Integer.MIN_VALUE;
        for (int value : values) {
            if (value < smallest) {
                smallest = value;
            } else if (value > largest) {
                largest = value;
            }
        }
        System.out.println(smallest + ", " + largest); // 1, 2 -- WRONG
    }
}

Om het te repareren, ofwel:

1. Gebruik elseniet, of

2. Begin met smallesten largestgelijk aan het eerste element, en loop dan de overige elementen door, waarbij de else ifbehouden blijft.

Hier is een voorbeeld van die tweede (live-kopie):

public class Example
{
    public static void main(String[] args) throws Exception {
        int[] values = {5, 1, 2};
        int smallest = values[0];
        int largest  = values[0];
        for (int n = 1; n < values.length; ++n) {
            int value = values[n];
            if (value < smallest) {
                smallest = value;
            } else if (value > largest) {
                largest = value;
            }
        }
        System.out.println(smallest + ", " + largest); // 1, 5
    }
}

Antwoord 2, autoriteit 42%

In plaats van de variabelen te initialiseren met willekeurige waarden (bijvoorbeeld int smallest = 9999, largest = 0) is het veiliger om de variabelen te initialiseren met de grootste en kleinste waarden die representatief zijn voor dat nummertype (dat is int smallest = Integer.MAX_VALUE, largest = Integer.MIN_VALUE).

Aangezien uw integerarray geen waarde kan bevatten die groter is dan Integer.MAX_VALUEen kleiner dan Integer.MIN_VALUE, werkt uw code in alle randgevallen.

Antwoord 3, autoriteit 15%

Door de min/max-waarden te initialiseren tot hun uiterste tegendeel, vermijdt u randgevallen van waarden in de invoer: een van de min/max-waarden is in feite een van die waarden (in het geval dat de invoer uit slechts één van die waarden), anders wordt de juiste min/max gevonden.

Opgemerkt moet worden dat primitieve typen moeteneen waarde hebben. Als u Objects (dwz Integer) gebruikte, zou u de waarde kunnen initialiseren tot nullen dat speciale geval voor de eerste vergelijking afhandelen, maar dat creëert extra (onnodige) code. Door deze waarden te gebruiken, hoeft de luscode zich echter geen zorgen te maken over het randgeval van de eerste vergelijking.

Een ander alternatief is om beide beginwaarden in te stellen op de eerste waarde van de invoerarray (nooit een probleem – zie hieronder) en te herhalen vanaf het 2eelement, aangezien dit de enige juiste staat is van min/max na één iteratie. Je zou ook kunnen herhalen vanaf het 1e element – het zou geen verschil maken, behalve een extra (onnodige) iteratie over het eerste element.

De enige verstandige manier om met inuit grootte nul om te gaan is eenvoudig: gooi een IllegalArgumentException, omdat min/max in dit geval niet gedefinieerd is.