Question

我是Java的新手，并且作为一个周末项目被提出要解决的问题。我遇到了一些麻烦，希望得到你的帮助。请理解我是初学者。如果我在某处出错，请向我解释。我希望有一天能成为一名优秀的程序员。

我做了一个搜索，并找到了诸如＆＃34; heatmaps＆＃34;之类的答案。或者＆＃34; arraylists＆＃34;，我可能不会被允许使用的东西，因为我还没有学到它。

好的，给我的问题是：

查找：1）模式，类中最常出现的标记。如果同等频繁出现2个或更多标记，则这些标记中的最高标记为模式。

2）模式频率：模式频率。

假设班级有10名学生，标记介于0到100之间。您不能对标记进行排序。

这是我找到模式的代码：

void mode()
{
    int c[]=new int[10];
    int arr[]=new int[10];
    for (int i=0;i<10;i++)
    {   
        for (int j=i+1;j<10;j++)
        {
            for (int k=0;k<10;k++)
            {
                if (marks[i]!=arr[k])
                {               
                    if (marks[i]==marks[j])
                    {
                        c[i]++;
                        break;
                    }   
                }
            }
            arr[i]=marks[i];
        }
    }
    for (int k=0;k<10;k++)
    {
        System.out.println();
        System.out.println(c[k]);
    }
}

其中marks []是我接受输入的int数组，c []是计算数字发生的次数，而arr []是一个数组，用于交叉检查数字是否先前已经发生过。

假设输入的10个数字是99,95,97,92,80,95,73,80,95,80。正如您所见，95和80出现三次。

所以我的c []应该有{0,2,0,0,2,0,0,0,0,0}，但是当我运行它时，它来自{0,2,0,0， 2,1,0,1,0,0}，这意味着我的程序不与arr []进行交叉检查。

我认为我使用三个for循环弄得一团糟。我似乎无法弄清楚如何解决它。

Answer 1

一种解决方案是将长度为101的数组初始化为零。该数组表示特定标记发生的次数。每次遇到特定标记时，都会增加计数。然后找到模式，您可以简单地找到具有最高计数的索引。

Answer 2

public class Loader
{

    // We suppose that the parameter is not null
    public static void mode_frequency(long collection[])
    {
        long frequencies[] = new long[collection.length];
        for (int i = 0, l = collection.length; i < l; i++)
        {
            for (int j = i; j < l; j++)
            {
                if (collection[i] == collection[j])
                {
                    ++frequencies[i];
                }
            }
        }

        // With your example {99, 95, 97, 92, 80, 95, 73, 80, 95, 80}
        // You should have somthing like {1, 3, 1, 1, 3, 2, 1, 2, 1, 1}
        //
        // As you can see, you just have to find the MAX frequency and then, print corresponding values from initial array
        long frequency = 0;
        for (int i = 0, l = frequencies.length; i < l; i++)
        {
            if (frequency < frequencies[i])
            {
                frequency = frequencies[i];
            }
        }
        // Print each mode
        for (int i = 0, l = collection.length; i < l; i++)
        {
            if (frequencies[i] == frequency)
            {
                System.out.println(collection[i]);
            }
        }
    }

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args)
    {
        mode_frequency(new long[]
        {
            99,
            95,
            97,
            92,
            80,
            95,
            73,
            80,
            95,
            80
        });
    }

}

Answer 3

您可能希望使用一种算法，在该算法中使用辅助数组来累积单个标记的计数，然后在这些辅助数组中搜索具有最大值且具有最大值的标记。考虑：

package com.example.mode;

public class Mode {

    public static void main(String[] args) {

        int[] marks = { 99, 95, 97, 92, 80, 95, 73, 80, 95, 80};


        //One algorithm .. insert marks and add occurances, keeping in order

        int[] unique  = new int[marks.length];
        int[] count = new int[marks.length];
        int maxUnique = 0;

        for (int i=0; i < marks.length ; i++) {
            int loc = -1;
            for (int j=0; j < maxUnique; j++) {
                if (marks[i] == unique[j]) {
                    loc = j;
                    break;
                }
            }
            if (loc == -1) {
                loc = maxUnique;
                unique[loc] = marks[i];
                count[loc] = 0;
                maxUnique++;
            }
            count[loc] = count[loc]+1;
        }
        int maxValue = unique[0];
        int maxCount = count[0];
        for (int j=1; j < maxUnique; j++) {
            if (count[j] > maxCount || (count[j] == maxCount && maxValue < unique[j]) ) {
                maxValue = unique[j];
                maxCount = count[j];
            }
        }

        System.out.println("Mode = " + maxValue + ", frequency = " + maxCount);

    }

}

查找模式的模式和频率，无需在Java中进行排序

3 个答案: