Java 查找阵列中的最大频率数

通过使用以下命令，我能够找到数组中最常出现的整数。但下面的代码在少数情况下不起作用。如何修复for循环中的代码？我只想加强这种方法

class FindingMostFrequencyOccur {

    public static void main(String args[]) {
        int A[] = { 1, 2, 3, 3, 1, 3, 1};
        int M = 3; // Maximum Number in Array
        int result = findFrequency(M, A);
        System.out.println("Result "+result);
    }

    static int findFrequency(int M, int[] A) {
        int N = A.length;
        int[] count = new int[M + 1];
        for (int i = 0; i <= M; i++)
            count[i] = 0;
        int maxOccurence = 1;
        int index = -1;
        for (int i = 0; i < N; i++) {
            if (count[A[i]] > 0) {
                int tmp = count[A[i]];
                if (tmp > maxOccurence) {
                    maxOccurence = tmp;
                    index = i;
                }
                count[A[i]] = tmp + 1;
            } else {
                count[A[i]] = 1;
            }
        }
        return A[index];
    }
}

---

在这个逻辑中，您获取数组的每个元素，并找到它在数组中右侧重复的次数。这由本地频率给出。如果该值恰好大于

max\u frequency

，则

arr[i]

处的该数字存储在

number

中，然后

max\u frequency

存储

本地频率

public static void main(String[] args)
{
    int[] arr = {1, 2, 3, 4, 3, 2, 1, 5, 5, 5, 4, 4, 3, 4};
    int result = findMostFrequent(arr);
    System.out.println(result + " is the most frequent number");
}

public static int findMostFrequent(int[] arr)
{
    int number = arr[0];
    int maxFrequency = 0;

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

        if(local_frequency > maxFrequency)
        {
            number = arr[i];
            maxFrequency = local_frequency;
        }
    }

    return number;
}

publicstaticvoidmain（字符串[]args）
{
int[]arr={1,2,3,4,3,2,1,5,5,4,4,3,4}；
int结果=FindMostFrequency（arr）；
System.out.println（结果+“是最常见的数字”）；
}
公共静态int findmastfrequency（int[]arr）
{
整数=arr[0]；
int maxFrequency=0；
对于（int i=0；i最大频率）
{
编号=arr[i]；
maxFrequency=本地_频率；
}
}
返回号码；
}

在此逻辑中，取数组中的每个元素，并在数组中找到其右侧重复的次数。这由本地频率给出。如果该值恰好大于

max\u frequency

，则

arr[i]

处的该数字存储在

number

中，然后

max\u frequency

存储

本地频率

public static void main(String[] args)
{
    int[] arr = {1, 2, 3, 4, 3, 2, 1, 5, 5, 5, 4, 4, 3, 4};
    int result = findMostFrequent(arr);
    System.out.println(result + " is the most frequent number");
}

public static int findMostFrequent(int[] arr)
{
    int number = arr[0];
    int maxFrequency = 0;

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

        if(local_frequency > maxFrequency)
        {
            number = arr[i];
            maxFrequency = local_frequency;
        }
    }

    return number;
}

publicstaticvoidmain（字符串[]args）
{
int[]arr={1,2,3,4,3,2,1,5,5,4,4,3,4}；
int结果=FindMostFrequency（arr）；
System.out.println（结果+“是最常见的数字”）；
}
公共静态int findmastfrequency（int[]arr）
{
整数=arr[0]；
int maxFrequency=0；
对于（int i=0；i最大频率）
{
编号=arr[i]；
maxFrequency=本地_频率；
}
}
返回号码；
}

要获得

a

中

m

的频率，请使用：

static int findFrequency(int m, int[] a) {
     return (int)IntStream.of(a).filter(i-> i==m).count();
}

static Map<Integer, Integer> findFrequency(int[] a) {
     Map<Integer, Integer> m = new HashMap<>();
     IntStream.of(a).distinct().forEach(i->{
            m.put(i, findFrequency(i,a));
     });
     return m;
}

要获得

a

中所有频率的映射，请使用：

static int findFrequency(int m, int[] a) {
     return (int)IntStream.of(a).filter(i-> i==m).count();
}

static Map<Integer, Integer> findFrequency(int[] a) {
     Map<Integer, Integer> m = new HashMap<>();
     IntStream.of(a).distinct().forEach(i->{
            m.put(i, findFrequency(i,a));
     });
     return m;
}

静态映射查找频率（int[]a）{
Map m=新的HashMap（）；
IntStream.of（a）.distinct（）forEach（i->{
m、 put（i，findFrequency（i，a））；
});
返回m；
}

要获得

a

中

m

的频率，请使用：

static int findFrequency(int m, int[] a) {
     return (int)IntStream.of(a).filter(i-> i==m).count();
}

static Map<Integer, Integer> findFrequency(int[] a) {
     Map<Integer, Integer> m = new HashMap<>();
     IntStream.of(a).distinct().forEach(i->{
            m.put(i, findFrequency(i,a));
     });
     return m;
}

要获得

a

中所有频率的映射，请使用：

static int findFrequency(int m, int[] a) {
     return (int)IntStream.of(a).filter(i-> i==m).count();
}

static Map<Integer, Integer> findFrequency(int[] a) {
     Map<Integer, Integer> m = new HashMap<>();
     IntStream.of(a).distinct().forEach(i->{
            m.put(i, findFrequency(i,a));
     });
     return m;
}

静态映射查找频率（int[]a）{
Map m=新的HashMap（）；
IntStream.of（a）.distinct（）forEach（i->{
m、 put（i，findFrequency（i，a））；
});
返回m；
}

M应该是什么？M是数组中的最大数

解（M，A）

应该是

findFrequency（M，A）

M应该是什么？M是数组中的最大数

解（M，A）

应该是

findFrequency（M，A）