Methode schreiben die den maximalen Wert im Array ermittelt

[Lestas89]

Ich soll eine Methode schreiben, die ein Array aus Integer Werten übergeben bekommt, den maximalen Wert ermittelt und diesen zurückgibt.

Allerdings versteh ich den Quellcode nicht:

static int maximum(int a[]){
        int max = a[0];
        for (int i = 1; i < a.length; i++){
            if (a[i] > max)
                max = a[i];
           
        }
        return max;
    }

Wieso wird int max = a[0] gesetzt?

 

[Joose]

Damit soll die Anzahl der Schleifendurchläufe verringert werden (kann bei großen Arrays Performance bringen 😉)
Außerdem brauchst du natürlich einen anfänglichen Vergleichswert für die Schleife.

 

[Lestas89]

Hallo Joose,

danke für deine schnelle Antwort. In der if Bedingung steht dann aber a[ i] > a[0]
Das versteh ich nicht. Kannst du mir erklären wieso das zum Maximum führt?

 

[Joose]

In der Schleife steht "a[ i] > max", außerdem schau dir mal an mit welchem Index du in der Schleife beginnst!

Was würdest du denn als initialen Startwert für "max" verwenden? Und warum?

 

[Lestas89]

Das weiß ich nicht Joose. Mein Problem ist, dass ich leider keinen Ansatz hätte. Ich hoffe, dass ich das aber bald verstehe. Als Index wird 1 genommen und nicht 0. Hmm .. Kannst du mir vllt noch ein wenig auf die Sprünge helfen?

Ich komm da nicht hinter warum diese Schleife mit der If Bedingung zum Maximum führt.

 

[Joose]

Beispiel 1:

Du übergibst folgendes Array { 11 }. Sprich die Länge ist 1 und der Wert von Index 0 = 11.
Für die Variable "max" brauchst du einen Initialwert. Hier würde sich 0 anbieten (solange im Array nur positive Zahlen sein können).
Warum 0? Weil 0 nun mal die kleinste natürliche Zahl ist. Und jede andere natürliche Zahl größer ist als 0

Bei folgenden Code:

static int maximum(int a[]){
        int max = a[0];
        for (int i = 0; i < a.length; i++){
            if (a[ i] > max)
                max = a[ i];
       
        }
        return max;
    }

Würde die Schleife genau 1x durchlaufen werden und es wird verglichen ob 11 > 0 (wahr). max = 11

Beispiel 2:

Du übergibst folgendes Array { 11, 10}. Sprich die Länge ist 2 und der Wert von Index 0 = 11, Index 1 = 10.
Für die Variable "max" brauchst du einen Initialwert. Hier würde sich 0 anbieten (solange im Array nur positive Zahlen sein können).
Bei folgenden Code:

static int maximum(int a[]){
        int max = a[0];
        for (int i = 0; i < a.length; i++){
            if (a[ i] > max)
                max = a[ i];
       
        }
        return max;
    }

Würde die Schleife genau 2x durchlaufen werden und es wird verglichen ob 11 > 0 (wahr) und dann ob 10 > 11 (falsch). max = 11

Beide Beispiele zeigen nun das der Wert von Index 0 immer größer ist als "max". Somit kann man direkt max mit dem Wert von Index 0 initialisieren. So erspart man sich auch einen ganz Schleifendurchlauf, Beispiel1 müsste nun 0x durchlaufen werden und Beispiel 1 würde die Schleife nur 1x durchalufen.

(Sollte im Array auch negative Zahlen stehen dürfen so wäre der Initialwert von max eben nicht 0 sondern "Integer.MIN_VALUE" aber trotzdem wäre der Wert von Index 0 immer noch größer bzw. gleichgroß wie max)

 

[Lestas89]

Aber was wäre denn wenn das Array { 10, 11} wäre? Würde das dann auch noch funktionieren? Außerdem wird max ja nicht mit 0 initialisiert sondern mit a[0], also in diesem Beispiel mit 10.

 

[Joose]

Du hast hier mehrere Möglichkeiten um zu überprüfen was bei dem Array { 10, 11} passiert:
1.) Du kannst dir mittels Konsolenausgaben den Ablauf darstellen lassen (was nimmt welchen wert an usw)
2.) Du verwendest den Debugger und schaust dir bei jeden Step an welche Variable, welchen Wert annimmt
3.) Du machst einen Schreibtischtest (welche für sowas gedacht ist) und überprüfst mit Stift und Zettel was passiert

Wie schon oben versucht zu erklären: Wenn du die Variable "max" nicht mit "a[0]" initialisieren würdest, welchen Wert würdest du "max" stattdessen als Initialwert zuweisen? (oben bei meinen Beispielen habe ich eben 0 genommen, inkl Erklärung). Und warum bei dir "a[0]" verwendet wird habe ich auch oben schon geschrieben (habs nun nochmal extra fett hervorgehoben).

 

[Lestas89]

Danke dir für deine Geduld. Ich versuch das nochmal Schritt für Schritt zu verfolgen. Ich wäre dir dankbar, wenn du mir dann sagen könntest ob meine Gedankengänge richtig sind. Betrachten wir z.B. folgenden Code:

public class Programm2{

    public static void main(String[]args){
  
    int [] feld = new int [10];
    int max = feld[0];
  
    for(int i = 0; i < feld.length; i++){
  
        feld[i]=i+1;
        System.out.println(feld[i]);
    }
  
    for(int i = 0; i < feld.length; i++){
        if(feld[i] > max)
        max = feld[i];
      
  
    }
    System.out.println();
    System.out.println(max);
  
  
    }
}

Hier wird ein Array mit den Werten 1 - 10 aufgefüllt.
In max speicher ich den Wert feld[0]. Also in diesem Fall mit 1.

Nun die for-Schleife:

Zuerst steht dort if(1 > 1)
1 = 1

im nächsten Durchlauf würde dort
if(2 > 1) stehen. Und so weiter, bis der höchste Wert erreicht ist. In diesem Fall also 10. Kann ich davon ausgehen, dass ich das verstanden habe?

 

[VfL_Freak]

Moin,

Kann ich davon ausgehen, dass ich das verstanden habe?

Gute Frage ... 😀

Geh' doch einfach mal hin und male Dir die einzelnen Durchäufe (also die Werte der jeweiligen Variablen) auf Papier auf!
Dann solltest Du schnell dahinterkommen, wo wann welche Werte stehen und wie das ganze abläuft !

Gruß Klaus

 

[JStein52]

In max speicher ich den Wert feld[0]. Also in diesem Fall mit 1.

Falsch !! Du initialisierst in dem Fall mit 0 !! Dein Feld wird ja erst nach der Initialisierung von max mit Werten gefüllt. Davor enthält es lauter 0er ! Obwohl dieser Gedankenfehler im konkreten Fall nichts am Ergebnis ändert !

 

[Lestas89]

Ich hatte letztemal schon einen Thread eröffnet. Doch irgendwie ist mir die ganze Sache immer noch nicht so klar.

Nehmen wir zum Beispiel folgenden Code:

public class Programm2{
    public static void main(String []args){
  
    int [] feld = {6,2,7,4,5};
    int max = 0;
  
    for(int i = 0; i < feld.length; i++){
    if(feld[i] > max)
    max = feld[i];
    }
    System.out.println(max);
    }
}

Ich initialisiere max mit dem Wert 0.
Und nun weiß ich auch wo mein Verständnisproblem liegt:

Ich verstehe nicht, wann die Schleife verlassen wird.
Kann mir das jemand erklären? Ich wäre wirklich für jegliche Hilfe sehr dankbar weil ich langsam am verzweifeln bin.

 

[MWin123]

Die Schleife läuft solange i < feld.length erfüllt ist.

 

[HarleyDavidson]

Na die Schleife wird verlassen, wenn i nicht mehr kleiner ist als die Größe des Arrays.
Nehmen wir dein Beispiel:

Dein Array "feld ={6,2,7,4,5}" hat eine Länge von 5, da fünf Zahlen darin sind.
Sobald i also den Wert 5 erhält, wird die Schleife verlassen.

 

[Lestas89]

Halloe euch beiden,

danke für die schnellen Antworten.


Ich versteh nicht wieso max irgendwann den Maximalwert annimmt.
Wenn die Schleife bis i < 5 läuft. Dann müsste max doch den Wert 5 annehmen und nicht 7. Kannst du mir das erklären, wieso max den Maximalwert annimmt?

 

[MWin123]

Dann schau doch mal wann max geändert wird.

if(feld[i] > max) {
   max = feld[i];
}

 

[HarleyDavidson]

Gehen wir mal durch die Schleife:

   for(int i =0; i < feld.length; i++){ 
   if(feld[i]> max) //Der Wert des Arrays an der Stelle i wird mit der variablen max verglichen
    max = feld[i]; //ist max KLEINER als der Wert des Arrays an der Stelle i, wird dieser in max gespeichert
   }

Es wird also jedes Mal überprüft, ob die aktuelle Zahl an der jeweiligen Stelle des Arrays größer ist. Und falls ja, dann wird dieser Wert in max gespeichert.
Ich empfehle dir für solch einfachen Programme den https://de.wikipedia.org/wiki/Schreibtischtest

Da kannst du den Verlauf super einfach verfolgen.

 

[Lestas89]

Ich versteh nicht genau worauf du hinaus willst.

Ich schreib mal die Schritte hin so wie ich sie verstehe:

Zuerst steht dort

if(6 > 0)
max = 6;

danach:

if(2 > 6)
max = 2;

danach:

if(7 > 2)
max = 7

danach:
if(4 > 7)
max = 4;

danach:
if(5 >4)
max = 5

Vielleicht kannst du mich jetzt verstehen. Max wird doch am Ende trotzdem gleich 5. Wieso wird mir 7 ausgegeben?

 

[MWin123]

Öhm, 4 ist nicht größer als 7.
Edit: 2 ist auch nicht größer als 6.

 

[HarleyDavidson]

Du hast das Array: feld ={6,2,7,4,5}

Dann sehen die Schritte so aus:

if(6 > 0) //TRUE >> max wird gesetzt
max = 6;

danach:

if(2 > 6) //FALSE >> max wird nicht gesetzt
max = 6;

danach:

if(7 > 6) //TRUE >> max wird gesetzt
max = 7

danach:
if(4 > 7) //FALSE >> max wird nicht gesetzt
max = 7;

danach:
if(5 > 7) //FALSE >> max wird nicht gesetzt
max = 7

 

[Lestas89]

Also werden diese Werte nicht in max gespeichert. Das hab ich nun verstanden. Aber das letzte trifft doch zu, das 5 größer als 4 ist. Wieso wird die 5 nicht in max gespeichert? Da ist nun die Krux bei mir ...

 

[Lestas89]

Hallo HarleyDavidson,

danke für deine ausführliche Hilfe ... jetzt hab ich das verstanden.
Wie kann man dies für den Minimalwert durchführen? Einfach das Größer-Zeichen zum Kleiner-Zeichen umdrehen?

 

[MWin123]

Tipp: Klammer deine IF-Anweisungen und rück den Code ein.
Dann siehst du gleich, dass die Variable nur gesetzt wird, wenn die Bedingung zutrifft.

 

[JStein52]

Generell: ich würde max nicht mit 0 initialisieren sondern mit feld[0] ! Dann funktioniert deine Schleife auch für den Minimalwert wenn du aus > < machst ! Die Schleife beginnt dann aber jeweils bei 1 und nicht bei 0 !!!

 

[Lestas89]

Hallo JStein, wieso denn erst dann wenn ich max mit feld[0] initialisiere? Das versteh ich nicht.

 

[MWin123]

Hallo JStein, wieso denn erst dann wenn ich max mit feld[0] initialisiere? Das versteh ich nicht.

Das wurde doch bereits alles hier erklärt:
http://www.java-forum.org/thema/methode-schreiben-die-den-maximalen-wert-im-array-ermittelt.169893/

 

[Joose]

Ich habe die beiden Threads zusammen geführt da sie einfach das gleiche Thema und Problem behandeln

 

[JStein52]

Um es noch mal zu sagen: du sagst am Anfang: " ich gehe mal davon aus mein Maximum/Minimum ist der Inhalt des ersten Feldelementes". Und dann gehst du den Rest des Feldes durch und guckst ob es grössere/kleinere Werte gibt. Wenn ja dann wird das der neue grösste/kleinste Wert. Wenn du das Maximum suchst funktioniert es natürlich auch wenn du sagst mein erster grösster Wert ist 0. Aber beim Minimum geht das natürlich nicht mehr