# 2.Grösster Wert Array



## Blackmore84 (6. Aug 2012)

Tag Zusammen, ich hab ein kleines Problem.
und zwar soll ich bei einem Array die zwei grössten Werte ausgeben lassen. (dies ohne spezielle Methoden, also "Handberechnung")
Das Maximum ist ja keine Sache, das ist einfach.
Aber wie komm ich auf den zweithöchsten Wert?

Das unten ist mein Ansatz. Ich weiss, dass ich irgendwie die elende 8 in die Variable max2 speichern muss.
Aber irgendwie komme ich immer auf denselben Wert wie max(also 12) oder auf -3 und das ist dann wohl vollkommen falsch.
Vielen Dank jetzt schon für die Hilfe.


```
public class Aufgabe2 {

	public static void main(String[] args) {
		 int[] arr = {3, 1, 5, 7, 4, 12, -3, 8, -2};
		
		    // Variablen für die zwei größten Elemente deklarieren und initialisieren
		 	int max = arr[0];
		 	int max2 = arr[0];

		    // die zwei größten Elemente berechnen
		    for ( int index=0 ; index < arr.length; index++)
		    {
		    	if(arr[index] > max )
		    	{
		    		max = arr[index];
		    		
		    	}
		    	if(max2 > arr[index] && max2 < max)
		    	{
		    		max2 = arr[index];
		    	}
		    	
		    	
		    	
		    	
		    }

		    // die zwei größten Elemente ausgeben
		    System.out.println("Das grösste: " + max + " das 2.Grösste: " + max2  );

	}

}
```


----------



## tribalup (6. Aug 2012)

Mach dir doch ein zweites Array in dem du alle Werte ausser dem größten speicherst und wiederhole den Vorgang. Oder du speicherst den ersten Wert in max, dann schauste ob der zweite größer als der erste ist.
Wenn ja speicher ihn in max, wenn nein dann in max2. Beime dritten kuckste ob größer max. Wenn nicht dann schau ob größer max2. Wenn ja dann ist es der neue max2 wenn nicht verwerfen und weiter.


----------



## tfa (6. Aug 2012)

Wenn der aktuelle Wert x größer ist als der bisher größte, wird x der größte und der alte größte der neue zweitgrößte,
sonst, wenn x größer ist als der zweitgrößte, wird x der neue zweitgrößte.


----------



## Gast2 (6. Aug 2012)

Die Bedingung bei max2 ist falsch.

```
if (max2 > arr[index] ...
```
=>

```
if (max2 < arr[index] ...
```

Etwas einfacher könntest du das so machen:
Array sortieren und die beiden ersten Werte auslesen.


----------



## pl4gu33 (6. Aug 2012)

tfa hat gesagt.:


> Wenn der aktuelle Wert x größer ist als der bisher größte, wird x der größte und der alte größte der neue zweitgrößte,
> sonst, wenn x größer ist als der zweitgrößte, wird x der neue zweitgrößte.



also je nach Aufgabenstellung kann der größte Wert ja auch doppelt vorkommen daher wäre bei der ersten Überprüfung größer/gleich auch möglich

und benutz else if, sparst dir damit die "2te Bedingung" im Vgl.


----------



## Blackmore84 (6. Aug 2012)

Danke euch allen.

Habe das else if komplett ignoriert und nur mit if gearbeitet (wieso auch immer).
Aber irgendwie verwirren mich die Arrays noch ein klein wenig und ich denke immer irgendwie falsch bei den Dingern.
Na ja, üben üben üben!


----------



## pl4gu33 (6. Aug 2012)

achja noch was  
initalisiere die beiden Variablen nicht mit dem ersten Wert im Array, weil wenn das der größte Wert ist, wird nix geändert und max und max2 sind bis zum Schluß auf dem größten Wert


----------



## Blackmore84 (6. Aug 2012)

pl4gu33 hat gesagt.:


> achja noch was
> initalisiere die beiden Variablen nicht mit dem ersten Wert im Array, weil wenn das der größte Wert ist, wird nix geändert und max und max2 sind bis zum Schluß auf dem größten Wert



Aber habe ich dieses Problem nicht bei jedem wert mit dem ich initialisiere? Und wenn ich mit 0 initialisieren würde könnte es ja nur negative zahlen geben.

Oder meinst Du ich soll irgendeinen extrem tiefen wert nehmen?


----------



## JimK (6. Aug 2012)

Du könnste das Array auch einfach sortieren und dann den zweiten Wert nehmen.


----------



## pl4gu33 (6. Aug 2012)

also entweder prüft du direkt vor der Schleife:


```
if(arr[0]>=arr[1]){
        	   max = arr[0];
        	   max2 = arr[1];
         }else{
        	  max=arr[1];
        	  max2=arr[0];
           }
```

und fängst die Schleife dann ab dem zweiten Element an durchzulaufen....
oder du baust die Zuweisung mit in die Schleife ein, sodass die ersten beiden Werte als "Startwerte" je nach größe genommen werden und danach weiter verglichen wird.

weil wenn du irgendeinen Wert zuweist, kann es immer passieren, dass die Werte zu hoch sind und es im Array nur tiefere Werte gibt,... daher musst du dann schon 2 Elemente aus dem Array nehmen

[EDIT]oder Michaels Lösung weiter unten 
das wäre wohl die Beste ohne viel drumrum  [/EDIT]


----------



## Blackmore84 (6. Aug 2012)

JimK hat gesagt.:


> Du könnste das Array auch einfach sortieren und dann den zweiten Wert nehmen.



Ja, das ist klar, aber denke, das war nicht der Sinn der Aufgabe, sondern, dass man rechnet (auch wenn das ein wenig mühsam ist.)

@ pl4gu33.
Stimmt, das wäre am elegantesten. Danke vielmals!


----------



## Michael... (6. Aug 2012)

Blackmore84 hat gesagt.:


> Oder meinst Du ich soll irgendeinen extrem tiefen wert nehmen?




```
int max = Integer.MIN_Value;
int max2 = Integer.MIN_Value;
```


----------



## L-ectron-X (6. Aug 2012)

Könnte man auch so machen:


```
public class Aufgabe2 {

    public static void main(String[] args) {
        int[] arr = {3, 1, 5, 7, 4, 12, -3, 8, -2};

        int maxIndex = 0;
        int max = Integer.MIN_VALUE;
        int max2 = Integer.MIN_VALUE;

        for (int i = 0; i < arr.length; i++) {
            if(arr[i] > max) {
                max = arr[i];
                maxIndex = i;
            }
        }
        
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] > max2 && i != maxIndex) {
                max2 = arr[i];
            }
        }

        // die zwei größten Elemente ausgeben
        System.out.println("Grösste Zahl: " + max + "\nZweitgrösste Zahl: " + max2);
    }
}
```
Voraussetzung: Es gibt keine Duplikate.


----------



## hüteüberhüte (6. Aug 2012)

Auch mal in die Trickkiste gegriffen:


```
int[] a = {3, 1, 5, 7, 4, 12, -3, 8, -2};

        int index1 = 0;
        int max1 = Integer.MIN_VALUE;
        int max2 = Integer.MIN_VALUE;

        for (int i = 0; i < a.length; i++) {
            if (a[i] > max1) {
                index1 = i;
                max1 = a[i];
            }
        }

        a[index1] = a[index1] + a[0] - (a[0] = a[index1]);

        for (int i = 1; i < a.length; i++) {
            if (a[i] > max2) {
                max2 = a[i];
            }
        }

        a[index1] = a[index1] + a[0] - (a[0] = a[index1]);

        System.out.println("max1 = " + max1);
        System.out.println("max2 = " + max2);
```

Alternativ:


```
int[] a = {3, 1, 5, 7, 4, 12, -3, 8, -2};

        int index1 = 0;
        int max1 = Integer.MIN_VALUE;
        int max2 = Integer.MIN_VALUE;

        for (int i = 0; i < a.length; i++) {
            if (a[i] > max1) {
                index1 = i;
                max1 = a[i];
            }
        }

        for (int i = 0; i < index1; i++) {
            if (a[i] > max2) {
                max2 = a[i];
            }
        }
        for (int i = index1 + 1; i < a.length; i++) {
            if (a[i] > max2) {
                max2 = a[i];
            }
        }

        System.out.println("max1 = " + max1);
        System.out.println("max2 = " + max2);
```

Edit: Oder du schleppst beide Werte mit:


```
int[] a = {3, 1, 5, 7, 4, 12, -3, 8, -2};

        int max1 = Integer.MIN_VALUE;
        int max2 = Integer.MIN_VALUE;

        for (int i = 0; i < a.length; i++) {
            if (a[i] > max1) {
                max2 = max1;
                max1 = a[i];
            } else if (a[i] > max2) {
                max2 = a[i];
            }
        }

        System.out.println("max1 = " + max1);
        System.out.println("max2 = " + max2);
```

Das könnte allerdings zu Gehirnverwindungen führen, wenn man länger darüber nachdenkt...

[EDIT]Edit 2: Sei a_ der größte Wert. Entweder ist der Index des zweitgrößten Werts < i oder > i. Fall < i: Da max2=max1 ist max2 der zweitgrößte Wert. Fall > i: Da max2=a[x] ist max2 auch der zweitgrößte Wert[/EDIT]_


----------

