Question

我有一个任务，我需要找到一个数组的模式。这意味着我正在寻找最常见的int。我有点完成了，但任务还说如果有两种模式是相同的，我应该返回最小的int，例如{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

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

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

完成

Java代码约定规定方法名称和变量名称应以小写字符开头。如果你遵循这个约定，你会有更好的语法着色和代码更容易阅读。

Answer 2

我会采用不同的方法。使用地图，您可以使用每个唯一编号作为键，然后将计数作为值。逐步执行数组并找到每个数字，检查地图以查看是否存在具有该值的键。如果找到一个，则将其值增加1，否则创建一个值为1的新条目。

然后，您可以检查每个地图条目的值，以查看哪个具有最高计数。如果当前密钥的计数高于前一个密钥，则它是“当前”答案。但是你可能会有类似计数的键，所以你需要存储每个'winnning'答案。

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

Answer 3

因为似乎没有别的办法，毕竟我做了一个哈希图。在比较频率时，我再次陷入逻辑中，并且如果频率相等，则选择最低整数。

        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 4

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

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 5

这可能会稍作修改。

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

java编程＆amp;找到一个数组的模式

6 个答案: