Question

我的程序在某个时间生成以下输出

以后的某个时间

我想确定BOTH波峰最大的4个值。我设法找到了最大波峰的最大4个值（参见下面的代码），这相对简单，因为我基本上需要找到绝对最大值。但我不知道如何找到较小波峰的最大4值，我想知道是否有人可以帮我这个？

以下是我用来查找最大波峰的最大4个值的C ++代码：

@Responsebody

Answer 1

我对发布这个问题犹豫不决，因为你似乎有一个非常简单的用例，你的解决方案可能已经足够好了，但是有很好的方法来寻找top-k值。一般来说，你可能会帮自己一个忙，如果你把它分成一个寻找最大值的函数（根据eOk所说的，如果这适用于你），一个寻找top-k的函数和一个运行的程序您的数据并在找到最大值时调用周围值的top-k函数。

我现在没有像现在这样的解决方案，如果不知道变量的类型，就不可能为你编写一个，但top-k通常对我来说就是这样的：

#include <algorithm>
#include <vector>
template <class in_iterator, class out_iterator,                                
        class value_type = typename std::iterator_traits<in_iterator>::value_type,
        class compare = std::greater<value_type>>                               
void findTopK(in_iterator start, in_iterator end, out_iterator out,             
        size_t k)                                                               
{                                                                               
    std::vector<value_type> heap;                                               
    heap.reserve(k + 1);                                                        
    for (;start != end; ++start)                                                
    {                                                                           
        heap.push_back(*start); //min-oriented heap, order implied by compare   
        std::push_heap(std::begin(heap), std::end(heap), compare());            
        if (heap.size() > k)                                                    
        {                                                                       
            std::pop_heap(std::begin(heap), std::end(heap), compare());         
            heap.pop_back();                                                    
        }                                                                       
    }                                                                           
    while (!heap.empty())                                                       
    {                                                                           
        std::pop_heap(std::begin(heap), std::end(heap), compare());             
        *out++ = heap.back();                                                   
        heap.pop_back();                                                        
    }                                                                           
}

此方法使用堆来跟踪k个最大元素。在常规数组上调用它可以在任何容器上运行，看起来像这样：

int main()                                                                      
{                                                                               
    int array[] = {1,3,4,5,6,2,62,3,32};                                        
    std::vector<int> results;                                                   
    findTopK(std::begin(array), std::end(array), back_inserter(results), 5);
}

因此，您不必每次都编写k个counterx循环，并且您的代码变得更具可读性。对你来说困难的部分可能是为你的元素提供自定义比较功能，但是有足够的帖子就这样：

Custom comparator for set

Answer 2

在每个图表中，您都应该找到徽章，以查找x axis = i的值大于x axis = i + 1的值。你会得到两个波峰，更大的值是更大的波峰。然后，将每个值与先前找到的值集合进行比较

Answer 3

受到@ e0k评论的启发（谢谢！），以下代码将确定两个徽章的最大4个值。

for(i=0;i<SPACE;i=i+1)
{
    if((U_field_matrix[i][t1] > 0.1) && (U_field_matrix[i+1][t1]-U_field_matrix[i][t1] < 0.0))
    {
        counter1 = i;
        break;
    }
}

for(i=0;i<4;i=i+1)
{
    queue_matrix1[i] = 0.0;
}

for(i=(counter1-3);i<(counter1+4);i=i+1)
{
    if(U_field_matrix[i][t1] > queue_matrix1[0])
    {
        queue_matrix1[0] = U_field_matrix[i][t1];
    }
}

for(i=(counter1-3);i<(counter1+4);i=i+1)
{
    if((U_field_matrix[i][t1] > queue_matrix1[1]) && (U_field_matrix[i][t1] < queue_matrix1[0]))
    {
        queue_matrix1[1] = U_field_matrix[i][t1];
    }
}

for(i=(counter1-3);i<(counter1+4);i=i+1)
{
    if((U_field_matrix[i][t1] > queue_matrix1[2]) && (U_field_matrix[i][t1] < queue_matrix1[1]))
    {
        queue_matrix1[2] = U_field_matrix[i][t1];
    }
}

for(i=(counter1-3);i<(counter1+4);i=i+1)
{
    if((U_field_matrix[i][t1] > queue_matrix1[3]) && (U_field_matrix[i][t1] < queue_matrix1[2]))
    {
        queue_matrix1[3] = U_field_matrix[i][t1];
    }
}

for(i=SPACE;i>-1;i=i-1)
{
    if((U_field_matrix[i][t1] > 0.1) && (U_field_matrix[i-1][t1]-U_field_matrix[i][t1] < 0.0))
    {
        counter2 = i;
        break;
    }
}

for(i=0;i<4;i=i+1)
{
    queue_matrix2[i] = 0.0;
}

for(i=(counter2-3);i<(counter2+4);i=i+1)
{
    if(U_field_matrix[i][t1] > queue_matrix2[0])
    {
        queue_matrix2[0] = U_field_matrix[i][t1];
    }
}

for(i=(counter2-3);i<(counter2+4);i=i+1)
{
    if((U_field_matrix[i][t1] > queue_matrix2[1]) && (U_field_matrix[i][t1] < queue_matrix2[0]))
    {
        queue_matrix2[1] = U_field_matrix[i][t1];
    }
}

for(i=(counter2-3);i<(counter2+4);i=i+1)
{
    if((U_field_matrix[i][t1] > queue_matrix2[2]) && (U_field_matrix[i][t1] < queue_matrix2[1]))
    {
        queue_matrix2[2] = U_field_matrix[i][t1];
    }
}

for(i=(counter2-3);i<(counter2+4);i=i+1)
{
    if((U_field_matrix[i][t1] > queue_matrix2[3]) && (U_field_matrix[i][t1] < queue_matrix2[2]))
    {
        queue_matrix2[3] = U_field_matrix[i][t1];
    }
}

找到局部最大值的最大4个值

3 个答案: