Rueckgabe des kleinsten Wertes

[Pupsicat]

Hallo Leute,
in der Methode "naechste" suche nach dem kleinsten Wert im Array und versuche ihn dann mit return zurueck zu geben.
Kann mir einer sagen wie ich einen bereits gefunden wert von der suche ausschliessen kann?

public class methoden {

	/**
	 * @param args
	 */
	
	
	public static void main(String[] args) {
		
		
		
		int[] lzahlen = ziehung();
		System.out.print("\nSortiert: ");
		
		for(int z=0;z<lzahlen.length;z++){
				naechste(lzahlen);
				//System.out.print(lzahlen[z]+" ");
		
		}
		
	}
	
	
//----------------------------------------------------------------------------------------
	public static int[] ziehung () { 
		
		int[] lzahlen = new int[6];
		System.out.print("Unsortiert: ");
		
		for(int i=0;i<lzahlen.length;i++){
			lzahlen[i] = (int)(Math.random() * 49) +1;
			
			for(int x=0;x<i;x++){
				if(lzahlen[i]== lzahlen[x])
					lzahlen[i] = (int)(Math.random() * 49) +1;
			}
			System.out.print(lzahlen[i]+" ");
		}
		
		return lzahlen;
	} 
	
	
//----------------------------------------------------------------------------------------
	public static int naechste (int lzahlen[]) {
		
		
		int min=0;
		int z=0;	
		
		for(int j=0;j<=lzahlen.length-1;j++){
			min= lzahlen[j];
			for(z=j+1;z<=lzahlen.length-1;++z){
				if(lzahlen[z]<min){
					min= lzahlen[z];
						
				}
			}			
		}
		return min;
	}

}

 

[bone2]

warum hast du 2 schleifen um ein eindimensionales array zu durchsuchen?

min = array[0];
for (i = 0; i < arraylänge) {
    if (array[i] < min) {
        min = array[i];
    }
}

 

[Pupsicat]

oh man wie blöd! Danke!

Meine Frage ist aber hiermit nicht beantwortet!

 

[bone2]

Hallo Leute,
in der Methode "naechste" suche nach dem kleinsten Wert im Array und versuche ihn dann mit return zurueck zu geben.

sollte beantwortet sein

Kann mir einer sagen wie ich einen bereits gefunden wert von der suche ausschliessen kann?

von welcher suche ausschließen? wieviele gefundene werte hast du? etwas mehr hintergrund wäre praktisch

du willst damit sortieren oder? dann lege min nicht als array[0] fest sondern gib es mit in die nachste methode als parameter.
dann speicherst du den ersten wert der größer ist als die letzte zahl und vergleichst mit dem und dem alten wert oder lösch einfach das gefundene aus dem array

 

[Michael...]

Darf man das Array sortieren? Dann musste man sich nur merken welcher Index zuletzt zurückgegeben wurde.
Man könnte die bereits "gelieferten" Indizes in einem zweiten Array speichern.
Man jedesmal ein neues, kürzeres Array erstellen.
...

Letztendlich hängt es davon ab, was Du genau vorhast.

 

[Pupsicat]

Danke erstmal!

Gedacht war, bei jedem Aufruf von naechste(); das kleinste Element im Array zu finden und zurueck zu geben.
In der Main sollten diese Werte dann aufsteigend ausgegeben werden.

 

[Andi_CH]

Meinst du so etwas? Aber wenn du sortieren willst gibt es wohl einfachere Algorithmen und globale Variablen sind auch nicht so elegant ...

public class Kleinster {

	private static int[] reihe = {7, 3, 5, 2, 4, 1 };
	
	private static int bisherKleinster = Integer.MIN_VALUE;
	
	private static int sucheMin() {
		int min = Integer.MAX_VALUE;
		for(int i : reihe) {
			if ((i>bisherKleinster) && (i<min))
				min = i;
		}
		bisherKleinster = min;
		return min;
	}

	public static void main(String[] args) {
		int kl = Integer.MAX_VALUE;
		for(int i: reihe) {
			kl = sucheMin();
			System.out.println(kl);
		}
	}

}

Output:

1
2
3
4
5
7

 

[Andi_CH]

Danke erstmal!

Gedacht war, bei jedem Aufruf von naechste(); das kleinste Element im Array zu finden und zurueck zu geben.
In der Main sollten diese Werte dann aufsteigend ausgegeben werden.

Wenn du immer das Kleinste ausgibst, wir auch immer das Kleinste ausgegeben 🙂
Du musst das n. kleinste suchen ;-)

Siehe mein Vorschlag oben. Ist nicht elegant, aber macht glaub das was du suchst.

Variante 2: einen Vector statt einem Array nehmen und das gefundene Element entfernen.

EDIT: PS: Bei mehreren gleichen Elementen wird das nur einmal ausgegeben!

 

[WIaimy]

Nur als Idee:
wenn du mit nem Selection Sort sortierst und jeweils den kleinsten Wert zurück geben lässt, könntest du die Laufzeit der Schleife in nacheste() immer um einen runterzählen. Dazu kannst du ja zu dem array noch 'nen int-wert übergeben lassen, der sich bei jedem aufruf um 1 verringert

 

[Michael...]

Noch eine Anmerkung zu dem Code:

[JAVA=33] for(int x=0;x<i;x++){
if(lzahlen== lzahlen[x])
lzahlen = (int)(Math.random() * 49) +1;
}[/code]

Wenn Du damit doppelte Zahlen im Array vermeiden willst, könnte das damit daneben gehen.


Nach Möglichkeit solltest Du vielleicht List verwenden (z.B. ArrayList) dafür gibt's Methoden zum sortieren und mischen. (Scheint ja um 6 aus 49 zu gehen)