Question

正如标题所说，有没有有效的方法使用递归来查找数组中的第二大元素？

Answer 1

partition based Selection algorithm本质上是递归的，它允许您选择数组中的k'元素，因此使用它 - 您实际上可以找到任何答案k，包括k = n-1（您的情况）。

这在O(n)平均以相当低的常数完成。

Answer 2

如果对阵列一无所知，那么无论是递归还是迭代，你都不能比O(n)做得更好。

以递归方式传递数组，同时传递两个最大的元素，并在找到更大的值时替换它们。

find_largest(array_begin, largest, secondLargest)
    if (array_begin = NULL)
       return secondLargest
    if (array_begin.value > largest)
       secondLargest = largest
       largest = array_begin.value
    return find_largest(array_begin+1, largest, secondLargest)

largest和secondLargest最初可以设置为您希望在数组中找到的最小值。

你是对的，排序（至少完全排序）是过度的。

Answer 3

像O(n)这样的东西：

int findSecondLargest(int[] arr, int index, int largest, int secondLargest) {
    if(index == arr.length) {
        return secondLargest;
    }
    int element = arr[index];
    if(element > secondLargest) {
        if(element > largest) {
            return findSecondLargest(arr, index + 1, element, largest);
        } else {
            return findSecondLargest(arr, index + 1, largest, element);
        }
    }
    return findSecondLargest(arr, index + 1, largest, secondLargest);
}

Answer 4

    public void recurs(int[] data, int ind, int max1, int max2){
        if(ind<data.length){
            if(data[ind]>max1){
                int temp = max1;
                max1 = data[ind];
                max2 = temp;
            } else if(data[ind]>max2){
                max2 = data[ind];
            }
            recurs(data, ind+1, max1, max2);
        } else {
            return max2;
        }
        return -1;
    }

来称呼它： recurs（dataX，0，Integer.MIN_VALUE，Integer.MIN_VALUE）;

Answer 5

本能地，您可以扫描数组并对每个值进行两次比较。无论如何，你需要O（n）来解决问题。它足够快。

在没有必要时尽量避免递归，因为它不是免费的。

Answer 6

如果你通过递归来做，那么最多你必须做3（n）/ 2-2比较但是为了更好的解决方案，将这个问题想象成具有n个节点的二叉树。然后将进行n-1比较以找到第二大的最大和log（n）-1比较。但有些人认为它需要n + log（n）比较。

使用递归查找数组中的第二大元素

6 个答案: