寻找当地的最大

Question

我的节目的最大的4个值会产生以下输出在一段时间

，并在一段时间后

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

---

这里是我用来寻找最大峰值最大4个值的C++代码：

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

for(i=0;i<SPACE;i=i+1) 
{ 
    if(U_field_matrix[i][t1] > queue_matrix[0]) 
    { 
     queue_matrix[0] = U_field_matrix[i][t1]; 
    } 
} 

for(i=0;i<SPACE;i=i+1) 
{ 
    if((U_field_matrix[i][t1] > queue_matrix[1]) && (U_field_matrix[i][t1] < queue_matrix[0])) 
    { 
     queue_matrix[1] = U_field_matrix[i][t1]; 
    } 
} 

for(i=0;i<SPACE;i=i+1) 
{ 
    if((U_field_matrix[i][t1] > queue_matrix[2]) && (U_field_matrix[i][t1] < queue_matrix[1])) 
    { 
     queue_matrix[2] = U_field_matrix[i][t1]; 
    } 
} 

for(i=0;i<SPACE;i=i+1) 
{ 
    if((U_field_matrix[i][t1] > queue_matrix[3]) && (U_field_matrix[i][t1] < queue_matrix[2])) 
    { 
     queue_matrix[3] = U_field_matrix[i][t1]; 
    } 
} 

Answer 1

受@ 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]; 
    } 
} 

Answer 2

在你应该找到波峰寻找值x axis = i比x axis = i + 1值的每一个曲线图。你会得到两个冠，更大的价值是更大的冠。然后，将每个值与之前找到的一组值进行比较

Answer 3

我还在犹豫要发布此，因为你似乎有一个非常简单的用例，其解决方案涵盖了可能足够好，但真的有更好的方法来寻找前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); 
} 

正如你不必写counterx循环每次k个结果，而你的代码变得更具可读性。你困难的部分，可以提供为你的元素自定义比较功能，但有足够的职位上会这样：

Custom comparator for set