web-dev-qa-db-de.com

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

Die Frage lautet: 

Schreiben Sie eine Methode namens mode, die das am häufigsten vorkommende Element eines Arrays von Ganzzahlen zurückgibt. Angenommen, das Array hat mindestens ein Element und jedes Element im Array hat einen Wert zwischen 0 und einschließlich 100. Brechen Sie die Bindung, indem Sie den niedrigeren Wert auswä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 Arrays mit einem Element

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;
}

Edit : endlich herausgefunden. count1 = 0; in count1 = 1; geändert, jetzt funktioniert alles!

9
TonyGW

Sie sollten für solche Probleme eine Hashmap verwenden. O(n) braucht Zeit, um jedes Element in die Hashmap einzugeben, und o(1), um das Element abzurufen. In dem angegebenen Code nehme ich im Wesentlichen ein globales Maximum und vergleiche es mit dem Wert, den ich mit 'get' von der Hashmap erhalten habe. Jedes Mal, wenn ich ein Element in dieses Feld eingebe, schau es 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. Der Wert wird 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;
}
13
codemania23

Sie sollten in der Lage sein, dies in N Operationen zu tun, dh in einem einzigen Durchgang O(n).

Verwenden Sie eine Map oder int [] (wenn das Problem nur für ints gilt), um die Zähler zu erhöhen, und verwenden Sie auch eine Variable, die den Schlüssel enthält, der die maximale Anzahl anzeigt. Wenn Sie einen Zähler inkrementieren, 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));
}
}
4
Gubatron
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;
}
2
Snerdling

check this .. Brief: Wählen Sie jedes Element eines Arrays aus und vergleichen Sie es mit allen Elementen des Arrays. 

  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.
1
Praful
    Arrays.sort(arr);
    int max=0,mode=0,count=0;
    for(int i=0;i<N;i=i+count) {
        count = 1;
        for(int j=i+1; j<N; j++) {
            if(arr[i] == arr[j])
                count++;
        }
        if(count>max) {
            max=count;
            mode = arr[i];
        }
    }
0
Saurabh Nigam

Ich weiß, dass diese Frage schon vor einiger Zeit stammt, aber ich wollte eine Antwort hinzufügen, die meiner Meinung nach 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 von 0 bis 100) zu verlassen. Ich habe eine Version für den Modus geschrieben, die den Wertebereich des ursprünglichen Arrays verwendet, um das Zählarray 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
}
0
flamewheel

Hier habe ich mit Einzelschleife codiert. Der Modus wird von a [j-1] abgerufen, da localCount kürzlich aktualisiert wurde, als j j-1 war. Auch N ist die Größe des Arrays und die Zähler werden auf 0 initialisiert.

        //After sorting the array 
        i = 0,j=0;
        while(i!=N && j!=N){
            if(ar[i] == ar[j]){
                localCount++;
                j++;
            }
            else{
                i++;
                localCount = 0;
            }
            if(localCount > globalCount){
                globalCount = localCount;
                mode = ar[j-1]; 
            }
        }
0
Rohith.

Dies ist nicht die schnellste Methode im gesamten Block, aber es ist ziemlich einfach zu verstehen, wenn Sie sich nicht in HashMaps einbinden und auch die Verwendung von 2 für Schleifen bei Komplexitätsproblemen vermeiden möchten.

    int mode(int n, int[] ar) {
    int personalMax=1,totalMax=0,maxNum=0;

    for(int i=0;i<n-1;i++)
    {

        if(ar[i]==ar[i+1])
        {
            personalMax++;

            if(totalMax<personalMax)
            {
                totalMax=personalMax;
                maxNum=ar[i];
            }
        }    
        else
        {
            personalMax=1;
        }
    }
    return maxNum;
}
0
Ajinkya Upasani

Basierend auf der Antwort von @ codemania23 und den Java Docs für HashMap habe ich diesen Code erstellt und eine Methode ausprobiert, die die am häufigsten vorkommende Zahl in einem Array von Zahlen zurückgibt.

import Java.util.HashMap;

public class Example {

    public int mostOcurrentNumber(int[] array) {
        HashMap<Integer, Integer> map = new HashMap<>();
        int result = -1, max = 1;
        for (int arrayItem : array) {
            if (map.putIfAbsent(arrayItem, 1) != null) {
                int count = map.get(arrayItem) + 1;
                map.put(arrayItem, count);
                if (count > max) {
                    max = count;
                    result = arrayItem;
                }
            }
        }

        return result;
    }
}

Unit-Tests

import org.junit.Test;

import static junit.framework.Assert.assertEquals;

public class ExampleTest extends Example {

    @Test
    public void returnMinusOneWhenInputArrayIsEmpty() throws Exception {
        int[] array = new int[0];
        assertEquals(mostOcurrentNumber(array), -1);
    }

    @Test
    public void returnMinusOneWhenElementsUnique() {
        int[] array = new int[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
        assertEquals(-1, mostOcurrentNumber(array));
    }

    @Test
    public void returnOne() throws Exception {
        int[] array = new int[]{0, 1, 0, 0, 1, 1, 1};
        assertEquals(1, mostOcurrentNumber(array));
    }

    @Test
    public void returnFirstMostOcurrentNumber() throws Exception {
        int[] array = new int[]{0, 1, 0, 1, 0, 0, 1, 1};
        assertEquals(0, mostOcurrentNumber(array));
    }
}

Ich würde diesen Code verwenden. Sie enthält eine instancesOf-Funktion und führt jede Zahl durch.

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 veröffentlichte Code auf meinem Computer nicht funktioniert. es gab mir eine ArrayIndexOutOfBoundsException.

0
HyperNeutrino

java.util.HashMap importieren;

öffentliche Klasse SmallestHighestRepeatedNumber { statisch int arr [] = {9, 4, 5, 9, 2, 9, 1, 2, 8, 1, 1, 7, 7};

public static void main(String[] args) {
    int mode = mode(arr);
    System.out.println(mode);
}

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 || temp > array[i] && count == max) {
                temp = array[i];
                max = count;
            }
        } else
            hm.put(array[i], 1);
    }
    return temp;
}

}

0
shrekanth

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;
}
0
user1059804

Ich habe vor kurzem ein Programm erstellt, das einige verschiedene Statistiken einschließlich des Modus berechnet. Die Codierung kann zwar rudimentär sein, funktioniert jedoch für jedes Array von Ints und kann so geändert werden, dass sie Doubles, Floats usw. ist. . Auf diese Weise können Sie alle Modi anzeigen (wenn mehrere vorhanden sind) sowie die Anzahl der Vorkommen (letztes Element im Modi-Array). Der folgende Code ist die getMode-Methode sowie die deleteValueIndex-Methode, die zum Ausführen dieses Codes erforderlich ist

import Java.io.File;
import Java.util.Scanner;
import Java.io.PrintStream;

public static int[] getMode(final int[] array) {           
  int[] numOfVals = new int[array.length];
  int[] valsList = new int[array.length];

  //initialize the numOfVals and valsList

  for(int ix = 0; ix < array.length; ix++) {
     valsList[ix] = array[ix];
  }

  for(int ix = 0; ix < numOfVals.length; ix++) {
     numOfVals[ix] = 1;
  }

  //freq table of items in valsList

  for(int ix = 0; ix < valsList.length - 1; ix++) {
     for(int ix2 = ix + 1; ix2 < valsList.length; ix2++) {
        if(valsList[ix2] == valsList[ix]) {
           numOfVals[ix] += 1;
        }
     }
  }

  //deletes index from valsList and numOfVals if a duplicate is found in valsList

  for(int ix = 0; ix < valsList.length - 1; ix++) {   
     for(int ix2 = ix + 1; ix2 < valsList.length; ix2++) {
        if(valsList[ix2] == valsList[ix]) {
           valsList = deleteValIndex(valsList, ix2);
           numOfVals = deleteValIndex(numOfVals, ix2);
        }
     }
  }

  //finds the highest occurence in numOfVals and sets it to most

  int most = 0;

  for(int ix = 0; ix < valsList.length; ix++) {
     if(numOfVals[ix] > most) {
        most = numOfVals[ix];
     }
  }

  //deletes index from valsList and numOfVals if corresponding index in numOfVals is less than most

  for(int ix = 0; ix < numOfVals.length; ix++) {
     if(numOfVals[ix] < most) {
        valsList = deleteValIndex(valsList, ix);
        numOfVals = deleteValIndex(numOfVals, ix);
        ix--;
     }
  }

  //sets modes equal to valsList, with the last index being most(the highest occurence)

  int[] modes = new int[valsList.length + 1];

  for(int ix = 0; ix < valsList.length; ix++) {
     modes[ix] = valsList[ix];
  }

  modes[modes.length - 1] = most;

  return modes;

}

public static int[] deleteValIndex(int[] array, final int index) {   
  int[] temp = new int[array.length - 1];
  int tempix = 0;

  //checks if index is in array

  if(index >= array.length) {
     System.out.println("I'm sorry, there are not that many items in this list.");
     return array;
  }

  //deletes index if in array

  for(int ix = 0; ix < array.length; ix++) {
     if(ix != index) {
        temp[tempix] = array[ix];
        tempix++;
     }
  }
  return temp;
}
0
Steve