java编程&查找数组的模式答案

【问题标题】：java programming & finding the mode of an arrayjava编程&查找数组的模式
【发布时间】：2012-02-25 23:10:39
【问题描述】：

我有一个任务，我需要找到一个数组的模式。这意味着我正在寻找最常见的 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();
}
}

如您所见，我的算法返回最后找到的模式或我应该如何解释它。

【问题讨论】：

标签： java

【解决方案1】：

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

然后您可以检查每个映射条目的值以查看哪个具有最高计数。如果当前键的计数高于前一个键，那么它就是“当前”答案。但是您有可能获得具有相似计数的密钥，因此您需要存储每个“获胜”的答案。

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

【讨论】：

我之前尝试过使用 hashmap，但我发现它非常混乱。也因为它不像python那样方便获取键/值，所以我尝试只用一个数组保持这种方式。谢谢你的意见，但我想用这种方式解决它，但我希望有办法
正如另一个答案所建议的那样，您将需要某种方式来存储“这个数字有 n 个计数”的数据。您可以选择将其存储为数组数组（位置 0 是数字，位置 1 是计数），但这确实是 Map 的用途。无论你选择哪种结构，你仍然需要存储数据，这样你就可以判断数字 n 的当前计数是否是相同的计数，如果是，那么你当前的数字是否低于之前具有相同计数的数字。也许如果你在编码之前用伪代码描述算法，它可能会帮助你思考你的方法。
好的，可以说我做到了。使用 HashMap 和将所有新整数放入 HashMap 的循环，如果 HashMap.containsKey ，则 hashMAP 的第二个索引将增加。仍然当我想检查哪个有更多时，很难访问键值。那么我唯一可以访问的是带有.get（theInteger）的值。解决“我”的方式是不可能的吗？

【解决方案2】：

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

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

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

【讨论】：

已修复:) 是的，我知道它必须在那时做一些事情，因为那是我输出的那个。我只是发现在循环 howMany 时很难抽象地看到它。
你能帮我更多吗，秃头？

【解决方案3】：

这可能需要稍作修改。

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

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

【讨论】：

是的，我在老师的帮助下解决了这个问题。修改期间的帮助是在 for 循环中打印了所有变量，因此我们可以跟进。完整的代码将作为新的回复，感谢您的帮助，因为它可能会对我有所帮助。

【解决方案4】：

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

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

【讨论】：

【解决方案5】：

已完成：

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

【讨论】：

【解决方案6】：

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

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

【讨论】：