C 查找数组中最频繁的数字

我最近开始学习C语言，我遇到了这个小测试

制作一个从用户处读取10个数字的代码

打印输入的最大值和最小值，然后打印最频繁的数字

对我来说，一切都很简单，但最常见的数字让我发疯，我搜索了一段时间，却找不到任何明确的答案

我写的代码

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int hi[10], i=0, largest, smallest;
    while(i<10)
    {
        printf("Enter a number:");
        scanf("%d", &hi[i]);
        i++;
    }
    smallest = hi[0];
    largest = hi[0];
    printf("Entered Numbers: ");
    while(i!=0)
    {
        if(hi[10-i] < smallest) { smallest = hi[10-i]; }
        if(hi[10-i] > largest) { largest = hi[10-i]; }
        printf("%d | ", hi[10-i]);
        i--;
    }

    printf("\nLargest number is = %d || Smallest number is = %d", largest, smallest);
    return 0;
}

#包括
#包括
int main（）
{
int-hi[10]，i=0，最大，最小；
而（i最大）{max=hi[10-i]；}
printf（“%d |”，hi[10-i]）；
我--；
}
printf（“\n最大的数字是=%d | |最小的数字是=%d”，最大的，最小的）；
返回0；
}

我唯一想到的是：

• 制作另一个数组

• 获取原始数组中[i]的值

• 将[i]与原始数组的其余值进行比较（如果它们相等或不相等）

• 如果其他数组的值相等，则增加它们的值

• 检查另一个数组中的最大值，该值应该是最频繁的数字

• 现在，我知道了最频繁元素的顺序以及该元素被输入的次数

---

使用hashmap会更有效。在那里，您可以使用输入数字作为键，并将值设置为1。当用户给出新号码时，您只需检查地图中是否已经有新号码。如果是这样，您可以将该值设置为2，否则您将使用值1添加新的数字。
使用hashmap将更有效。在那里，您可以使用输入数字作为键，并将值设置为1。当用户给出新号码时，您只需检查地图中是否已经有新号码。如果是这样，则将值设置为2，否则将新数字与值1相加。
根据Markus的说法，哈希映射确实是通用解决方案的理想选择，因此可以降低渐近时间，但由于您仅使用10的数组，因此使用2D数组来存储频率就可以了

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int hi[10][2], i=0,j=0,largest, smallest;

    while(i<10)
    {
        printf("Enter a number:");
        scanf("%d", &hi[i][0]);
        i++;
    }
    smallest = hi[0][0];
    largest = hi[0][0];
    printf("Entered Numbers: ");
    while(i!=0)
    {
        hi[10-i][1] = 0;
        if(hi[10-i][0] < smallest) { smallest = hi[10-i][0]; }
        if(hi[10-i][0] > largest) { largest = hi[10-i][0]; }
        printf("%d | ", hi[10-i][0]);
        i--;
    }
    int most_freq = 0;
    for (i = 0; i < 10; i++){
        for (j = 0; j < 10; j++){
            if(hi[i][0] == hi[j][0]){
                hi[i][1]++;
                if (hi[i][1] > most_freq){
                    most_freq = hi[i][0];
                }
            }
        }
    }

    printf("\nLargest number is = %d || Smallest number is = %d", largest, smallest);
    printf("\nMost frequent is = %d\n", most_freq);
    return 0;
}

#包括
#包括
int main（）
{
int-hi[10][2]，i=0，j=0，最大，最小；
而（i最大）{max=hi[10-i][0]；}
printf（“%d |”，hi[10-i][0]）；
我--；
}
int most_freq=0；
对于（i=0；i<10；i++）{
对于（j=0；j<10；j++）{
if（hi[i][0]==hi[j][0]）{
嗨[i][1]++；
如果（hi[i][1]>最频繁）{
most_freq=hi[i][0]；
}
}
}
}
printf（“\n最大的数字是=%d | |最小的数字是=%d”，最大的，最小的）；
printf（“\n最频繁为=%d\n”，最频繁）；
返回0；
}

根据马库斯的说法，散列图确实是通用解决方案的理想选择，因此可以降低渐近时间，但由于您只需要使用10的数组，因此使用2D数组存储频率就可以了

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int hi[10][2], i=0,j=0,largest, smallest;

    while(i<10)
    {
        printf("Enter a number:");
        scanf("%d", &hi[i][0]);
        i++;
    }
    smallest = hi[0][0];
    largest = hi[0][0];
    printf("Entered Numbers: ");
    while(i!=0)
    {
        hi[10-i][1] = 0;
        if(hi[10-i][0] < smallest) { smallest = hi[10-i][0]; }
        if(hi[10-i][0] > largest) { largest = hi[10-i][0]; }
        printf("%d | ", hi[10-i][0]);
        i--;
    }
    int most_freq = 0;
    for (i = 0; i < 10; i++){
        for (j = 0; j < 10; j++){
            if(hi[i][0] == hi[j][0]){
                hi[i][1]++;
                if (hi[i][1] > most_freq){
                    most_freq = hi[i][0];
                }
            }
        }
    }

    printf("\nLargest number is = %d || Smallest number is = %d", largest, smallest);
    printf("\nMost frequent is = %d\n", most_freq);
    return 0;
}

#包括
#包括
int main（）
{
int-hi[10][2]，i=0，j=0，最大，最小；
而（i最大）{max=hi[10-i][0]；}
printf（“%d |”，hi[10-i][0]）；
我--；
}
int most_freq=0；
对于（i=0；i<10；i++）{
对于（j=0；j<10；j++）{
if（hi[i][0]==hi[j][0]）{
嗨[i][1]++；
如果（hi[i][1]>最频繁）{
most_freq=hi[i][0]；
}
}
}
}
printf（“\n最大的数字是=%d | |最小的数字是=%d”，最大的，最小的）；
printf（“\n最频繁为=%d\n”，最频繁）；
返回0；
}

@Vittorio Romeo:是的，这似乎是OP已经找到的解决方案。这对我来说似乎很合理。看看这里提供的解决方案：并根据您的需要对其进行编辑。对数组进行排序。然后在for循环中从hi[0]…h[9]枚举数组中的项。然后使用额外的变量来跟踪重复计数。@sudo_coffee这正是我需要的！对它做了一点修改，效果很好。doynax，ayy所以我想我的主意没那么糟。维托里奥·罗密欧：嗯，是的，这似乎是OP已经找到的解决方案。这对我来说似乎很合理。看看这里提供的解决方案：并根据您的需要对其进行编辑。对数组进行排序。然后在for循环中从hi[0]…h[9]枚举数组中的项。然后使用额外的变量来跟踪重复计数。@sudo_coffee这正是我需要的！对它做了一点修改，效果很好。doynax，ayy所以我想我的主意没那么糟。我基本上害怕把事情搞砸。在我看来，这样的方案会增加相当多的复杂性，对10个要素的好处有限。不过，对于更大的问题集来说，这是非常明智的。是的，这是完全正确的。但我认为这不是一个“现实世界的问题”。只是为了学习编程。这里有一个hashmap提示，有助于了解有关此数据结构的信息；）hashmap是我以前从未听说或见过的东西。学习新东西对我来说也很重要，我会继续学习的。谢谢在我看来，这样一个方案将增加相当多的复杂性和10个要素的有限收益。不过，对于更大的问题集来说，这是非常明智的。是的，这是完全正确的。但我认为这不是一个“现实世界的问题”。只是为了学习编程。这里有一个hashmap提示，有助于了解有关此数据结构的信息；）hashmap是我以前从未听说或见过的东西。学习新东西对我来说也很重要，我会继续学习的。谢谢请不要发布代码的图像。以格式化文本的形式发布代码。很抱歉，以后也可以。这里不需要二维数组。使用两个数组会更清晰-因此使用

hi[i]

和

count[i]

而不是

hi[i][0]

和

hi[i][1]

。请不要发布代码图像