Question

有没有一种简单的方法可以在一维数组中找到局部最大值？

假设我有一个数组：

[ 0,
  1,
  10, <- max
  8,  <- (ignore)
  3,
  0,
  0,
  4,
  6,  <- (ignore)
  10, <- max
  6,  <- (ignore)
  1,
  0,
  0,
  1,
  4,  <- max
  1,
  0 ]

我希望它找到10和4，但忽略8＆amp; 6，因为那些是10s。在数学上，如果它是一个函数，你可以找到导数等于零的位置。我不太确定如何在Javascript中执行此操作。

Answer 1

maxes = []
for (var i = 1; i < a.length - 1; ++i) {
    if (a[i-1] < a[i] && a[i] > a[i+1])
        maxes.push(a[i])
}

Answer 2

这将返回给定整数数组中所有峰值（局部最大值）的数组，同时处理高原：

function findPeaks(arr) {
  var peak;
  return arr.reduce(function(peaks, val, i) {
    if (arr[i+1] > arr[i]) {
      peak = arr[i+1];
    } else if ((arr[i+1] < arr[i]) && (typeof peak === 'number')) {
      peaks.push(peak);
      peak = undefined;
    }
    return peaks;
  }, []);
}

findPeaks([1,3,2,5,3])   // -> [3, 5]
findPeaks([1,3,3,3,2])   // -> [3]
findPeaks([-1,0,0,-1,3]) // -> [0]
findPeaks([5,3,3,3,4])   // -> []

请注意，数组的第一个和最后一个元素不被视为峰值，因为在数学函数的上下文中，我们不知道它们之前或之后是什么，因此无法判断它们是否为峰值。

Answer 3

此代码找到局部极值（min和max，其中第一个推导为0，并且），即使后面的元素具有相等的值（非唯一的极值 - 即。＆＃39; 3＆＃39;从1中选择，1,1,3,3,3,2,2,2）

var GoAsc  = false;      //ascending move
var GoDesc = false;      //descending move
var myInputArray = [];
var myExtremalsArray = [];
var firstDiff;

for (index = 0; index < (myArray.length - 1); index++) {
    //(myArray.length - 1) is because not to exceed array boundary, 
    //last array element does not have any follower to test it

  firstDiff = ( myArray[index] - myArray[index + 1] );

   if ( firstDiff > 0 )   { GoAsc  = true;  }
   if ( firstDiff < 0 )   { GoDesc = true;  }

   if ( GoAsc === true && GoDesc === true )  {  
        myExtremalsArray.push(myArray[index]);
        GoAsc  = false ;     
        GoDesc = false;     
        //if firstDiff > 0 ---> max
        //if firstDiff < 0 ---> min
      }

 }

Answer 4

简单的迭代怎么样？

var indexes = [];
var values = [0,1,10,8,3,0,0,4,6,10,6,1,0,0,1,4,1,0];
for (var i=1; i<values.length-1; i++)
    if (values[i] > values[i-1] && values[i] > values[i+1])
        indexes.push(i);

Answer 5

更具说明性的方法：

const values = [3, 2, 3, 6, 4, 1, 2, 3, 2, 1, 2, 3];

const findPeaks = arr => arr.filter((el, index) => {
  return el > arr[index - 1] && el > arr[index + 1]
});
  
console.log(findPeaks(values)); // => [6, 3]

Answer 6

这两种情况是你有一个峰值，一个大于前一个值的值，大于下一个值，一个高原，一个大于前一个值的值，等于下一个（s），直到找到必须少用的下一个不同的价值。

所以当找到一个平台时，临时从该位置创建一个数组'直到结束，并查找下一个不同的值（Array.prototype.find方法返回匹配条件的第一个值）并确保它是低于第一个高原值。

此特定函数将返回第一个平台值的索引。

function pickPeaks(arr){
  return arr.reduce( (res, val, i, self) => {
    if(
      // a peak when the value is greater than the previous and greater than the next
      val > self[i - 1] && val > self[i + 1] 
      || 
      // a plateau when the value is greater than the previuos and equal to the next and from there the next different value is less
      val > self[i - 1] && val === self[i + 1] && self.slice(i).find( item =>  item !== val ) < val 
    ){
      res.pos.push(i);
      res.peaks.push(val);
    }
    return res;
  }, { pos:[],peaks:[] } );
}

console.log(pickPeaks([3,2,3,6,4,1,2,3,2,1,2,3])) //{pos:[3,7],peaks:[6,3]}
console.log(pickPeaks([-1, 0, -1])) //{pos:[1],peaks:[0]}
console.log(pickPeaks([1, 2, NaN, 3, 1])) //{pos:[],peaks:[]}
console.log(pickPeaks([1, 2, 2, 2, 1])) //{pos: [1], peaks: [2]} (plateau!)

Answer 7

一个 Python 实现，有几点

避免使用reduce以更容易查看算法
第一项和最后一项被认为是高峰（这可能是一项要求，例如在面试中）
添加高原中的所有值
可以在平台期开始或结束

def findPeaks(points: List[int]) -> List[int]:
    peaks, peak = [], []

    if points[0] >= points[1]:  # handle first
        peak.append(points[0])

    for i in range(1, len(points)):
        prv = points[i - 1]
        cur = points[i]

        if cur > prv:  # start peak
            peak = [cur]
        elif cur == prv:  # existing peak (plateau)
            peak.append(cur)
        elif cur < prv and len(peak):  # end peak
            peaks.extend(peak)
            peak = []

    if len(peak) and len(peak) != len(points):  # ended on a plateau
        peaks.extend(peak)

    return peaks

if __name__ == "__main__":
    print(findPeaks([1, 2, 3, 4, 5, 4, 3, 2, 1]))   # [5]
    print(findPeaks([1, 2, 1, 2, 1]))               # [2, 2]
    print(findPeaks([8, 1, 1, 1, 1, 1, 9]))         # [0, 6]
    print(findPeaks([1, 1, 1, 1, 1]))               # []
    print(findPeaks([1, 6, 6, 6, 1]))               # [6, 6, 6]

在1D阵列中查找局部最大值

7 个答案: