Поиск максимальной частоты элемента в массиве (иногда это работает)

Question

Привет, У меня возникла небольшая проблема с моим кодом ниже. Иногда максимальная частота возвращается правильно, но иногда это не так. Когда возникает ошибка, он всегда возвращает 1. Кажется, я не могу найти ошибку. Я попытался написать первый цикл nrofpeople-1, но это не имеет значения.

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

#define MAX 10000 

int main(int argc, const char *argv[]) { 
    int nrofpeople; 
    int array[MAX]; 
    int num = 0; 
    int index; 

    srand((unsigned int)time(NULL)); 

    printf("How many people?"); 
    scanf("%d", &nrofpeople); 

    for (int i = 0; i < nrofpeople; i++) { 
     array[i] = rand() % 3 + 1; // generate random number to test 
    } 

    int maxcount = 0; 
    for (int i = 0; i < nrofpeople; i++) { 
     index = 1; 

     for (int j = 1; j < nrofpeople; j++) { 
      if (array[i] == array[j]) { 
       index++; 
      } 
     } 
     if (index > maxcount) { 
      maxcount = index; 
      num = array[i]; 
     } 
    } 

    printf("Number: %d Occurred: %d times\n", num, maxcount); 
    return 0; 
} 

Answer 1

Есть некоторые проблемы в вашем коде:

• Вы не проверяете достоверность количества людей вошли, что приводит к непредсказуемому поведению для недопустимого ввода.

• Вы используете алгоритм поиска самой высокой частоты: вы считаете array[i] дважды за i > 0. Фактически вы можете сделать внутренний цикл проверки меньшим количеством записей, только первое вхождение данного номера, создающее максимальное количество.

Вот улучшенная версия:

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

#define MAX 10000 

int main(int argc, const char *argv[]) { 
    int nrofpeople; 
    int array[MAX]; 

    printf("How many people?"); 
    if (scanf("%d", &nrofpeople) != 1 || nrofpeople <= 0 || nrofpeople > MAX) { 
     printf("invalid number of people\n"); 
     return 1; 
    } 

    srand((unsigned int)time(NULL)); 
    for (int i = 0; i < nrofpeople; i++) { 
     array[i] = rand() % 3 + 1; // generate random number to test 
    } 

    int num = 0, maxcount = 0; 
    for (int i = 0; i < nrofpeople; i++) { 
     int count = 1; 
     for (int j = i + 1; j < nrofpeople; j++) { 
      if (array[i] == array[j]) { 
       count++; 
      } 
     } 
     if (count > maxcount) { 
      maxcount = count; 
      num = array[i]; 
     } 
    } 
    printf("Number: %d Occurred: %d times\n", num, maxcount); 
    return 0; 
} 

Answer 2

(иногда работает)

Я на самом деле удивлен, что он когда-либо работает. В любом случае, если вы хотите, чтобы найти самый большой элемент в вашем входном массиве, вы можете сделать это, сделав один проход:

int maxcount = 0; 

for (int i=0; i < nrofpeople; i++) 
{ 
    if (array[i] > maxcount) 
    { 
     maxcount = array[i]; 
    } 
} 

Вы используете двойную петлю на массив, который бы целесообразно, если вам нужно было выполнить сопоставление типов файлов с перекрестными элементами. Но это, похоже, не согласуется с вашим заявлением о проблеме.

Answer 3

Если вы намереваетесь найти частоту каждого номера в заданном массиве, вы можете создать другой массив, содержащий все элементы, которые содержит исходный массив минус повторяющиеся числа. Затем вы можете установить массив count для подсчета частоты всех чисел в исходном массиве.

int flag = 0, a[nrpeople], k = 0; 
    for(int i = 0; i < nrpeople; i++){ 
    flag = 0; 
    for(int j = i+1; j<nrpeople; j++){ 
     if(array[i] == array[j]){ 
      flag = 1; 
      break; 
     } 
    } 
    if(flag == 0){ 
     a[k] = array[i]; 
     k++; 
    } 
    } 
    int count[k] = {0}; 
    for(int i=0; i<k; i++){ 
    for(int j = 0; j<nrpeople; j++){ 
     if(a[i] == array[j]) 
     count[i]++; 
    } 
    } 

И затем сделайте все, что хотите, с помощью массива count.

Answer 4

В заявлении проблемы, которую вы хотите решить, есть некоторые неочищенные области. Я думаю, было бы лучше, если бы вы предоставили нам несколько примеров (ввод + ожидаемый результат).

В любом случае, я прочитал ваш последний комментарий и кажется, что вы хотите найти наиболее распространенный (часто используемый) элемент внутри данного массива. Вот какой способ добиться этого. В коде есть комментарии: внимательно прочитайте их.

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

#define MAX 10 

// gcc main.c -o main -std=c99 
// ./main 

int main(int argc, const char * argv[]) 
{ 
    srand((unsigned int)time(NULL)); 

    int array[MAX]; 
    for(int i=0; i<MAX; i++) { 
     array[i] = -1; // to make sure there are no uninitialized fields 
    } 

    int npeople = -1; 
    do { 
     printf("How many people (1 to %d)? ", MAX); 
     scanf("%d", &npeople); 
    } 
    while(npeople<1 || npeople>MAX); 

    // Filling array with integer values in range [min, max] 

    const unsigned int min=5; 
    const unsigned int max=15; 
    for(int i=0; i<npeople; i++) { 
     array[i] = min + rand() % (max-min+1); 
    } 

    // Now searching for the most frequent element 

    const int f = max+1; 
    int freq[f]; 
    /* frequency array 
    * freq[i] = k means value i appears k times in array 
    * And to make things easier, we use up to max+1 fields for the frequency array. 
    * But normally, only max-min+1 fields are needed. 
    * However in that case, additional conversions (between array and freq) 
    * become mandatory. 
    */ 

    // initialization 
    for(int i=0; i<f; i++) { 
     freq[i] = 0; 
    } 

    // filling frequency array 
    for(int i=0; i<MAX; i++) { 
     freq[array[i]]++; 
    } 

    // Display 

    printf("\n"); 
    printf("Input array\n"); 
    printf("===========\n"); 
    for(int i=0; i<MAX; i++) { 
     printf("%d", array[i]); 
     i==MAX-1 ? printf("\n") : printf(" "); 
    } 

    printf("\n"); 
    printf("Frequency array\n"); 
    printf("===============\n"); 
    for(int i=0; i<f; i++) { 
     printf("%0d", freq[i]); 
     i==f-1 ? printf("\n") : printf(" "); 
    } 

    printf("\n"); 
    printf("Note\n"); 
    printf("====\n"); 
    printf("freq[i] = k MEANS value i appears k times in array\n"); 

    int mse = -1; // most frequent element 
    int h = -1; // highest occurrence 
    for(int i=0; i<f; i++) { 
     if(freq[i] > h) { 
      h = freq[i]; 
      mse = i; 
     } 
    } 
    printf("\n"); 
    printf("Conclusion\n"); 
    printf("==========\n"); 
    printf("The most frequent element is %d, appearing %d time(s).\n", mse, h); 

    return 0; 
} 

Этот алгоритм работает, поскольку мы знаем минимальное и максимальное значения в массиве. Если мы этого не сделаем, мы можем сначала отсортировать массив, используя qsort, и тогда мы сможем найти экстремумы массива (экстремальные значения).

Надеюсь, это поможет.