Erste Schritte Minimum und Maximum in Array finden

[rayan_ben]

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.

in pseudocode:

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

sonst: weiter

 

[pl4gu33]

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.

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

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

 

[rayan_ben]

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.

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?

    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.

    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

 

[jgh]

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!

	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]
			}
		}

 

[rayan_ben]

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

 

[jgh]

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

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();
	}
}

 

[rayan_ben]

Das klappt wohl nur wenn die Werte im array von klein nach groß sortiert sind.

 

[tröööt]

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.

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

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

 

[jgh]

@tröööt

dein Vorschlag mit

int min=Integer.MAX_VALUE;

und

int max=Integer.MIN_VALUE;

ist im Endeffekt genau das gleiche, was ich mit dem 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

absoluter Qutsch...das klappt für jedes Array, das mindestens eine Zahl beinhaltet!

 

[hasso]

mal von abgesehen das

[..]

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

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.

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];
}

 

[Spewer]

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.

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 :

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

Hoffe der Code ist verständlich.

 

[hasso]

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.

Oder einfach:

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:

 

[Spewer]

Oder einfach:

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:

Deshalb hab ich es nicht genutzt, sondern was eigenes. Sicherlich wäre es über

Arrays.sort

einfacher

 

[Marco13]

http://www.java-forum.org/java-basics-anfaenger-themen/142525-maximum-berechnen.html#post948322 !!!!!!!!!!!!!1111einseinseinselfelf

 

[hasso]

Manche verwechseln "Programmierstil" wohl mit "Performance" :bahnhof:

 

[Spewer]

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]

Manche verwechseln "Programmierstil" wohl mit "Performance" :bahnhof:

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]

 

[Marco13]

Das Ziel ist doch klar:

Wir sind gerade absolut am Anfang von Java, wir können Variablen, if, else und jetzt gerade while und for-Schleifen.

Dann vorzuschlagen, die Aufgabe mit Arrays.sort zu lösen ist nich nur übergeordnet-konzeptuell schlecht, sondern widerspricht auch offensichtlichen Intention des Aufgabenstellers. :noe:

 

[hasso]

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]

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.

 

[Landei]

Ein Rube-Goldberg-Vorschlag: Wer braucht schon Schleifen...

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));
    }
}

 

[maki]

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...

 

[bone2]

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.

 

[TheWhiteShadow]

@Landei
Da ist ein Fehler in der find-Funktion.

Korrektur:

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^^

 

[Marco13]

Es ist ja schon fast OT, aber...

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.

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:

int[] array = new int[]{3, 6, 4, 8, 3, 7, 1};
System.out.println("min-Value: " + 1);
System.out.println("max-Value: " + 8);

:joke:

 

[Landei]

@Landei
Da ist ein Fehler in der find-Funktion.

Korrektur:

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^^

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

    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));
        }
    }

//die Differenz halbieren, nicht die Summe.

Das ist allerdings Schwachfug.

 

[rayan_ben]

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

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();
	}
}

danke, das ist dann die lösung. ich hab's gerafft.
hätte man auch selbst drauf kommen können.

 

[TheWhiteShadow]

Das ist allerdings Schwachfug.

Ist es nicht, nur Umgeformt. Habs nicht so mit Umformen^^

Der eigentlichen Fehler ist aber immer noch drin.
Bei der Bedingung

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:

Math.min(mid,mid);

dabei macht.

 

[pappawinni]

Die Initialisierung

        int mini = 100;
        int maxi = 0;

ist vielleicht ungünstig.
Besser wäre vermutlich,

        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

 

[faetzminator]

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.

 

[Landei]

Ist es nicht, nur Umgeformt. Habs nicht so mit Umformen^^

Der eigentlichen Fehler ist aber immer noch drin.
Bei der Bedingung

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:

Math.min(mid,mid);

dabei macht.

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