java编程和查找数组模式

Question

我有一个任务，我需要找到一个数组模式。这意味着我正在寻找最频繁的整数。我已经有点完成了，但任务还说，如果有两种模式是相同的，我应该返回最小的整数例如{1,1,1,2,2,2}应该给1（就像在我的文件中我使用该阵列，它给出了2）

public class theMode 
{ 
public theMode() 
{ 
    int[] testingArray = new int[] {1,1,1,2,2,2,4}; 
    int mode=findMode(testingArray); 
    System.out.println(mode); 
} 

public int findMode(int[] testingArray) 
{ 
    int modeWeAreLookingFor = 0; 
    int frequencyOfMode = 0; 

    for (int i = 0; i < testingArray.length; i++) 
    { 
     int currentIndexOfArray = testingArray[i]; 
     int frequencyOfEachInArray = howMany(testingArray,currentIndexOfArray); 

     if (frequencyOfEachInArray > frequencyOfMode) 
     { 
      modeWeAreLookingFor = currentIndexOfArray; 
      frequencyOfMode = modeWeAreLookingFor; 

     } 
    } 
    return modeWeAreLookingFor; 
    } 

public int howMany(int[] testingArray, int c) 
{ 
    int howManyOfThisInt=0; 
    for(int i=0; i < testingArray.length;i++) 
    { 
     if(testingArray[i]==c){ 
      howManyOfThisInt++; 
     } 
    } 
    return howManyOfThisInt; 
} 


public static void main(String[] args) 
{ 
    new theMode(); 
} 
} 

当你看到我的算法返回最后找到的模式或我应该如何解释它。

Answer 1

这可能会稍作修改。

http://www.toves.org/books/java/ch19-array/index.html#fig2

if ((count > maxCount) || (count == maxCount && nums[i] < maxValue)) { 
    maxValue = nums[i]; 
    maxCount = count; 
} 

Answer 2

提示：当您找到频率更高的整数时，您正在更新ModeWeAreLookingFor。如果您发现与ModeWeAreLookingFor频率相同的整数，该怎么办？

额外练习：在主循环执行的第一次迭代中，计算'1'的频率。在第二次迭代（以及第三次和第四次）中，您重新计算此值。如果存储第一次计算的结果，则可以节省一些时间。可以用Map完成。

Java代码约定规定方法名称和变量名称应该以小写字符开头。如果遵循此惯例，您将拥有更好的语法着色和更易于阅读的代码。

Answer 3

我会以不同的方式处理它。使用地图可以将每个唯一编号用作关键字，然后将计数用作值。遍历数组并查找每个找到的数字，检查地图以查看是否存在具有该值的键。如果发现其中一个值增加1，否则创建一个值为1的新条目。

然后，您可以检查每个映射条目的值以查看哪个条目的计数最高。如果当前键的计数比前一个键的计数更高，那么它是“当前”答案。但是你有可能得到类似计数的密钥，所以你需要存储每个'winnning'的答案。

解决此问题的一种方法是检查每个地图的每个条目并删除每个条目的数量小于当前的最高数量。你将留下的是所有“最高计数”的地图。如果你的地图只有一个条目，那么关键是答案，否则你需要比较一组键来确定最低。

Answer 4

因为看起来没有其他办法，我做了一个hashmap毕竟。在比较频率时，我再一次陷入逻辑，如果频率相等，同时选择最低的整数。

 public void theMode() 
    { 
     for (Integer number: intAndFrequencyMap.keySet()) 
     { 
      int key = number; 
      int value = intAndFrequencyMap.get(number); 
      System.out.println("the integer: " +key + " exists " + value + " time(s)."); 
      int lowestIntegerOfArray = 0; 
      int highestFrequencyOfArray = 0; 
      int theInteger = 0; 
      int theModeWanted = 0; 

      if (value > highestFrequencyOfArray) 
      { 
       highestFrequencyOfArray = value; 
       theInteger = number; 
      } 
      else if (value == highestFrequencyOfArray) 
      { 
       if (number < theInteger) 
       { 
        number = theInteger; 
       } 
       else if (number > theInteger) 
       { 

       } 
       else if (number == theInteger) 
       { 
        number = theInteger; 
       } 
      } 
     } 
    } 

Answer 5

很高兴您设法解决它。正如您现在所看到的，解决问题的方法不止一种。这是我的意思是使用地图

package util; 

import java.util.HashMap; 
import java.util.Map; 

public class MathUtil { 

    public static void main(String[] args) { 
     MathUtil app = new MathUtil(); 
     int[] numbers = {1, 1, 1, 2, 2, 2, 3, 4}; 
     System.out.println(app.getMode(numbers)); 
    } 

    public int getMode(int[] numbers) { 
     int mode = 0; 
     Map<Integer, Integer> numberMap = getFrequencyMap(numbers); 

     int highestCount = 0; 

     for (int number : numberMap.keySet()) { 
      int currentCount = numberMap.get(number); 

      if (currentCount > highestCount) { 
       highestCount = currentCount; 
       mode = number; 
      } else if (currentCount == highestCount && number < mode) { 
       mode = number; 
      } 
     } 

     return mode; 
    } 

    private Map<Integer,Integer> getFrequencyMap(int[] numbers){ 
     Map<Integer, Integer> numberMap = new HashMap<Integer, Integer>(); 

     for (int number : numbers) { 
      if (numberMap.containsKey(number)) { 
       int count = numberMap.get(number); 
       count++; 
       numberMap.put(number, count); 
      } else { 
       numberMap.put(number, 1); 
      } 
     } 

     return numberMap; 
    } 
} 

Answer 6

完成：

import java.util.Arrays; 

public class TheMode                         
{ 
    //Probably not the most effective solution, but works without hashmap 
    //or any sorting algorithms 

public TheMode() 
{ 
    int[] testingArray = new int[] {2,3,5,4,2,3,3,3}; 
    int mode = findMode(testingArray); 
    System.out.println(Arrays.toString(testingArray)); 
    System.out.println("The lowest mode is: " + mode); 

    int[] test2 = new int[] {3,3,2,2,1}; 
    int mode2=findMode(test2); 
    System.out.println(Arrays.toString(test2)); 
    System.out.println("The lowest mode is: " +mode2); 

    int[] test3 = new int[] {4,4,5,5,1}; 
    int mode3 = findMode(test3); 
    System.out.println(Arrays.toString(test3)); 
    System.out.println(The lowest mode is: " +mode3); 
} 

public int findMode(int[] testingArray) 
{ 
    int modeWeAreLookingFor = 0; 
    int frequencyOfMode = 0; 

    for (int i = 0; i < testingArray.length; i++) 
    { 
     int currentIndexOfArray = testingArray[i]; 
     int countIntegerInArray = howMany(testingArray, currentIndexOfArray); 

     if (countIntegerInArray == frequencyOfMode) 
     { 
      if (modeWeAreLookingFor > currentIndexOfArray) 
      { 
       modeWeAreLookingFor = currentIndexOfArray; 
      } 
     } 

     else if (countIntegerInArray > frequencyOfMode) 
     { 
      modeWeAreLookingFor = currentIndexOfArray; 
      frequencyOfMode = countIntegerInArray;    
     } 

    } 
    return modeWeAreLookingFor; 
    } 

public int howMany(int[] testingArray, int c) 
{ 

    int howManyOfThisInt=0; 
    for(int i=0; i < testingArray.length;i++) 
    { 
     if(testingArray[i]==c){ 
      howManyOfThisInt++; 

     } 
    } 
    return howManyOfThisInt; 
} 


public static void main(String[] args) 
{ 
    new TheMode(); 
} 
}