# 2. kleinster Wert und verschiedene Werte



## deiwid (3. Mai 2010)

Hi, habe ein Problem und ich kommt leider nicht auf die Lösung:

Meine Methoden sollen den 2. kleinsten Wert und die Anzahl der verschiedenen Werte ausgeben; in einem Array.
In meinem Beispiel soll eben 12 als 2.kleinster Wert rauskommen und 3 verschiedene Werte.

Das Programm gibt keine Fehlermeldung aus, also habe ich die falschen Formel.
Bitte um Hilfe!


```
public class Tester {
	
	public static void main( String [] args) {
		
		Array b = new Array(10);
		b.setArray(new int[]{1, 12, 45, 12, 1});
		System.out.println(b.kleinsterWert());
		System.out.println(b.zweitKleinsterWert());
		System.out.println(b.verschiedeneWerte());
				}

}
```


```
public int kleinsterWert(){
		
		int erg = a[0];
		for(int i = 0; i < a.length; i++){
			
			if(a[i] < erg)
				erg = a[i];
				}
	
		return erg;
		
	}
	
	public int zweitKleinsterWert(){
		
		int erg = 0;
		int min2 = 0;
		for(int i = 0; i < a.length-1; i++){
			
			if(a[i] < erg) {
				min2 = erg;
				erg = a[i]; }
			if(a[i] > min2){
					
					min2 = a[i]; }
			
			}
		return min2;
	}
	
	
	public int verschiedeneWerte(){
				
		int counter = 0;
		for(int i = 0; i < a.length; i++){
			for(int j=1; j < a.length; j++){
						
			if(a[i] == a[j])
				counter++; }
		}
		return counter++;
	}
}
```


----------



## gorefest (3. Mai 2010)

Hi,

versuch doch mal einfach folgendes :

(ist freestyle)

```
Collection<Integer> liste = Arrays.asList(deinArray);
   Collections.sort(liste);
   int kleinsterWert= liste.iterator.next();
   int zweitkleinsterWert=lister.iterator.next().next();
```

Grüße
gore


----------



## deiwid (3. Mai 2010)

Habe jetzt den 2.kleinsten Wert so gelöst, dass ich sortiert habe und das an der 2. Stelle soll ausgegeben werden. Habe deines nicht zum Laufen gebracht

Wenn ich jetzt das mit den verschiedenen Werten auch so sortieren kann ich es leichter vergleichen. Gehe einfach die Lsite durch durch und zähle. Möchte aber gerne wissen ob es auch anders möglich ist...

Ich habe mit da eben die 2 for schleifen gedacht, dass zuerst die 1. Zahl mit allen verglichen wird und dann eben die 2. Zahl mit allen verglichen wird. Funkt aber nicht so richtig. Finde aber den Fehler nicht.


----------



## vfl_freak (3. Mai 2010)

Moin,



deiwid hat gesagt.:


> Möchte aber gerne wissen ob es auch anders möglich ist...



Möglichkeiten gibt es sicher einige. Ich finde auch, dass eine Sortierung - wie von _gorefest_ vorgeschlagen - die sinnvollste Lösung und wohl auch die Schnellste ist. Ob über _Collections_ oder anders ist dann eher nebensächlich ...



deiwid hat gesagt.:


> Ich habe mit da eben die 2 for schleifen gedacht, dass zuerst die 1.  Zahl mit allen verglichen wird und dann eben die 2. Zahl mit allen  verglichen wird. Funkt aber nicht so richtig. Finde aber den Fehler  nicht



Was meinst Du mit "den 2 for-Schleifen"  
Aber die Zahlen _nacheinander _mit allen Vorhandenen zu vergleichen, wird sicher nicht reichen.

Ein ganz einfacher Algorithmus wäre in etwa :
  * liese die ersten beiden Ziffern ein und merke sie dir
  * lies die weiteren Zahlen einzeln () ein und prüfe jedesmal, ob sie_ kleiner gleich_ der Kleinsten bzw. Zweitkleinsten ist
  * Du kannst Du sie Dir für das nächste Einlesen merken 
     (Vorsicht: ist es die neue kleinste Zahl, dann musst Du Dir die bisherige Kleinste als neue Zweitkleinste merken und die bisherige 
                   Zweitkleinste verwerfen)

Hoffe, das reicht als Gedankenansatz 

Gruß
Klaus


----------



## deiwid (3. Mai 2010)

vfl_freak hat gesagt.:


> Ein ganz einfacher Algorithmus wäre in etwa :
> * liese die ersten beiden Ziffern ein und merke sie dir
> * lies die weiteren Zahlen einzeln () ein und prüfe jedesmal, ob sie_ kleiner gleich_ der Kleinsten bzw. Zweitkleinsten ist
> * Du kannst Du sie Dir für das nächste Einlesen merken
> ...



Das ist ein Algor. für die 2.kleinste was ich eh schon gelöst habe. Ich brauche einen kleinen Anstatz um zu sehen wie viele verschieden ZAhlen sich in einem Array befinden.


----------



## vfl_freak (4. Mai 2010)

Moin,

dann sind wir doch wieder bei der Idee der Sortierung 
Sortiere Deine Liste mit Zahlen und laufe werteweise durch, um zu prüfen. 
Bei jedem neuen Wert inkrementierst Du dann einfach einen Zähler .....

Gruß
Klaus


----------



## gorefest (4. Mai 2010)

```
public static void main(String[] argv){
		Integer[] arr = {1,2,3,4,1,2,3,1,2,1};
		Integer old = null;
		int anzahl = 0;

		List<Integer> list = Arrays.asList(arr);
		Collections.sort(list);
		for (Integer integer : list) {
			if (!integer.equals(old)) {
				old = integer; 
				++ anzahl;
			}
		}
	}
```


----------



## Vereth (4. Mai 2010)

Speichere doch einfach deine Werte in einem TreeSet. Dann hast du die Gewähr, dass jeder Wert nur einmal gespeichert ist, und du kannst die Werte in aufsteigender Sortierung durchlaufen. Und wenn du ein Element schon schon gespeichert hast, kannst du das in einer Hashtable o.ä. vermerken.


----------



## youza (4. Mai 2010)

```
import java.util.ArrayList;
import java.util.Arrays;

public class Tester {
	
	public static void main( String [] args) 
	{
		int b [] = new int[]{1, 12, 45, 12, 1};
		System.out.println(kleinsterWert(b));
		System.out.println(zweitKleinsterWert(b));
		int Temp[] = verschiedeneWerte(b);
		for (int i = 0; i < Temp.length; i++) {
			System.out.println(Temp[i]);
		}
	}
	public static int kleinsterWert(int[]b){
		int erg = b[0];
		for (int i = 0; i < b.length; i++) {
			if(b[i]<erg)
			{
				erg = b[i];
			}
		}
		return erg;
	}
	
	public static int zweitKleinsterWert(int[]b){
		
		Arrays.sort(b);
		int kleinster = b[0];
		for (int i = 0; i < b.length; i++) {
			if(b[i]==kleinster)
			{}
			else
			return b[i];
		}
		return kleinster;
	}
	public static int[] verschiedeneWerte(int[]b){
		ArrayList<Integer> merker = new ArrayList<Integer>();
		Arrays.sort(b);
		int Temp = b[0];
		merker.add(b[0]);
		for (int i = 0; i < b.length; i++) {
			if(b[i]==Temp)
			{}
			else
			{
				merker.add(b[i]);
				Temp = b[i];
			}
		}
		int[] erg = new int[merker.size()];
		for (int i = 0; i < erg.length; i++) {
			erg[i] = merker.get(i);
		}
		return erg;
	}

}
```

Is zwar sau umständlich aber funktioniert.


----------



## Vereth (4. Mai 2010)

Eigentlich dachte ich mir das so:

```
import java.util.TreeSet;


public class Main
{

  /**
   * @param args
   */
  public static void main(String[] args)
  {
    // Die Testwerte
    Integer[] arr = {1,2,3,4,1,2,3,1,2,1}; 
    // Das Set zum Zwischenspeichern
    TreeSet<Integer> set = new TreeSet<Integer>();
    // Die Werte werden in das Set kopiert
    // doppelte Werte werden automatisch ignoriert (Set-Interface!)
    for ( Integer i : arr )
    { set.add(i); }
    // Test-Ausgabe der Werte
    // die Werte sind in aufsteigender Reihenfolge sortiert (TreeSet!)
    System.out.println("TreeSet-Werte:");
    for ( Integer j : set )
    { System.out.println(j); }
    // umkopieren in ein Array
    // die Array-Größe wird automatisch angepasst
    Integer[] res1 = new Integer[set.size()];
    Integer[] res2;
    res2 = set.toArray(res1); 
    // nochmalige Test-Ausgabe
    System.out.println("\nArray-Werte:");
    for ( Integer k : res2 )
    { System.out.println(k); }
    // Prüfen, ob res1 und res2 dasselbe Objekt sind
    if ( res1 == res2 )
      System.out.println("\nIdentisch");
    else System.out.println("\nVerschieden");
  }
}
```
Die erwähnte HashTable sollte nur verwendet werden, wenn die Anzahl des mehrmaligen Vorkommens eines Wertes mitgezählt werden soll.


----------

