遍历数组以在线性时间内找到第二大元素

Question

有没有一种方法可以在线性时间内找到数组的第二大元素？ 数组元素可以是正数、负数或零。 元素可以重复。 不允许使用 STL。 可以使用 Python。

解决方案：对数组进行排序并取第二个元素，但不允许排序

修改：根据定义，第二大元素将是数值较小的元素。就像我们有

Arr = {5,5,4,3,1} 然后第二大是4

加法 可以说，如果我想将问题推广到第 k 个最大且复杂度小于 nlogn 之类的线性问题，那么解决方案是什么。

Answer 1

遍历数组，保留 2 个内存槽来记录目前看到的最大的 2 个元素。返回两者中较小的一个。

....这个问题有什么我看不到的棘手之处吗？

Answer 2

可以，这是伪算法：

max = 2max = SMALLEST_INT_VALUE;

for element in v:
   if element > max:
      2max = max;
      max = element;

  else if element > 2max:
      2max = element;

2max 是您要查找的值。

算法不会在特定情况下返回正确的值，例如元素相等的数组。

Answer 3

如果你想要一个真正的 O(n) 算法，并且想要在数组中找到第 n 个最大的元素，那么你应该使用 quickselect（它基本上是快速排序，你扔掉你不感兴趣的分区），下面是一篇很棒的文章，带有运行时分析：

http://pine.cs.yale.edu/pinewiki/QuickSelect

Answer 4

伪代码：

int max[2] = { array[0], array[1] }

if(max[1] < max[0]) swap them

for (int i = 2; i < array.length(); i++) {
  if(array[i] >= max[0]) max[1] = max[0]; max[0] = array[i]
  else if(array[i] >= max[1]) max[1] = array[i];
}

现在，max 数组包含最多 2 个元素。

Answer 5

• 创建一个大小为 3 的临时数组，
• 在那里复制前 3 个元素，
• 对临时数组进行排序，
• 用源数组中的第 4 个元素替换临时数组中的最后一个元素，
• 对临时数组进行排序，
• 用源数组中的第 5 个元素替换临时数组中的最后一个元素，
• 对临时数组进行排序，
• 等

对大小为 3 的数组进行排序是常数时间，您对源数组的每个元素执行一次，因此总体时间是线性的。

Answer 6

是的。您将其标记为 C/C++，但您提到可以在 Python 中完成。无论如何，这是算法：

1. 创建数组（显然）。
2. 如果第一项大于第二项，则将第一个变量设置为第一项，将第二个变量设置为第二项。否则，反之亦然。
3. 遍历所有项目（前两项除外）。
4. 如果数组中的项大于第一个变量，则将第二个变量设置为第一个变量，将第一个变量设置为该项。否则，如果项目大于第二个变量，则将第二个变量设置为项目。

第二个变量是你的答案。

list = [-1,6,9,2,0,2,8,10,8,-10]

if list[0] > list[1]:
        first = list[0]
        second = list[1]
else:
        first = list[1]
        second = list[0]

for i in range(2, len(list)):
        if list[i] > first:
                first, second = list[i], first
        elif list[i] > second:
                second = list[i]

print("First:", first)
print("Second:", second)

Answer 7

// assuming that v is the array and length is its length
int m1 = max(v[0], v[1]), m2 = min(v[0], v[1]);

for (int i=2; i<length; i++) {
  if (likely(m2 >= v[i]))
    continue;
  if (unlikely(m1 < v[i]))
    m2 = m1, m1 = v[i];
  else
    m2 = v[i];
}

您需要的结果以 m2 为单位（出于性能目的，可能和不太可能将宏定义为 here，如果不需要它们，您可以简单地删除它们）。

Answer 8

我认为其他答案没有考虑这样一个事实，即在像 [0, 1, 1] 这样的数组中，第二大是 0（根据更新的问题定义）。此外，所有提到的快速选择都不是 O(n) 而是 O(n^2)，并且所做的工作比必要的要多得多（最重要的是问题陈述不允许的排序算法）。这是一个与 Simone 非常相似的算法，但经过更新以返回第二大唯一元素：

def find_second(numbers):
    top = numbers[0]
    second = None

    for num in numbers[1:]:
        if second is None:
            if num < top: second = num
            elif num > top:
                second = top
                top = num
        else:
            if num > second:
                if num > top:
                    second = top
                    top = num
                elif num < top: second = num

    if second is not None: return second
    return top

if __name__ == '__main__':
    print "The second largest is %d" % find_second([1,2,3,4,4,5,5])

Answer 9

// Second larger element and its position(s)
    int[] tab = { 12, 1, 21, 12, 8, 8, 1 };
    int[] tmp = Arrays.copyOf(tab, tab.length);
    int secMax = 0;
    Arrays.sort(tmp);
    secMax = tmp[tmp.length - 2];
    System.out.println(secMax);
    List<Integer> positions = new ArrayList<>();
    for (int i = 0; i < tab.length; i++) {
        if (tab[i] == secMax) {
            positions.add(i);
        }
    }
    System.out.println(positions);