Ist es möglich, das größte und zweitgrößte element in einem Array mit nur einer Schleife ausfindig zu machen ?

Diskutiere Ist es möglich, das größte und zweitgrößte element in einem Array mit nur einer Schleife ausfindig zu machen ? im Java Basics - Anfänger-Themen Bereich.
M

Martze

Hallo,
Meine Frage wie in der Überschrift genau genug definiert. es handelt ist um ein Integerarray.

Hier ein Code als Beispiel, um zu verstehen was ich meine, das Problem hierbei ist nur, dass ich diese Aufgabe mit 2 Schleifen gelöst habe, ich möchte jedoch wissen, ob dies auch mit einer gehen würde und wie:


Java:
    public static void main(String[] args) {

        int max = 0;
        int secondmax = 0;

        int[] array = new int[] { 5, 7, 4, 3, 9, 5, 14, 2, 8, 4, 6, 5 };

        // firstsecond zweischleifig

        for (int i = 0; i < array.length; i++) {
            if (array[i] > max)
                max = array[i];
        }

        for (int i = 0; i < array.length; i++) {
            if (array[i] < max && secondmax < array[i])
                secondmax = array[i];
        }

        System.out.println(max + " " + secondmax);

    }
Vielen Dank für die Antwort schonmal
 
Tarrew

Tarrew

Ja, das sollte möglich sein.
Wenn du ein neues maximales Element findest, dann wird dein altes max-Element ja gleichzeitig zum zweitgrößten Element ;)
 
Tarrew

Tarrew

Für den Fall muss du eine extra Bedingung einfügen, aber mit einer Schleife geht das immer noch.

Java:
for (int i = 0; i < array.length; i++) {
    if (array[i] > max) {
        secondmax = max;
        max = array[i];
    } else if (array[i] > secondmax) {
        secondmax = array[i];
    }
}
 
Zuletzt bearbeitet:
W

White_Fox

Wieso initialisierst du int max nicht mit dem kleinsten Wert, der vorkommen kann? Dann kannst du dir das if sparen.

Und bedenke den Fall daß ein neues Element zwar kleiner als max ist, aber größer als max-1 sein kann. Wenn dein größtes Element sieben und dein zweitgrößtes Element fünf ist, hast du ein Problem wenn auf einmal eine sechs reingerät.
 
mrBrown

mrBrown

Wieso initialisierst du int max nicht mit dem kleinsten Wert, der vorkommen kann? Dann kannst du dir das if sparen.

Und bedenke den Fall daß ein neues Element zwar kleiner als max ist, aber größer als max-1 sein kann. Wenn dein größtes Element sieben und dein zweitgrößtes Element fünf ist, hast du ein Problem wenn auf einmal eine sechs reingerät.
Auf welchen Code beziehst du dich?
 
W

White_Fox

Auf keinen Code...nur auf die Beschreibung von Tarrew ganz oben.

Aber ich sehe gerade: Tarrew hat den Fall in seinem Beispiel ja berücksichtigt. Mea Culpa.
 
X

Xyz1

Man kommt mit genau zwei Fällen in der Schleife aus
Java:
		int n = 2;
		int[] array = new int[n];
		for (int i = 0; i < array.length; i++) {
			array[i] = new Random().nextInt(6);
		}
		int m1 = array[0] >= array[1] ? 0 : 1;
		int m2 = array[0] < array[1] ? 0 : 1;
		for (int i = 2; i < array.length; i++) {
			if (array[i] > array[m1]) {
				m2 = m1;
				m1 = i;
			} else if (array[i] > array[m2]) {
				m2 = i;
			}
		}
		System.out.println(Arrays.toString(array));
		System.out.println(array[m1] + " " + array[m2] + " " + m1 + " " + m2);
(Aber das Array muss mind eine Länge von 2 haben denn sonst wird es schwer das zweitgrößte Element zu finden) :(
 
X

Xyz1

Da bin ich nicht bei dir. Alleine schon die Benennung der Variablen macht sie deutlich undurchsichtiger.
Nein, das ist Quatsch. Zum Beispiel möchte ich keinen Informationsverlust haben bei dem Index von gleichen Elementen. Für jeden Programmierer mit etwas Erfahrung sollte das selbstverständlich sein - andernfalls weise ich auch darauf hin.
 
mihe7

mihe7

Java:
public class TwoLargestElements<T extends Comparable<T>> {
    private int ixFirstMax = -1;
    private int ixSecondMax = -1;
    private T[] data;

    public TwoLargestElements(T[] arr) {
        data = arr;
        if (arr.length > 1) {
            findMaxs();
        }        
    }

    private void findMaxs() {
        ixFirstMax = data[1].compareTo(data[0]) > 0 ? 1 : 0;
        ixSecondMax = -(ixFirstMax-1);
        for (int i = 2; i < data.length; i++) {
            if (data[i].compareTo(data[ixFirstMax]) > 0) {
                ixSecondMax = ixFirstMax;
                ixFirstMax = i;
            } else if (data[i].compareTo(data[ixSecondMax]) > 0) {
                ixSecondMax = i;
            }
        }
    }
  
    public int indexOfLargest() { return ixFirstMax; }
    public int indexOfSecondLargest() { return ixSecondMax; }
    public T largest() { return data[ixFirstMax]; }
    public T secondLargest() { return data[ixSecondMax]; }

    public static void main(String[] args) {
        TwoLargestElements<Integer> tl = new TwoLargestElements<>(
            new Integer[]{-8,-10,-1, -2, -3, -4, -5});
        System.out.println(tl.largest());
        System.out.println(tl.secondLargest());
    }
}
Gut, damit kommen wir allmählich in den Blödsinn rein :)
 
Thema: 

Ist es möglich, das größte und zweitgrößte element in einem Array mit nur einer Schleife ausfindig zu machen ?

Passende Stellenanzeigen aus deiner Region:
Anzeige

Anzeige

Anzeige
Oben