C++ 数组（向量）中大于某个值的元素的起始索引和结束索引

给定这样的数组：

{1, 3, 11, 2, 24, 13, 5....}

数组长度可能大于1000

如果元件的值不合适，例如大于10，则应使用合适的值替换。在这种情况下，通过线性插值计算适当的值

例如：

Arr={1,3,11,2,24,13,5..}

新阵列应为：

NewArr={1,3,3+（2-3）/2,2,2+（5-2）/3,2+2*（5-2）/3,5，…}

为了做到这一点，我必须知道不适当元素的开始和结束索引

起止索引应为（2,2）表示“11”和（4,5）表示“24,13”

我已经尝试了

for循环

。但这是没有效率的。 然后我搜索了

IPPAPI

，没有得到结果：(

有更好的办法吗

谢谢你的帮助，：）

顺便说一句：

IPP API

将是一个更好的选择

更新：

示例代码：

int arr[] = {1, 3, 11, 2, 24, 13, 5....};

/// find the starting index and ending index of inappropriate values
/// (2,2) (4,5).
int i = 0; 
std::map<int,int> Segments;
if(arr[i] > Threshold)
{
    int b = i;
    while(arr[i] > Threshold )
        i ++;
    int e = i;
    Segments.insert(std::map<int,int>::value_type(b,e));
}

/// linear interpolation
for(std::map<int,int>::iterator i = 0; i != Segments.end(); i ++) /// len means the number of inappropriate segments  
{
    //// linear interpolation of each segments
    int b = i->first;
    int e = i->second;
    int num = e - b + 1;
    float step = (arr[e+1]-arr[b-1]) / num; // For short. The case that b=0 or e=len-1 is not considered. 
    for(int j = b; j <= e; j ++)
        arr[j] = arr[j-1] + step;
}

intarr[]={1,3,11,2,24,13,5..}；
///查找不适当值的起始索引和结束索引
/// (2,2) (4,5).
int i=0；
std：：映射段；
如果（arr[i]>阈值）
{
int b=i；
while（arr[i]>阈值）
i++；
int e=i；
插入（std:：map:：value_type（b，e））；
}
///线性插值
for（std:：map:：iterator i=0；i！=Segments.end（）；i++）///len表示不适当的段数
{
////每段的线性插值
intb=i->first；
INTE=i->秒；
int num=e-b+1；
浮点步长=（arr[e+1]-arr[b-1]）/num；//简而言之，不考虑b=0或e=len-1的情况。
对于（int j=b；j我不太清楚你所说的“不适当元素的开始和结束索引”是什么意思，所以我假设你只是指索引

在这里使用向量将是一个很好的方法：

std::vector<int> the_stuff {1, 3, 11, 2, 24, 13, 5, ... };
std::vector<int>::iterator it = the_stuff.begin();

while (it != the_stuff.end()
{
   if (*it > 10) { // do stuff };
   etc.
}

std:：vector the_stuff{1,3,11,2,24,13,5，…}；
std:：vector:：iterator it=_stuff.begin（）；
while（it！=_stuff.end（）
{
如果（*it>10）{//do stuff}；
等
}

你明白了。使用a，应该会让事情变得更简单。你可以随意搜索/插入/获取索引/删除/等等。
如果你将数字存储在std:：vector中，你可以通过迭代器对数组进行迭代。一旦你找到符合条件且需要删除的元素，你就可以删除它，并且同时将迭代器分配给下一个元素。这将是最有效的方法：

下面是您的代码的外观：

std::vector<int> intVector;
for(auto it = intVector.begin(); it != intVector.end(); ++it)
{
    if (*it > 10)
    {
        it = intVector.erase(it);
    }
}

std:：vector intVector；
for（auto it=intVector.begin（）；it！=intVector.end（）；+it）
{
如果（*it>10）
{
it=intVector.erase（它）；
}
}
如果要搜索特定值，并替换向量中符合特定条件的项，则可以使用transform（）在一行中完成

也可以使用replace_if（），但鉴于对您的问题的模糊描述，我不知道替换值是否需要根据原始值变化（replace_if需要一个常量替换值）。因此，现在让我们使用std:：transform（）

#包括
#包括
结构变压器
{
bool此数字传输格式（int num）{
//您填写此项。如果需要更改数字，请返回true，否则返回false
}
整数编号（整数编号）{
//您填写此项。根据原始号码返回更改后的号码。
}
int运算符（）（int num）
{
如果（此数字传输格式（num））
返回数字（num）；
返回num；
}
};
int main（）
{
std：：向量intVector；
//...
std:：transform（intVector.begin（），intVector.end（），intVector.begin（），Transformer（））；
}

基本上，结构充当函数对象。对于intVector中的每个项，函数对象将对该数字进行操作。如果数字符合条件，则转换并返回该数字，否则返回原始数字

由于您没有真正阐明更改数字的标准，因此这种方法为问题的解决提供了更大的灵活性。您只需填写我在
Transformer
struct中保留的两个打开的函数，就可以正常工作了

如果您的需求更复杂，那么可以扩展函数对象转换器以包含成员变量，或者简单地说，可以根据您的需要使其变得复杂

还请记住，如果您要对这些事情进行计时，请计时发布、优化版本。不要计时“调试”或未优化的版本。
向我们展示您的一些代码如何？您是否尝试过简单地使用例如替换错误的值？而“大于1000”可以表示从1001到无穷大的任何值，在现代计算机上对数组中的数千个条目进行迭代真的很快。@JoachimPileborg，我必须通过线性插值计算新值。如果

不起作用，我担心

std:：replace\u。@Steve-然后看看我作为answ提供的std:：transform算法函数呃。函子会稍微复杂一点，但它应该能工作。哇。谢谢你的回答。但是我恐怕必须通过线性插值来计算新值。这意味着我必须得到两个合适的值，它们紧靠着不合适的值。顺便说一句，
发布
和
完全优化
确实是一个很好的方法方法。@Steve-我编辑了我的答案。基本上，你刚才所说的正是使用函数对象的原因——你的需求的复杂性可以直接编码到结构中。如果你需要“记住”值，然后您可以添加跟踪这些值的成员变量
#include <algorithm>
#include <vector>

struct Transformer 
{
   bool ThisNumberNeedsTransformation(int num) { 
     // you fill this in.  Return true if number needs to be changed, false otherwise
   }

   int TransformNumber(int num) {
      // you fill this in.  Return the changed number, given the original number.
   }

   int operator()(int num)
   {
      if ( ThisNumberNeedsTransformation(num) )
          return TransformNumber(num);
      return num;
   }
};

int main()
{
     std::vector<int> intVector;
     //...
     std::transform(intVector.begin(), intVector.end(), intVector.begin(), Transformer());
}