Schreiben Sie eine Mode-Methode in Java, um das am häufigsten vorkommende Element in einem Array zu finden

Die Frage geht:

Schreiben Sie eine Methode namens mode, die das am häufigsten vorkommende Element eines Arrays von ganzen Zahlen zurückgibt. Angenommen, das Array hat mindestens ein Element und jedes Element im Array hat einen Wert zwischen 0 und 100 einschließlich. Brechen Sie den Gleichstand, indem Sie den niedrigeren Wert wählen.

Wenn das übergebene Array beispielsweise die Werte {27, 15, 15, 11, 27} enthält, sollte Ihre Methode 15 zurückgeben wie man dieses Problem löst.)

Unten ist mein Code, der fast funktioniert, außer für Einzelelement-Arrays

public static int mode(int[] n)
{
    Arrays.sort(n);
    
    int count2 = 0;
    int count1 = 0;
    int pupular1 =0;
    int popular2 =0;
    
    
    for (int i = 0; i < n.length; i++)
    {
            pupular1 = n[i];
            count1 = 0;    //see edit
        
        for (int j = i + 1; j < n.length; j++)
        {
            if (pupular1 == n[j]) count1++;
        }
        
        if (count1 > count2)
        {
                popular2 = pupular1;
                count2 = count1;
        }
        
        else if(count1 == count2)
        {
            popular2 = Math.min(popular2, pupular1);
        }
    }
    
    return popular2;
}

Bearbeiten: endlich herausgefunden. Geändert count1 = 0; zu count1 = 1; alles funktioniert jetzt!

Für solche Probleme sollten Sie eine Hashmap verwenden. Es dauert O(n) Zeit, um jedes Element in die Hashmap einzugeben, und O(1), um das Element abzurufen. In dem angegebenen Code nehme ich im Grunde genommen ein globales Maximum und vergleiche es mit dem Wert, der bei „get“ von der Hashmap empfangen wird. Jedes Mal, wenn ich ein Element hineingebe, schaue es dir an:

hashmap besteht aus zwei Teilen, einer ist der Schlüssel, der zweite ist der Wert, wenn Sie eine Get-Operation für den Schlüssel ausführen, wird sein Wert zurückgegeben.

public static int mode(int []array)
{
    HashMap<Integer,Integer> hm = new HashMap<Integer,Integer>();
    int max  = 1;
    int temp = 0;

    for(int i = 0; i < array.length; i++) {

        if (hm.get(array[i]) != null) {

            int count = hm.get(array[i]);
            count++;
            hm.put(array[i], count);

            if(count > max) {
                max  = count;
                temp = array[i];
            }
        }

        else 
            hm.put(array[i],1);
    }
    return temp;
}

Sie sollten dies in N Operationen tun können, dh in nur einem Durchgang, O(n) Zeit.

Verwenden Sie eine Karte oder int[] (wenn das Problem nur für Ints besteht), um die Zähler zu erhöhen, und verwenden Sie auch eine Variable, die den Schlüssel behält, der die maximale Anzahl gesehen hat. Jedes Mal, wenn Sie einen Zähler erhöhen, fragen Sie nach dem Wert und vergleichen Sie ihn mit dem zuletzt verwendeten Schlüssel. Wenn der Wert größer ist, aktualisieren Sie den Schlüssel.

public class Mode {
public static int mode(final int[] n) {
    int maxKey = 0;
    int maxCounts = 0;

    int[] counts = new int[n.length];

    for (int i=0; i < n.length; i++) {
        counts[n[i]]++;
        if (maxCounts < counts[n[i]]) {
            maxCounts = counts[n[i]];
            maxKey = n[i];
        }
    }
    return maxKey;
}

public static void main(String[] args) {
    int[] n = new int[] { 3,7,4,1,3,8,9,3,7,1 };
    System.out.println(mode(n));
}
}

public int mode(int[] array) {
    int mode = array[0];
    int maxCount = 0;
    for (int i = 0; i < array.length; i++) {
        int value = array[i];
        int count = 1;
        for (int j = 0; j < array.length; j++) {
            if (array[j] == value) count++;
            if (count > maxCount) {
                mode = value;
                maxCount = count;
            }
        }
    }
    return mode;
}

Überprüfen Sie dies.

  int popularity1 = 0;
  int popularity2 = 0;
  int popularity_item, array_item; //Array contains integer value. Make it String if array contains string value.
  for(int i =0;i<array.length;i++){
      array_item = array[i];
      for(int j =0;j<array.length;j++){
          if(array_item == array[j])
             popularity1 ++;
          {
      if(popularity1 >= popularity2){
          popularity_item = array_item;
          popularity2 = popularity1;
      }
      popularity1 = 0;
  }
  //"popularity_item" contains the most repeted item in an array.

Ich würde diesen Code verwenden. Es enthält eine instancesOf Funktion, und es durchläuft jede Zahl.

public class MathFunctions {

public static int mode(final int[] n) {
    int maxKey = 0;
    int maxCounts = 0;

    for (int i : n) {
        if (instancesOf(i, n) > maxCounts) {
            maxCounts = instancesOf(i, n);
            maxKey = i;
        }
    }

    return maxKey;
}

public static int instancesOf(int n, int[] Array) {
    int occurences = 0;
    for (int j : Array) {
        occurences += j == n ? 1 : 0;
    }
    return occurences;
}

public static void main (String[] args) {
    //TODO Auto-generated method stub
    System.out.println(mode(new int[] {100,200,2,300,300,300,500}));
}
}

Ich habe festgestellt, dass der von Gubatron gepostete Code auf meinem Computer nicht funktioniert; es gab mir ein ArrayIndexOutOfBoundsException.

Hier ist meine Antwort.

public static int mode(int[] arr) {
    int max = 0;
    int maxFreq = 0;

    Arrays.sort(arr);
    max = arr[arr.length-1];

    int[] count = new int[max + 1];

    for (int i = 0; i < arr.length; i++) {
        count[arr[i]]++;
    }

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

    for (int i = 0; i < count.length; i++) {
        if (count[i] == maxFreq) {
            return i;
        }
    }
    return -1;
}

Ich weiß, dass diese Frage schon eine Weile her ist, aber ich wollte eine Antwort hinzufügen, von der ich glaube, dass sie die ursprüngliche Frage erweitert. Der Zusatz zu dieser Frage bestand darin, die Modusmethode zu schreiben, ohne sich auf einen voreingestellten Bereich (in diesem Fall 0 bis 100) zu verlassen. Ich habe eine Version für mode geschrieben, die den Wertebereich im ursprünglichen Array verwendet, um das count-Array zu generieren.

public static int mode(int[] list) {

    //Initialize max and min value variable as first value of list
    int maxValue = list[0]; 
    int minValue = list[0];

    //Finds maximum and minimum values in list
    for (int i = 1; i < list.length; i++) {
        if (list[i] > maxValue) {
            maxValue = list[i];
        }

        if (list[i] < minValue) {
            minValue = list[i];
        }
    }

    //Initialize count array with (maxValue - minValue + 1) elements  
    int[] count = new int[maxValue - minValue + 1];

    //Tally counts of values from list, store in array count
    for (int i = 0; i < list.length; i++) {
        count[list[i] - minValue]++; //Increment counter index for current value of list[i] - minValue
    }

    //Find max value in count array
    int max = count[0]; //Initialize max variable as first value of count

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

    //Find first instance where max occurs in count array
    for (int i = 0; i < count.length; i++) {
        if (count[i] == max) {
            return i + minValue; //Returns index of count adjusted for min/max list values - this is the mode value in list
        }
    }
    return -1; //Only here to force compilation, never actually used
}