Question

编辑 采取不同的方法并找到解决方案，更新功能以正确查找模式

我一直都在使用这个算法，我已经查看了大约12个代码示例10倍，但似乎没有一个能够解决我的问题。

问题：查找数组中的模式，如果数组有多个模式，则全部显示。（这是一个家庭作业，所以我必须使用数组/指针）

示例数组： -1，-1,5,6,1,1

示例输出：该数组具有以下模式：-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的小分布中识别模式，但是有一个数量过多的bin。

您需要对数据进行分区，选择分档以使数据具有明确的峰值和低谷。然后模式是峰的尖端。然而，在通往顶部的路上很少有辅助峰值不是模式，它们表明您的分箱过于狭窄。它很容易让人眼前一亮，在计算机算法中更难以解决这个模式，这种算法必须是正式的。一个测试是将箱子移动半个箱子。如果一个模式消失，它就是噪音而不是真实模式。

查找数组

2 个答案: