Question

我有这个数组我写了一个函数MostFreq，它接受一个整数数组并返回2个值：数组中更频繁的数字及其频率检查这段代码我觉得你觉得怎么样？有更好的方法吗？

static void Main()
{ 
    int [] M={4,5,6,4,4,3,5,3};
    int x;
    int f=MyMath.MostFreq(M,out x );
    console.WriteLine("the most Frequent Item = {0} with frequency = {1}",x,f);
}

=====

在Mymath课程中

public static int MostFreq(int[] _M, out int x)
{
    //First I need to sort the array in ascending order
    int Max_Freq, No_Freq, i, k;
    Array.Sort(_M);                         
    k = _M[0];
    Max_Freq = 0; i = 0; x = 0;
    while (i < _M.Length)
    {
        //No_Freq= the frequency of the current number
        No_Freq = 0;
        //X here is the number which is appear in the array Frequently 
        while (k == _M[i])
        {
            No_Freq++;
            i++;
            if (i == _M.Length) 
                break;
        }
        if (No_Freq > Max_Freq)
        {
            //so it will be printed the same
            Max_Freq = No_Freq;
            x = k;
        }
        if (i < _M.Length) k = _M[i];
    }
    return (Max_Freq);
}

Answer 1

LINQ它。我知道这是在VB中，但您应该能够将其转换为C＃：

Dim i = From Numbers In ints _
            Group Numbers By Numbers Into Group _
            Aggregate feq In Group Into Count() _
            Select New With {.Number = Numbers, .Count = Count}

编辑：现在也在C＃中：

var i = from numbers in M
                group numbers by numbers into grouped
                select new { Number = grouped.Key, Freq = grouped.Count()};

Answer 2

假设你不能使用LINQ，我可能会像这样接近算法：

创建键/值词典
迭代你的数组，为每个唯一元素添加一个字典，每次重复元素时增加值。
走字典键，返回最高值的元素。

这不是一个很好的解决方案，但它很简单，ContainsKey是一个O（1）查找，所以你最多只能迭代你的数组两次。

Answer 3

从软件工程的角度来看，我希望一个名为MostFreq的函数能够返回频率最高的元素 - 而不是频率本身。我会把你换掉并返回值。

Answer 4

您可以通过迭代整个数组一次来消除您在开始时所做的排序，保持计算临时数组中每个值的次数，然后迭代临时数组以获得最大数字。你也可以保持最高频率和最频繁的项目。

当然，不同类型的数据对不同类型的数据有不同的效率，但这只是两次迭代的最坏情况。

编辑：为重复道歉...'当我开始时，我不知道。）

Answer 5

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MostFrequentElement
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] array = new int[] { 4, 1, 1, 4, 2, 3, 4, 4, 1, 2, 4, 9, 3, 1, 1, 7, 7, 7, 7, 7 };
            Array.Sort(array, (a, b) => a.CompareTo(b));
            int counter = 1;
            int temp=0 ;

            List<int> LOCE = new List<int>();
            foreach (int i in array)
            {
                counter = 1;
                foreach (int j in array)

{
                    if (array[j] == array[i])
                    {
                        counter++;
                    }
                    else {
                    counter=1;
                    }
                    if (counter == temp)
                    {
                        LOCE.Add(array[i]);
                    }
                    if (counter > temp)
                    {
                        LOCE.Clear();
                        LOCE.Add(array[i]);
                        temp = counter;

                    }
                }

            }
            foreach (var element in LOCE)
            {
                Console.Write(element + ",");
            }
            Console.WriteLine();
            Console.WriteLine("(" + temp + " times)");
            Console.Read();
        }
    }
}

Answer 6

以下是一个如何在没有LINQ且没有字典和列表的情况下执行此操作的示例，只有两个简单的嵌套循环：

public class MostFrequentNumber
{
    public static void Main()
    {
        int[] numbers = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();

        int counter = 0;
        int longestOccurance = 0;
        int mostFrequentNumber = 0;

        for (int i = 0; i < numbers.Length; i++)
        {
            counter = 0;

            for (int j = 0; j < numbers.Length; j++)
            {
                if (numbers[j] == numbers[i])
                {
                    counter++;
                }
            }

            if (counter > longestOccurance)
            {
                longestOccurance = counter;
                mostFrequentNumber = numbers[i];
            }
        }

        Console.WriteLine(mostFrequentNumber);
        //Console.WriteLine($"occured {longestOccurance} times");
    }
}

您获得最常出现的数字的值，并且（注释）您还可以获得出现次数。我知道我有一个＆＃34;使用Linq;＆＃34;，它只是将初始输入字符串转换为int数组并且节省了几行和一个解析循环。即使没有它，算法也很好，如果你填充数组＆＃34; long＆＃34;方式...

Answer 7

完成1次传递......

public class PopularNumber
    {
        private Int32[] numbers = {5, 4, 3, 32, 6, 6, 3, 3, 2, 2, 31, 1, 32, 4, 3, 4, 5, 6};

        public PopularNumber()
        {
            Dictionary<Int32,Int32> bucket = new Dictionary<Int32,Int32>();
            Int32 maxInt = Int32.MinValue;
            Int32 maxCount = 0;
            Int32 count;

            foreach (var i in numbers)
            {
                if (bucket.TryGetValue(i, out count))
                {
                    count++;
                    bucket[i] = count;
                }
                else
                {
                    count = 1;
                    bucket.Add(i,count);
                }

                if (count >= maxCount)
                {
                    maxInt = i;
                    maxCount = count;
                }

            }

            Console.WriteLine("{0},{1}",maxCount, maxInt);

        }
    }

Answer 8

让我们假设数组如下：

int arr[] = {10, 20, 10, 20, 30, 20, 20,40,40,50,15,15,15};

int max = 0;
int result = 0;
Map<Integer,Integer> map = new HashMap<>();

for (int i = 0; i < arr.length; i++) {
    if (map.containsKey(arr[i])) 
        map.put(arr[i], map.get(arr[i]) + 1);
    else
        map.put(arr[i], 1);
    int key = map.keySet().iterator().next();
    if (map.get(key) > max) {
        max = map.get(key) ;
        result = key;
    }
}
System.out.println(result);

说明：

在上面的代码中，我采用了HashMap来将元素存储在键中，并将元素的重复作为值。我们已经初始化了变量max = 0（max是重复元素的最大计数），同时遍历元素时，我们还获得了键的最大计数。

result变量返回大多数重复的键。

Answer 9

int[] arr = { 4, 5, 6, 4, 4, 3, 5, 3 };
var gr = arr.GroupBy(x => x).OrderBy(x => x.Count()).Last();
Console.WriteLine($"The most Frequent Item = {gr.Key} with frequency = {gr.Count()}"); // The most Frequent Item = 4 with frequency = 3

Answer 10

int count = 1;
int currentIndex = 0;
for (int i = 1; i < A.Length; i++)
{
    if (A[i] == A[currentIndex])
        count++;
    else
        count--;
    if (count == 0)
    {
        currentIndex = i;
        count = 1;
    }
}

int mostFreq = A[currentIndex];

数组中最常见的数字

10 个答案: