Обнаружение режима или режима в массиве

Question

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

Я был в этом алгоритме весь день и ночь , Я просмотрел около 12 примеров кода 10x, но ни один из них, похоже, не подходит для решения моей проблемы.

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

Пример массива: -1, -1, 5, 6, 1, 1

Пример вывода: Этот массив имеет следующий режим (s): -1, 1

Проблема, с которой я сталкиваюсь, пытается понять, как хранить и отображать только самый высокий режим или несколько режимов, если они существуют.

Я использовал много подходов, и поэтому я вывешу мой самый последний подход:

void getMode(int *arr, int size) 
{ 
    int *count = new int[size]; // to hold the number of times a value appears in the array 

    // fill the count array with zeros 
    for (int i = 0; i < size; i++) 
     count[i] = 0; 

    // find the possible modes 
    for (int x = 0; x < size; x++) 
    { 
     for (int y = 0; y < size; y++) 
     { 
      // don't count the values that will always occur at the same element 
      if (x == y) 
       continue; 

      if (arr[x] == arr[y]) 
       count[x]++; 
     } 
    } 

    // find the the greatest count occurrences 
    int maxCount = getMaximum(count, size); 

    // store only unique values in the mode array 
    int *mode = new int[size]; // to store the mode(s) in the list 
    int modeCount = 0; // to count the number of modes 
    if (maxCount > 0) 
    { 
     for (int i = 0; i < size; i++) 
     { 
      if (count[i] == maxCount) 
      { 
       // call to function searchList 
       if (!searchList(mode, modeCount, arr[i])) 
       { 
        mode[modeCount] = arr[i]; 
        modeCount++; 
       } 
      } 
     } 
    } 

    // display the modes 
    if (modeCount == 0) 
     cout << "The list has no mode\n"; 
    else if (modeCount == 1) 
    { 
     cout << "The list has the following mode: " << mode[0] << endl; 
    } 
    else if (modeCount > 1) 
    { 
     cout << "The list has the following modes: "; 

     for (int i = 0; i < modeCount - 1; i++) 
     { 
      cout << mode[i] << ", "; 
     } 
     cout << mode[modeCount - 1] << endl; 
    } 

    // delete the dynamically allocated arrays 
    delete[]count; 
    delete[]mode; 
    count = NULL; 
    mode = NULL; 
} 

/* 
    definition of function searchList. 
    searchList accepts a pointer to an int array, its size, and a value to be searched for as its arguments. 
    if searchList finds the value to be searched for, searchList returns true. 
*/ 

bool searchList(int *arr, int size, int value) 
{ 
    for (int x = 0; x < size; x++) 
    { 
     if (arr[x] == value) 
     { 
      return true; 
     } 
    } 
    return false; 
} 

Answer 1

Лучше всего строить алгоритмы из более мелких строительных блоков. Стандартная библиотека <algorithm> - отличный источник таких компонентов. Даже если вы не используете это, программа должна быть аналогично структурирована с помощью подпрограмм.

Для домашней работы, по крайней мере, обоснование программы должно быть достаточно «очевидным», особенно с учетом некоторых замечаний.

Вот версия, использующая <algorithm> и std::unique_ptr вместо new, которую вы никогда не должны использовать. Если это помогает удовлетворить требования домашних заданий, вы можете реализовать свои собственные версии стандартных средств библиотеки.

// Input: array "in" of size "count" 
// Output: array "in" contains "count" modes of the input sequence 
void filter_modes(int * in, int & count) { 
    auto end = in + count; 
    std::sort(in, end); // Sorting groups duplicate values. 

    // Use an ordered pair data type, <frequency, value> 
    typedef std::pair< int, int > value_frequency; 
    // Reserve memory for the analysis. 
    auto * frequencies = std::make_unique<value_frequency[]>(count); 
    int frequency_count = 0; 

    // Loop once per group of equal values in the input. 
    for (auto group = in; group != end; ++ group) { 
     auto group_start = group; 

     // Skip to the last equal value in this subsequence. 
     group = std::adjacent_find(group, end, std::not_equal_to<>{}); 

     frequencies[ frequency_count ++ ] = { // Record this group in the list. 
      group - group_start + 1, // One unique value plus # skipped values. 
      * group // The value. 
     }; 
    } 

    // Sort <frequency, value> pairs in decreasing order (by frequency). 
    std::sort(frequencies.get(), frequencies.get() + frequency_count, 
       std::greater<>{}); 

    // Copy modes back to input array and set count appropriately. 
    for (count = 0; frequencies[ count ].first == frequencies[ 0 ].first; ++ count) { 
     in[ count ] = frequencies[ count ].second; 
    } 
} 

Answer 2

Не существует реального ответа из-за способа определения режима. Иногда вы видите, что в британской средней школе сдаются экзамены требование определить режим из небольшого распределения, которое явно amodal, но имеет один бит с избыточным количеством.

Вам необходимо вынуть данные, выбирая бункеры, чтобы данные имели определенные пики и впадины. Режимы - это вершины пиков. Однако небольшие вспомогательные пики на пути вверху не являются режимами, они являются признаком того, что ваш битнинг слишком узкий. Достаточно просто огласить режимы, немного сложнее разобраться в компьютерном алгоритме, который должен быть формальным. Один тест состоит в том, чтобы переместить бункеры на пол-корзины. Если режим исчезает, это скорее шум, чем реальный режим.