Erste Schritte Minimum und Maximum in Array finden

R

rayan_ben

Mitglied
Hallo,

...ja ich habe gesucht...

Wir sollen in einer Hausaufgabe das Minimum und Maximum in einem Array finden. Wir sind gerade absolut am Anfang von Java, wir können Variablen, if, else und jetzt gerade while und for-Schleifen.

Mit so einer for-Schleife sollen wir jetzt das Minimum und Maximum finden. Die Zahlen sind nicht sortiert.

Um das Minimum zu finden, sollen wir davon ausgehen, dass keine Zahl größer als 100 ist.
Um das Maximum zu finden, davon, dass keine negativ ist.

In einem geschlossenen Thread habe ich das hier gefunden. Aber ich soll doch von der 100 ausgehen... ich komm nicht drauf.
Code: 
in pseudocode:

int 0;
for( alle Werte im Array){
if (wert = 0)
minimum = wert

sonst: weiter
 
rayan_ben hat gesagt.:
Um das Minimum zu finden, sollen wir davon ausgehen, dass keine Zahl größer als 100 ist.
Um das Maximum zu finden, davon, dass keine negativ ist.
Zum Vergrößern anklicken....

ich bin zwar gerade aufgestanden, aber hast du Minimum und Maximum hier vertauscht? 😀

also am Besten deklarierst du dir 2 Int Variablen Minimum / Maximum ... dann durchläufst du das Array und setzt beim ersten Durchlauf Minimum/Maximum auf den ersten Wert. Bei jedem weiteren prüfst du, ob er größer oder kleiner als der aktuelle Min/Max Wert ist,... wenn ja dann setzt du den als neuen Min/Max Wert

oder

Java: 
public static void main(String[] args){
		int[] array = new int[]{3,6,10,5,99,33,21,65,3,4,6,55};
		Arrays.sort(array);
		System.out.println("MAX: "+ array[array.length-1]);
		System.out.println("MIN: "+ array[0]);		
	}

aber ich bin mir sicher, so sollt ihr das net machen 😀
 
Zuletzt bearbeitet:
ich hab auch schon 100 mal drüber gelesen, es steht so dort, kann aber ein fehler sein:
Für die Berechnung des Minimums können Sie annehmen, dass keine Zahl größer als 100 ist, für
die Berechnung des Maximums, dass keine Zahl negativ ist.
Zum Vergrößern anklicken....

ich bekomm's nicht hin...

etwa so soll es ja für das minimum funktionieren:
- ich setze x=0
- ich lasse mit einer for-schleife alle array-werte mit x vergleichen.
- x soll dann immer um 1 erhöht werden
- wenn dann irgendwann mal array=x zutrifft, habe ich das minimum.

aber wie? -.-

das teil gibt immerhin schon mal die array-werte sortiert von klein nach groß aus. wie kann ich die schleife stoppen nach dem ersten treffer?
Code: 
    for ( int x = 0; x<=100; x++){
      for ( int i = 0; i<values.length; i++){
        
        if (x==values[i]){
          System.out.println(values[i]); } 
      }
    }


edit
so geht's: :toll:
um das mal kurz zu erklären: x fängt bei 0 an; wenn ein wert aus value trifft, wird der wird er an die erste stelle inarr geschrieben; usw, bis alle werte durch sein; danach gebe ich einfach arr[0] aus.
Code: 
    int k=0;
    int[] arr = new int [values.length];
    for ( int x = 0; x<=100; x++){
      for ( int i = 0; i<values.length; i++){
        
        if (x==values[i]){
          
          arr[i] = values[k];
          k++;
          
        } 
      }
    } 
    System.out.println("Minimum gefunden: "+arr[0]);
aber das kann doch nicht die musterlösung sein
 
Zuletzt bearbeitet:
hier mal mein morgen-Vorschlag inc. der scheinbar etwas merkwürdigen Bedingung. Wenn das kein Fehler ist, könnte man daraus ableiten dass man das minimum mit 100 und das maximum mit 0 initialisiert. Dementsprechend wäre sichergestellt, dass die if-Bedingung mindestens 1x zutrifft!

Java: 
	int mini =100;
		int maxi=0;
		int[] arr = new int[values.length];
		for (int x = 0; x < arr.length; x++) {
			if (arr[x]<=mini){
				mini = arr[x];
			}
			if (arr[x]>=maxi){
				maxi = arr[x]
			}
		}
 
int [] values = {11, 5, 66, 52, 6, 9 }

das ist der Array mit dem es losgeht.

Dein Code macht für mich keinen sinn.
* * * * * * if (arr[x]<=mini)
in arr steht doch hier noch gar nichts bzw einfach 0
 
grundsätzlich hast du Recht...aber ich dachte ein wenig Arbeit lasse ich dir...aber gut:
btw. ein Semikolon hat auch noch gefehlt!

Java: 
public final class MinMax {

	public MinMax() {
		int mini = 100;
		int maxi = 0;
		int[] arr = new int[] { 3, 6, 10, 5, 99, 33, 21, 65, 3, 4, 6, 55 };
		for (int x = 0; x < arr.length; x++) {
			if (arr[x] <= mini) {
				mini = arr[x];
			}
			if (arr[x] >= maxi) {
				maxi = arr[x];
			}
		}
		System.out.println("Minimum gefunden: " + mini);
		System.out.println("Maximum gefunden: " + maxi);
	}

	public static void main(String[] args) {
		new MinMax();
	}
}
 
mal von abgesehen das

Um das Minimum zu finden, sollen wir davon ausgehen, dass keine Zahl größer als 100 ist.
Um das Maximum zu finden, davon, dass keine negativ ist.
Zum Vergrößern anklicken....

blödsinn ist ... denn eigentlich müsste es genau umgedreht lauten ... gibt es verschiedene wege ...

Arrays.sort() wäre wohl das einfachste ... aber sicher nicht im sinn der aufgabe ...

ich würde sowas eher in diese richtung hier lösen

Java: 
int[] array=...
int min=Integer.MAX_VALUE;
int max=Integer.MIN_VALUE;
for(int i : array)
{
	if(i<min)
		min=i;
	if(i>max)
		max=i;
}

ist jetzt nur so ausm kopf geschrieben ...

sinn ist es einfach das man das "minimum" mit dem größten wert und das "maximum" mit dem kleinsten wert initialisiert und dann prüft ob die aktuelle zahl kleiner als das aktuelle minimum (2^31-1) ist oder größer als das aktuelle maximum (-2^31)

dabei sollte egal sein wie rum das ausgangs-array sortiert ist
 
@tröööt

dein Vorschlag mit
Code: 
int min=Integer.MAX_VALUE;
und
Code: 
int max=Integer.MIN_VALUE;
ist im Endeffekt genau das gleiche, was ich mit dem Code
Code: 
int mini = 100;
        int maxi = 0;
bezwecken wollte...nur das ich die 0-100 aus der Aufgabenstellung genommen habe.

Das klappt wohl nur wenn die Werte im array von klein nach groß sortiert sind
Zum Vergrößern anklicken....
absoluter Qutsch...das klappt für jedes Array, das mindestens eine Zahl beinhaltet!
 
tröööt hat gesagt.:
mal von abgesehen das

[..]

blödsinn ist ... denn eigentlich müsste es genau umgedreht lauten ... gibt es verschiedene wege ...
Zum Vergrößern anklicken....


Nein, das ist kein Blödsinn. Um ein Minimum zu finden muss man die Vergleichsvariable am Anfang auf irgendeinen Wert festlegen, du setzt sie ja selbst auf INT_MAX_VALUE. Wenn du aber weißt das es nichts größer 100 gibt kannst du sie auf 100 festlegen. Genau DAFÜR ist diese Restriktion.
Umgekehrt für das Maximum natürlich dasselbe.

Java: 
int[] array = ...
int maxValue = 0;
int minValue = 100;

for(int i = 0; i < array.length; i++)
{
    if(array[i] > maxValue) maxValue = array[i];
    if(array[i] < minValue) minValue = array[i];
}
 
Zuletzt bearbeitet:
Warum sortierst du nicht das Array und liest dann einfach die erste und letzte Stelle aus ?

Hab mal einen ziemlich einfachen Sortieralgorithmus geschrieben. Der sollte es tun.

Java: 
int[] values =
	{ 11, 5, 66, 52, 6, 9 };

	int pos, posMin, min, merke;

	// Sortieren u. Vertauschen
	for (int i = 0; i < values.length; i++)
	{
	    posMin = i;
	    min = values[i];

	    for (pos = i + 1; pos < values.length; pos++)
{
		if (values[pos] < min)
		{
		    min = values[pos];
		    posMin = pos;
		}
}	    
	    //Vertauschen
	    merke = values[i];
	    values[i] = values[posMin];
	    values[posMin] = merke;
	}

Und dann kann man ganz einfach :

Java: 
System.out.println("kleinster: " + values[0]);
	System.out.println("größte: " + values[values.length - 1]);

Hoffe der Code ist verständlich.
 
Zuletzt bearbeitet:
Spewer hat gesagt.:
Warum sortierst du nicht das Array und liest dann einfach die erste und letzte Stelle aus ?

Hab mal einen ziemlich einfachen Sortieralgorithmus geschrieben. Der sollte es tun.
Zum Vergrößern anklicken....


Oder einfach:

Java: 
int[] array = new int[]{3, 6, 4, 8, 3, 7, 1};
Arrays.sort(array);

System.out.println("min-Value: " + array[0]);
System.out.println("max-Value: " + array[array.length - 1]);

Da dies aber eine "Hausaufgabe" ist ging man mal davon aus das es so nicht gewünscht ist :bahnhof:
 
hasso hat gesagt.:
Oder einfach:

Java: 
int[] array = new int[]{3, 6, 4, 8, 3, 7, 1};
Arrays.sort(array);

System.out.println("min-Value: " + array[0]);
System.out.println("max-Value: " + array[array.length - 1]);

Da dies aber eine "Hausaufgabe" ist ging man mal davon aus das es so nicht gewünscht ist :bahnhof:
Zum Vergrößern anklicken....

Deshalb hab ich es nicht genutzt, sondern was eigenes. Sicherlich wäre es über
Code: 
Arrays.sort
einfacher
 
Wir sind hier immer noch in einem Thread in dem es um eine Hausaufgabe geht.
Wenn wir jetzt anfangen mit Performance etc. entwickelt sich ganz langsam aus der Maus ein ausgewachsener Elefant.

Fakt ist, Sortieren bringt hier das gewünschte Ergebnis relativ einfach. [OT]Dem Lehrer ist's im Zweifel eh egal.[/OT]
 
faetzminator hat gesagt.:
Wenn du aber nur durchiterierst, und so das Maximum suchst, hast du [c]O(n)[/c]. Wenn du sortierst, hast du warscheinlich etwas wie [c]O(n log n)[/c]
Zum Vergrößern anklicken....

Was aber in diesem Fall hier völlig egal ist.

Es macht überhaupt keinen Sinn hier O-Berechnungen anzustellen. Man sollte seine Lösung einfach der Komplexität des vorhandenen (!!!) Problems anpassen.

Mir ist durchaus bewusst das Sortieren wesentlich länger dauert und für Industriezwecke oder riesige Datenmengen absolut falsch ist. Aber in diesem Fall hier kann man Schleifen und If-Abfragen wegwerfen und einen Zweilzeiler bauen, fertig. Performance Unterschiede wirst du bei diesen Datenmengen hier absolut keine feststellen.

Und das hat auch nichts mit "man muss es ja nicht falsch lernen" zu tun, das Argument ist ja beliebt. Es hat nur damit etwas zu tun keinen einfachen und übersichtlichen Code zu opfern nur um Peformance zu optimieren die in diesem Fall völlig irrelevant ist.

Dass das sortieren hier eh nicht erwünscht ist weil Hausaufgabe, steht ja schon mehrmals im Thread, meine erste gepostete Lösung sortiert auch nichts. Ich wehre mich nur gegen die Aussage das Sortieren sei perse IMMER schlecht, weil das stimmt so einfach nicht, das ist mir viel zu pauschal, auch bezogen auf min- und max-Werte.
 
Ein Rube-Goldberg-Vorschlag: Wer braucht schon Schleifen...

Java: 
public class MinMaxFinder {

    enum Op {
        MIN, MAX;
        public int op(int x, int y) {
            switch(this) {
                case MIN : return Math.min(x,y);
                case MAX : return Math.max(x,y);
                default : throw new AssertionError();
            }
        }
    }

    public static int find(Op op, int[] array) {
        return find(op, array, 0, array.length-1);
    }

    private static int find(Op op, int[] array, int from, int to) {
        if (to - from == 1) {
            return array[to];
        } else {
            int mid = (from + to)/2;
            return op.op(find(op, array, from,mid), find(op,array, mid,to));
        }
    }

    public static void main(String... args) {
        int[] array = {7,43,2,5,6,3,5,7,12,8,9,13};
        System.out.println(find(Op.MIN,array));
        System.out.println(find(Op.MAX,array));
    }
}
 
Zuletzt bearbeitet:
Eines der "real world problems" mit sortieren um das maximum zu finden: Die Reihenfolge der Elemente in der Datenstruktur wird geändert, ziemlich heftiger Seiteneffekt, klar könnte man das Array/die Coleltion vorher kopieren, ist aber nciht immer pragmatisch...
 
jup ich denek auch, das sortieren nie als lösung für min/max vorgeschlagen werden sollte. Das lert nur falsche denkmuster.
ich schraub am auto ja auch nicht alle reifen ab, legen sie nebeneinander und sortiere sie dann nach profiltiefe, ohne mir die bei der sortierung gemesene tiefe aufzuschreiben.
Nur um dann bei dem mit dem flachsten profil nochmal zu messen und zu entscheiden ob sie gewechselt werden müssen.
 
@Landei
Da ist ein Fehler in der find-Funktion.

Korrektur:
Java: 
private static int find(Op op, int[] array, int from, int to) {
        if (to - from == 0) { // from und to müssen gleich sein. bzw to == from
            return array[to];
        } else {
            int mid = from + (to - from) / 2; // die Differenz halbieren, nicht die Summe.
            return op.op(find(op, array, from,mid), find(op,array, mid+1,to)); // 2x den Index mid verwendet
        }
    }
Also bevor man so ein exotischen Mist schreibt, gründlich testen^^
 
Zuletzt bearbeitet:
Es ist ja schon fast OT, aber...

hasso hat gesagt.:
Da dies aber eine "Hausaufgabe" ist ging man mal davon aus das es so nicht gewünscht ist
...
Mir ist durchaus bewusst das Sortieren wesentlich länger dauert und für Industriezwecke oder riesige Datenmengen absolut falsch ist. ...

Ich wehre mich nur gegen die Aussage das Sortieren sei perse IMMER schlecht, weil das stimmt so einfach nicht, das ist mir viel zu pauschal, auch bezogen auf min- und max-Werte.
Zum Vergrößern anklicken....

Das Sortieren
- ist nicht das, was durch die Aufgabe vermittelt werden sollte
- ist weniger performant
- hat unangenehme Seiteneffekte
- (oder wie du gesagt hast, ist in der Praxis 'absolut falsch')

Welchen Grund sollte es eben, diese Möglichkeit überhaupt zu erwähnen, wenn sie sowohl theoretisch als auch praktisch in jeder Hinsicht "schlecht" ist? NUR wegen des kürzeren Codes?
Noch kürzer:
Java: 
int[] array = new int[]{3, 6, 4, 8, 3, 7, 1};
System.out.println("min-Value: " + 1);
System.out.println("max-Value: " + 8);
:joke:
 
TheWhiteShadow hat gesagt.:
@Landei
Da ist ein Fehler in der find-Funktion.

Korrektur:
Java: 
private static int find(Op op, int[] array, int from, int to) {
        if (to - from == 0) { // from und to müssen gleich sein. bzw to == from
            return array[to];
        } else {
            int mid = from + (to - from) / 2; // die Differenz halbieren, nicht die Summe.
            return op.op(find(op, array, from,mid), find(op,array, mid+1,to)); // 2x den Index mid verwendet
        }
    }
Also bevor man so ein exotischen Mist schreibt, gründlich testen^^
Zum Vergrößern anklicken....

Danke, da war tatsächlich ein Bug drin. Es war eigentlich so gedacht:

Java: 
    public static int find(Op op, int[] array) {
        return find(op, array, 0, array.length);
    }

    public static int find(Op op, int[] array, int from, int to) {
        if (to - from == 1) {
            return array[from];
        } else {
            int mid = (from + to)/2;
            return op.op(find(op, array, from, mid), find(op,array, mid,to));
        }
    }

Java: 
//die Differenz halbieren, nicht die Summe.
Zum Vergrößern anklicken....

Das ist allerdings Schwachfug.
 
jgh hat gesagt.:
grundsätzlich hast du Recht...aber ich dachte ein wenig Arbeit lasse ich dir...aber gut:
btw. ein Semikolon hat auch noch gefehlt!

Java: 
public final class MinMax {

	public MinMax() {
		int mini = 100;
		int maxi = 0;
		int[] arr = new int[] { 3, 6, 10, 5, 99, 33, 21, 65, 3, 4, 6, 55 };
		for (int x = 0; x < arr.length; x++) {
			if (arr[x] <= mini) {
				mini = arr[x];
			}
			if (arr[x] >= maxi) {
				maxi = arr[x];
			}
		}
		System.out.println("Minimum gefunden: " + mini);
		System.out.println("Maximum gefunden: " + maxi);
	}

	public static void main(String[] args) {
		new MinMax();
	}
}
Zum Vergrößern anklicken....
danke, das ist dann die lösung. ich hab's gerafft.
hätte man auch selbst drauf kommen können.
 
Landei hat gesagt.:
Das ist allerdings Schwachfug.
Zum Vergrößern anklicken....
Ist es nicht, nur Umgeformt. Habs nicht so mit Umformen^^

Der eigentlichen Fehler ist aber immer noch drin.
Bei der Bedingung
Code: 
to - from == 1
trifft ein Array der Länge 2 zu.
Du hast Wahllos einen der beiden Indizes genommen. Nun den Anderen, aber das ändert nichts.

und die Zeile mit mid+1 ist Sinnvoll, weil man sonst immer den unnötigen Vergelich:
Code: 
Math.min(mid,mid);
dabei macht.
 
Die Initialisierung
Java: 
        int mini = 100;
        int maxi = 0;
ist vielleicht ungünstig.
Besser wäre vermutlich,
Java: 
        int[] arr = new int[] { 3, 6, 10, 5, 99, 33, 21, 65, 3, 4, 6, 55 };
        int mini = arr[0];
        int maxi = mini;
oder aber Integer.MAX_VALUE für mini und Integer.MIN_VALUE für maxi
 
pappawinni, nicht wenn du die Aufgabenstellung liest 😉 Ist wohl bewusst so gewählt, dass nicht [c]Integer.MAX_VALUE[/c] und das [c]MIN_VALUE[/c] verwendet werden muss.
 
TheWhiteShadow hat gesagt.:
Ist es nicht, nur Umgeformt. Habs nicht so mit Umformen^^

Der eigentlichen Fehler ist aber immer noch drin.
Bei der Bedingung
Code: 
to - from == 1
trifft ein Array der Länge 2 zu.
Du hast Wahllos einen der beiden Indizes genommen. Nun den Anderen, aber das ändert nichts.

und die Zeile mit mid+1 ist Sinnvoll, weil man sonst immer den unnötigen Vergelich:
Code: 
Math.min(mid,mid);
dabei macht.
Zum Vergrößern anklicken....

Zeige mir einen Input, für den mein korrigiertes(!) Programm nicht funktioniert, dann reden wir weiter...
 

Aktuelle Jobs

Neue Themen

Ähnliche Themen

Lokales Minimum- Maximum, Globales Minimum - Maximum ?
Antworten: 4
Minimum/Maximum aus einer Liste
Antworten: 3
Maximum, Minimum und Mittelwert berechnen
Antworten: 25
Felder- Minimum/Maximum
Antworten: 2
Minimum und Maximum ausgeben lassen
Antworten: 7

Zurück
Oben