Wie nach häufigsten Werten im Array/Java suchen?
Schreiben Sie eine Methode, die in einem int-Feld mit Werten zwischen 0 und 9 nach
dem Wert sucht, der am häufigsten im Feld vorkommt. Sollten Werte gleichhäufig vor-
kommen, so soll der kleinste von ihnen zurückgegeben werden.
Beispiel: Für das Feld { 1,2,3,3,5,9,7,7,1,3,7 } soll der Wert 3 zurückgegeben werden,
da 3 und 7 jeweils dreimal vorkommen und 3 kleiner als 7 ist.
Sry, die Frage soll lauten wie nach Häufigsten Werten im Array/ Java suchen?
4 Antworten
Ich würde mit einer Schleife arbeiten und mit einem zweiten Feld, in dem man jeweils den Index der Zahl nimmt und jeweils das element mit dem Index Zahl[i] erhöht.
Dann würde ich einfach den Maximalen Wert suchen mit der Abfrage mit >.
Wenn es "nur" die Zahlen von '0' bis '9' sind, dann einfach in einem Array durchzählen.
Falls es wesentlich mehr bzw. komplexere Zeichen sind, nimm eine Map als Zähler.
Da es nur die Werte von 0 bis 9 haben kann: Erstell doch einfach ein neues int-Array der Länge 10 - der Wert eines bestimmten Index ist hierbei die Anzahl für die entsprechende Zahl
Vereinfachtes Beispiel:
Werte von 0 bis 3 möglich, Array a (dein Input) ist {0, 0, 1, 3, 2, 0}
Dann erstellst du ein Array b der Länge 4 und iterierst über Array a. Du zählst jedes mal den entsprechenden Index hoch.
Array b wäre dann z.B. {3, 1, 1, 1}
public class HäufigstenWert {
public static void main(String[] args) {
int[] feld= {1,2,3,3,5,9,7,7,1,3,7};
System.out.println(berechneHaufigstenWert(feld));
}
public static int berechneHaufigstenWert(int [] feld) {
assert(feld != null);
int [] feld1 = new int [9];
int max=0;
int maxNumber=0;
for(int i=0;i<feld.length;i++)
{
for (int j=1;j<feld.length;j++)
{
if (feld[i]==feld[j])
{
max++;
maxNumber=feld[i];
}
}
}return maxNumber;
}
}
Das ist auch nicht ganz, was ich gemeint habe.
Warum die doppelte Schleife? Und du zählst max immer hoch, wenn eine doppelte Zahlg efunden wurde, ohne es zu Nutzen. zudem setzt du maxNumber quasi auf die letzte Nummer, die doppelt ist ...
okay, teil das ganze doch in zwei Schritte auf:
Eine Methode, die die Anzahl der Werte zählt (und ein int[] der Länge 10 (! NICHT 9 !) zurückgibt.
Und eine weitere Methode, die dieses Array nimmt und dort nach dem häufigsten Wert sucht
Alternativ kannst du die Liste auch sortieren und nach dem größten Vorkommen der gleichen Zahl suchen
hab das mal kurz für mich ausprogrammiert. Wie ich vorgegangen bin - mit Kommentaren:
- Finde das größte Element der Liste
- nutze dies, um ein Array dieser Länge + 1 zu erstellen
diese beiden Schritte kannst du theoretisch auch überspringen oder sogar ausbauen - dass auch ein anderer Wert als 0 dein Minimum sein kann
- Iteriere über deine Ursprungsliste - zähle den der aktuellen Zahl entsprechenden Index hoch
Da du dies wohl nicht verstanden hast: Nehmen wir mein Beispiel von oben erneut.
Werte von 0 bis 3 möglich, Array a (dein Input) ist {0, 0, 1, 3, 2, 0}
Dann erstellst du ein Array b der Länge 4 und iterierst über Array a. Du zählst jedes mal den entsprechenden Index hoch.
was dann passiert:
1. Wert: 0 => Zähle b[0] um eins hoch
2. Wert: 0 => Zähle b[0] um eins hoch
3. Wert: 1 => Zähle b[1] um eins hoch
4. Wert: 3 => Zähle b[3] um eins hoch
5. Wert: 2 => Zähle b[2] um eins hoch
6. Wert: 0 => Zähle b[0] um eins hoch
==> b ist also {3, 1, 1, 1}
du hast jetzt also eine Liste, die bei Index 0 die Anzahl der Vorkommnisse der Zahl 0 hat, bei Index 1 die Anzahl der Vorkommnisse der Zahl 1 usw ...
- Iteriere über das Zähl-Array und suche nach dem Maximum. Da die Liste aufsteigend nach der Zahl selbst sortiert ist, wirst du auch immer das Maximum mit der kleinsten Nummer (im Falle, dass mehrere Zahlen gleich oft vorkommen) finden.
DCS (Distribution Count Sort, auch Countingsort).
Erzeuge ein Zählarray, dann scanne das Array und setze zählarray[Array[i]]+=1; Am Ende scanst Du über Zählarray und suchst das Maximum. Der Index des Maximus ist die häufigste Zahl im Array.
public class HäufigstenWert {
public static void main(String[] args) {
int[] feld= {1,2,3,3,5,9,7,7,1,3,7};
System.out.println(berechneHaufigstenWert(feld));
}
public static int berechneHaufigstenWert(int [] feld) {
assert(feld != null);
int [] feld1 = new int [9];
int max=0;
int maxNumber=0;
for(int i=0;i<feld.length;i++)
{
for (int j=1;j<feld.length;j++)
{
if (feld[i]==feld[j])
{
max++;
maxNumber=feld[i];
}
}
}return maxNumber;
}
}
int [] feld1 = new int [10]; /* 0-9 */
for (int i=0;i<feld.length;++i) feld1[feld[i]]+=1; /* DCS */
int max=0; /* Annahme 0 hat größte Häufigkeit */
for int(i=1;i<feld1.length;++i) if(feld1[i]>feld1[max]) max=i; /* scan nach größerer Häufigkeit */
return max;
Das sollte eigentlich reichen, wenn ich um die Uhrzeit nichts übersehen habe.
public class HäufigstenWert {
public static void main(String[] args) {
int[] feld = { 1, 2, 3, 3, 5, 9, 7, 7, 1, 3, 7 };
System.out.println(berechneHäufigstenWert(feld));
}
public static int berechneHäufigstenWert(int[] feld) {
int counter = 0;
int old = 1;
int erg = 0;
for (int i = 0; i < feld.length; i++) {
for (int j = 0; j < feld.length; j++) {
if (feld[i] == feld[j]) {
counter++;
}
}
if (counter > old) {
erg = feld[i];
old = counter;
}
counter = 0;
}
return erg;
}
}
Das kann man natürlich auch so machen, nur hat das halt quadratische Laufzeit.
und wieso das und nicht den Index direkt, wenn man eh die Werte 0 bis 9 hat?