使用简单的 for 循环查找模式（数组中最常见的值）？

Question

如何使用简单的 for 循环找到众数（数组中最常见的值）？

该代码编译后输出错误。

这是我所拥有的：

public static void mode(double [] arr)
{
    double mode=arr[0];

    for(int i = 1; i<arr.length; i++)
    {   
        if(mode==arr[i])
        {
            mode++;
        }

     }


    return mode;
}

Answer 1

首先，我按顺序对数组进行排序，然后计算一个数字的出现次数。仅适用于循环和 if 语句，没有哈希图。

我的代码：

static int Mode(int[] n){
    int t = 0;
    for(int i=0; i<n.length; i++){
        for(int j=1; j<n.length-i; j++){
            if(n[j-1] > n[j]){
                t = n[j-1];
                n[j-1] = n[j];
                n[j] = t;
            }
        }
    }

    int mode = n[0];
    int temp = 1;
    int temp2 = 1;
    for(int i=1;i<n.length;i++){
        if(n[i-1] == n[i]){
            temp++;
        }
        else {
            temp = 1;
        }
        if(temp >= temp2){
            mode = n[i];
            temp2 = temp;
        }
    }
    return mode;
}

Answer 2

- 只需使用一个 HashMap，其中包含数组索引值作为键，其出现次数作为值。

- 在遍历 for 循环时通过检查当前索引是否已存在于 HashMap 中来更新 HashMap。如果确实如此，则在哈希映射中找到该双精度，并查看它已经发生了多少次，然后将其放回哈希映射中，并再出现一次。

-我是用Java做的，因为这就是你正在使用的。同样好的一点是，时间复杂度为 O(n)，这是这种情况下您可能获得的最佳时间复杂度，因为您必须至少访问每个元素一次。

-所以如果你有一个像这样的双精度数组： { 1,2,3,1,1,1,5,5,5,7,7,7,7,7,7,7,7,7}
那么哈希映射最后看起来像这样： { 1->4, 2->1, 3->1, 5->3, 7->9 }
意思是“1出现4次，2出现1次......7出现9次”等等。

    public static double mode(double [] arr)
    {
        HashMap arrayVals = new HashMap();
        int maxOccurences = 1;
        double mode = arr[0];

        for(int i = 0; i<arr.length; i++)
        {   
            double currentIndexVal = arr[i];
            if(arrayVals.containsKey(currentIndexVal)){
                int currentOccurencesNum = (Integer) arrayVals.get(currentIndexVal);
                currentOccurencesNum++;
                arrayVals.put(currentIndexVal, currentOccurencesNum );
                if(currentOccurencesNum >= maxOccurences)
                {
                    mode = currentIndexVal;
                    maxOccurences = currentOccurencesNum;
                }
            }
            else{
                arrayVals.put(arr[i], 1);
            }
        }


        return mode;
    }

Answer 3

此代码是不使用哈希图的不同方式。该方法是在 java 中创建的，采用一个数组作为参数，并在方法内创建另一个名为“numberCount”的数组。该数组“numberCount”将其索引设置为数组中的值。包含传递数组中的值的“numberCount”索引会将“numberCount”的值加 1（“++numberCount[array[i]]”），然后转到数组中的下一个值（重复直到数组的末尾）。然后创建另一个 for 循环来遍历“numberCount”中数组的每个值，具有最高值/计数的索引将被存储并作为“max”返回。此方法必须经过一些困难的更改才能使用双数组。但似乎与 int 数组配合得很好。

public static int findMostFrequentValue(int[] array) {
    int i;
    int[] numberCount = new int[100];
    for (i = 0; i < array.length; i++)++numberCount[array[i]];
    int max = 0;
    int j;

    for (j = 0; j < numberCount.length; j++) {
        if (numberCount[j] > max) max = j;
    }
    return max;
}

Answer 4

您应该检查数组中每个元素出现的次数。您可以通过 2 个内部 for 循环将数组的每个元素与自己和其他元素进行比较来做到这一点。

请记住，如果数组未排序并且包含超过 1 个模态值（因此重复出现的次数），则这将返回第一个模态值。首先通过Arrays.sort(array)对数组进行排序可能是明智的，这样您就可以选择最小或最大的模态值。

public static int modeOfArray(int[] array){
    int mode;     
    int maxOccurance = 0;

    for(int i=0; i<array.length; i++){
        int occuranceOfThisValue = 0;
        for(int j=0; j<array.length; j++){
            if(array[i] == array[j])
               occuranceOfThisValue++;
        }

        if(occuranceOfThisValue > maxOccurance){
            maxOccurance = occuranceOfThisValue;
            mode = array[i];
        }
    }
    return mode;
}