C++ 我如何编写一个算法来寻找序列中从一个数字到另一个数字的最大跳跃？

如果您的序列是

4 2 1

，则最大的跳转是从4到2。如果您的序列是

3 10 5 16 8 4 2 1

，则最大的跳跃是从5到16

我已经做了一个算法，但是我不能完全确定我做错了什么（当我没有正确地进行循环，正确地设置变量，或者做其他事情时）。我不确定我需要什么来设置我的索引、BiggestDiff或CurrentDiff。我尝试使用while循环来比较向量中的每个数字，但得到了零（我假设是因为我将BiggestDiff设置为零）

如果有人能给我指出正确的方向，给我举个例子，或者别的什么，我将不胜感激

下面是我的代码

int findBiggestDiff(std::vector<int> sequence)
{
  int index = 0;
  int BiggestDiff = 0 ;
  int CurrentDiff = BiggestDiff;
  CurrentDiff = std::abs(sequence[index] - sequence[index + 1]);
  while (index < sequence.size())
  {
    if (CurrentDiff > BiggestDiff)
    {
      BiggestDiff = CurrentDiff;
    }

    return index;
  }
}

int findBiggestDiff（标准：：向量序列）
{
int指数=0；
int BiggestDiff=0；
int CurrentDiff=最大的diff；
CurrentDiff=std:：abs（序列[index]-序列[index+1]）；
while（索引BiggestDiff）
{
BiggestDiff=电流差；
}
收益指数；
}
}

试试这个：

{
    int indexOfBiggestJump = 0;
    int BiggestDiff = 0 ;
    int CurrentDiff = BiggestDiff;

    for(int i = 0; i < sequence.size() - 1; i++) {
        CurrentDiff = std::abs(sequence[i] - sequence[i + 1]);
        if (CurrentDiff > BiggestDiff)
        {
            BiggestDiff = CurrentDiff;
            indexOfBiggestJump = i;
        }
    }
    return indexOfBiggestJump;
}

{
int indexOfBiggestJump=0；
int BiggestDiff=0；
int CurrentDiff=最大的diff；
对于（int i=0；iBiggestDiff）
{
BiggestDiff=电流差；
indexOfBiggestJump=i；
}
}
返回indexOfBiggestJump；
}

您的代码中有几个错误

您的

返回索引

实际上什么都不做，只返回

索引

（始终为0）

您没有保存任何地方最大跳跃的索引

如果您查看的是位置

i

和

i+1

，则必须一直查看到

sequence.size（）-1

，否则将超出

sequence

的范围

---

您根本没有重新计算

CurrentDiff

。另外，中的

return

语句位于错误的位置。您可以这样做（未经测试）

int findLargest（const std:：vector&sequence）{
如果（sequence.size（）<2）返回-1；//如果没有至少两个元素，则没有任何有效元素。
int指数=0；
int biggestIndex=-1；
int biggestDiff=-1；
而（indexbiggestDiff）
{
//更新统计数据
最大指数=指数；
biggestDiff=电流差；
}
++指数；
}
返回最大索引
}
int main（）{
//…
int index=findLargest（序列）；
如果（索引！=-1）{
STD：在你的while循环中的CUT，你没有计算“代码> CurrutDIFF……而且你正在做一个<代码>返回<代码>……你还需要记住这两个数字，这给了你最大的不同。如果你有帮助的话，考虑接受一个答案。你应该解释或注释你的代码是如何解决OP问题的。
int findLargest( const std::vector<int> &sequence ) {
  if ( sequence.size() < 2 ) return -1; // if there's not at least two elements, there's nothing valid.
  int index = 0;
  int biggestIndex = -1;
  int biggestDiff = -1;

  while (index < sequence.size() - 1) // -1 so that the +1 below doesn't go out of range
  {
    // get the current difference
    int currentDiff = std::abs(sequence[index] - sequence[index + 1]);
    if (currentDiff > biggestDiff)
    {
       // update stats
       biggestIndex = index;
       biggestDiff = currentDiff;
    }
    ++index;
  }
  return biggestIndex
}

int main() {
   //…
   int index = findLargest( sequence );
   if ( index != -1 ) {
       std::cout << "Biggest difference was between " << sequence[index] << " and " << sequence[index+1];
   }
}