Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
Methode schreiben die den maximalen Wert im Array ermittelt
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.
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?
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.
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:
Java:
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:
Java:
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)
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.
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).
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:
Java:
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?
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 !
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 !
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:
Java:
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.
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?
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
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
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 ...
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?
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 !!!
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