当有多个峰时如何在数组中找到峰元素？

Question

对于具有单个峰值元素的数组，可以使用二进制搜索在 o(logn) 中完成，但是如果数组中有多个峰值元素，我们应该使用什么方法？

---提供更多信息---- 一个峰值元素是比它的邻居更大的东西，例如，看看下面的数组，

[1,3,20,4,1,0,7,5,2]

里面有2个山峰，20个和7个。

我们需要设计一个算法来找到这个数组中的峰值元素。

Answer 1

我可能不明白你的问题，因为找到单峰可以在 O(logn) 中完成，需要首先对数组进行排序。

我建议您存储一个差异数组，该数组将生成如下输出：[1,3,20,4,1,0,7,5,2] => [1, 1,-1,-1,-1, 1,-1,-1] 这只是生成一个大小为n - 1 的数组并将增加的方向放在数组中。这可以在 O(n) 单程中完成。

在第二遍中，您将寻找 [1, -1] 对，这是出现峰值的地方。

如果要在起点和终点找到峰值，则需要检查起点是否为-1，终点是否为1。

希望这会有所帮助。

Answer 2

我最近在一个编程网站上遇到了类似的问题，但是除了找到峰值之外，还有另一个重要的限制。首先，可以有多个高峰，但也可以有高原！高原是出现在 arr: [1,2,2,2,1] 中的东西，在这种情况下，我们必须将峰值返回为 2。在问题中，我们还被要求返回峰值所在的第一个位置发生，所以在这种情况下，它将是位置 = 1。我们必须保持小心的唯一情况是在 arr: [1,2,2,2,3,4,5,1] 中，有峰值5 在倒数第二个位置，但没有高原，即使有一系列重复的第一眼看起来像高原。

因此，我考虑的基本算法是使用差异数组，正如已经建议的那样，使用 {1,0,-1}，当我们在连续流中获得一系列重复项时，我们使用 0。每当我们在检查差异数组时得到 0 时，我们就开始寻找第一个非零条目，无论它是 1 还是 -1 并相应地输出。但是我们必须再次注意，Difference 数组可能看起来像 Diff = [-1,1,-1,1,0,0,0]，在这种情况下没有高原，只有一个峰值。当输入 arr 时，python 代码如下所示：

n = len(arr)
if arr == []:
    return {"pos":[],"peaks":[]}
Diff = []
for i in range(0,n-1):
    if arr[i]< arr[i+1]:
        Diff.append(1)
    elif arr[i] == arr[i+1]:
        Diff.append(0)
    if arr[i] > arr[i+1]:
        Diff.append(-1)
pos = []
peaks = []
j = 0
for i in range(0,n-2):
    if Diff[i] == 1 and Diff[i+1] == -1:
        pos.append(i+1)
        peaks.append(arr[i+1])
    if Diff[i] == 1 and Diff[i+1] == 0:
        if Diff[i+1:] == [Diff[i+1]]:
            break
        j = i+1
        while(Diff[j] == 0 and j < n-2):
            j = j+1
        if Diff[j] == -1:
            pos.append(i+1)
            peaks.append(arr[i+1])


return {"pos":pos, "peaks":peaks} 

Answer 3

用于在有多个峰时查找所有峰元素。

class Solution(object):
    def findPeakElement(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        left, right = 0, len(nums) - 1
        while left < right:
            mid = left + right >> 1
            if nums[mid] < nums[mid + 1]:
                left = mid + 1
            else:
                right = mid
        return left

Answer 4

int arr[] = {50, 12, 13, 20, 16, 19, 11, 7, 24};
int size = sizeof(arr) / sizeof(arr[0]);

int peak_arr[size / 2];
int i, j, k = 0;
int next, previous = 0;

for(i = 0; i < size; i++){
    if(i + 1 == size){
        next = 0;
    }
    else{
        next = arr[i + 1];
    }
    
    if(arr[i] > next && arr[i] >= previous){
        peak_arr[k++] = arr[i];
    }
    previous = arr[i];
}

Answer 5

使用递归方法查找多个峰元素。

def Div(lst, low, high):
    mid = (low + high)//2
    if low > high:
        return ""
    else:
        if mid+1 < len(lst) and lst[mid] > lst[mid+1] and lst[mid] > lst[mid -1]:
            return str(lst[mid]) + " " + Div(lst, low, mid-1) + Div(lst, mid+1, high)
        else:
            return Div(lst, low, mid-1) + Div(lst, mid + 1, high)

def peak(lst):
    if lst == []:
        return "list is empty"
    elif len(lst) in [1, 2]:
        return "No peak"
    else:
        return Div(lst, 0, len(lst))

print(peak([0, 5, 2, 9, 1, 10, 1]))

Answer 6

这个想法是使用修改后的二进制搜索。

如果arr[mid+1]>arr[mid]，那么你的峰值总是在右半边。

如果arr[mid-1]>arr[mid]，那么您的峰值始终存在于左半部分。 因为 arr[i+1] 只有两个选项，要么大于 arr[i]，要么小于 arr[i-1]

我没有 java 实现，但这里有一个 python 实现。

def FindAPeak(arr, i, j):
    mid = (i+j)/2
    # if mid element is peak
    if (mid == len(arr)-1 or arr[mid] > arr[mid+1]) and (mid == 0 or arr[mid] > arr[mid-1]):
        return arr[mid]
    # when your peak exists in the right half
    if arr[mid] < arr[mid+1] and mid+1 < len(arr):
        return FindAPeak(arr, mid+1, j)
    # when your peak exists in the left half
    else:
        return FindAPeak(arr, i, mid-1)


In [31]: arr = [1,2,3,2,1]
    ...: FindAPeak(arr, 0, len(arr)-1)
    ...: 
Out[31]: 3


In [32]: 
    ...: arr = [1,2,3,4,5,6]
    ...: FindAPeak(arr, 0, len(arr)-1)
    ...: 
Out[32]: 6