Question

如果当前元素右边的元素更大，我需要找到未排序列表中元素之间的最大差值。例如：

myList = [2, 3, 8, 0, 7].

函数应计算如下：

present element = 2.
is 3 > 2? Yes. Then 3-2 = 1
is 8 > 2? Yes. Then 8-2 = 6
is 0 > 2? No. Go to the next element.
is 7 > 2? Yes. Then 7-2 = 5 and so on

Finally my output = 7

我的第一个解决方案如下：

def maxDiff(a):
l = len(a)
arr = []
for i in range(l-1):
    for j in range(i+1, l):
        if a[j] > a[i]:
            diff = a[j] - a[i]
            arr.append(diff)
return (max(arr))

有人说这不是最佳解决方案。我提出了另一个解决方案，如下所示：

def maxDiff(a):
l = len(a)
diffList = []
for i in range(l-1):
    newList = a[i+1:]
    max1 = max(newList)
    difference = max1 - a[i]
    diffList.append(difference)
return (max(diffList))

我的问题是第二个解决方案正确吗？如果是，那是否是最佳选择？这两个功能的时间复杂度是多少？还有其他更理想的解决方案吗？

Answer 1

您的第二个解决方案仍然在每次迭代时重新计算前缀列表的最大值，而无需这样做。

我认为您的两个解决方案都是正确的，但是第二个解决方案仍然至少是二次O（n ^ 2），因为您正在for循环中执行线性时间运算（例如max()）。因此，请回答您的问题：不，这可能不是最佳解决方案。

如果我正确理解了该问题，则可以使用dynamic programming解决该问题。考虑以下代码：

def maxDiff(a):
    vmin = a[0]
    dmax = 0
    for i in range(len(a)):
        if (a[i] < vmin):
            vmin = a[i]
        elif (a[i] - vmin > dmax):
            dmax = a[i] - vmin
    return dmax

在这里，我们只是跟踪到目前为止所遇到的最小值和最大差值，因此使我们仅可以遍历列表一次，而无需存储任何其他列表或进行任何嵌套循环。因此，根据比较操作，此函数的运行时间应为线性O（n）。

Answer 2

def maxPairDiff(arr):
    listDiff=[]
    for p,i in enumerate(arr):
        evalList=[e for e in arr[p+1:] if e>i]
        if len(evalList)>0:
            listDiff.append(max(evalList)-i)
    return (max(listDiff))


givenList = [7, 9, 5, 6, 3, 2]
print ("Required result is {}".format(maxPairDiff(givenList)))

Answer 3

尽管有很多方法可以解决一个问题。我建议采用这种方式，因为这样会更快一些，并且更加Python化。

mylist = [2, 3, 8, 0, 7]
max_diff = max( [mylist[i+1]-mylist[i] for i in range(len(mylist)-1) if mylist[i]<mylist[i+1]] )

print(max_diff)

Python：列表中元素之间的最大差异

3 个答案: